gravityview / GravityView

vendor/paragonie/sodium_compat/src/Compat.php

Spacing +1080 added lines, -1080 removed lines

@@ -21,7 +21,7 @@ 
  * CAUTION * CAUTION * CAUTION * CAUTION * CAUTION * CAUTION * CAUTION * CAUTION *
  */
 
-if (class_exists('ParagonIE_Sodium_Compat', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Compat', false ) ) {
     return;
 }
 
@@ -155,23 +155,23 @@ 
      * @return void
      * @throws SodiumException
      */
-    public static function add(&$val, $addv)
+    public static function add( &$val, $addv )
     {
-        $val_len = ParagonIE_Sodium_Core_Util::strlen($val);
-        $addv_len = ParagonIE_Sodium_Core_Util::strlen($addv);
-        if ($val_len !== $addv_len) {
-            throw new SodiumException('values must have the same length');
+        $val_len = ParagonIE_Sodium_Core_Util::strlen( $val );
+        $addv_len = ParagonIE_Sodium_Core_Util::strlen( $addv );
+        if ( $val_len !== $addv_len ) {
+            throw new SodiumException( 'values must have the same length' );
         }
-        $A = ParagonIE_Sodium_Core_Util::stringToIntArray($val);
-        $B = ParagonIE_Sodium_Core_Util::stringToIntArray($addv);
+        $A = ParagonIE_Sodium_Core_Util::stringToIntArray( $val );
+        $B = ParagonIE_Sodium_Core_Util::stringToIntArray( $addv );
 
         $c = 0;
-        for ($i = 0; $i < $val_len; $i++) {
-            $c += ($A[$i] + $B[$i]);
-            $A[$i] = ($c & 0xff);
+        for ( $i = 0; $i < $val_len; $i++ ) {
+            $c += ( $A[ $i ] + $B[ $i ] );
+            $A[ $i ] = ( $c & 0xff );
             $c >>= 8;
         }
-        $val = ParagonIE_Sodium_Core_Util::intArrayToString($A);
+        $val = ParagonIE_Sodium_Core_Util::intArrayToString( $A );
     }
 
     /**
@@ -181,40 +181,40 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function base642bin($encoded, $variant, $ignore = '')
+    public static function base642bin( $encoded, $variant, $ignore = '' )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($encoded, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $encoded, 'string', 1 );
 
         /** @var string $encoded */
-        $encoded = (string) $encoded;
-        if (ParagonIE_Sodium_Core_Util::strlen($encoded) === 0) {
+        $encoded = (string)$encoded;
+        if ( ParagonIE_Sodium_Core_Util::strlen( $encoded ) === 0 ) {
             return '';
         }
 
         // Just strip before decoding
-        if (!empty($ignore)) {
-            $encoded = str_replace($ignore, '', $encoded);
+        if ( ! empty( $ignore ) ) {
+            $encoded = str_replace( $ignore, '', $encoded );
         }
 
         try {
-            switch ($variant) {
+            switch ( $variant ) {
                 case self::BASE64_VARIANT_ORIGINAL:
-                    return ParagonIE_Sodium_Core_Base64_Original::decode($encoded, true);
+                    return ParagonIE_Sodium_Core_Base64_Original::decode( $encoded, true );
                 case self::BASE64_VARIANT_ORIGINAL_NO_PADDING:
-                    return ParagonIE_Sodium_Core_Base64_Original::decode($encoded, false);
+                    return ParagonIE_Sodium_Core_Base64_Original::decode( $encoded, false );
                 case self::BASE64_VARIANT_URLSAFE:
-                    return ParagonIE_Sodium_Core_Base64_UrlSafe::decode($encoded, true);
+                    return ParagonIE_Sodium_Core_Base64_UrlSafe::decode( $encoded, true );
                 case self::BASE64_VARIANT_URLSAFE_NO_PADDING:
-                    return ParagonIE_Sodium_Core_Base64_UrlSafe::decode($encoded, false);
+                    return ParagonIE_Sodium_Core_Base64_UrlSafe::decode( $encoded, false );
                 default:
-                    throw new SodiumException('invalid base64 variant identifier');
+                    throw new SodiumException( 'invalid base64 variant identifier' );
             }
-        } catch (Exception $ex) {
-            if ($ex instanceof SodiumException) {
+        } catch ( Exception $ex ) {
+            if ( $ex instanceof SodiumException ) {
                 throw $ex;
             }
-            throw new SodiumException('invalid base64 string');
+            throw new SodiumException( 'invalid base64 string' );
         }
     }
 
@@ -224,27 +224,27 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function bin2base64($decoded, $variant)
+    public static function bin2base64( $decoded, $variant )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($decoded, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $decoded, 'string', 1 );
         /** @var string $decoded */
-        $decoded = (string) $decoded;
-        if (ParagonIE_Sodium_Core_Util::strlen($decoded) === 0) {
+        $decoded = (string)$decoded;
+        if ( ParagonIE_Sodium_Core_Util::strlen( $decoded ) === 0 ) {
             return '';
         }
 
-        switch ($variant) {
+        switch ( $variant ) {
             case self::BASE64_VARIANT_ORIGINAL:
-                return ParagonIE_Sodium_Core_Base64_Original::encode($decoded);
+                return ParagonIE_Sodium_Core_Base64_Original::encode( $decoded );
             case self::BASE64_VARIANT_ORIGINAL_NO_PADDING:
-                return ParagonIE_Sodium_Core_Base64_Original::encodeUnpadded($decoded);
+                return ParagonIE_Sodium_Core_Base64_Original::encodeUnpadded( $decoded );
             case self::BASE64_VARIANT_URLSAFE:
-                return ParagonIE_Sodium_Core_Base64_UrlSafe::encode($decoded);
+                return ParagonIE_Sodium_Core_Base64_UrlSafe::encode( $decoded );
             case self::BASE64_VARIANT_URLSAFE_NO_PADDING:
-                return ParagonIE_Sodium_Core_Base64_UrlSafe::encodeUnpadded($decoded);
+                return ParagonIE_Sodium_Core_Base64_UrlSafe::encodeUnpadded( $decoded );
             default:
-                throw new SodiumException('invalid base64 variant identifier');
+                throw new SodiumException( 'invalid base64 variant identifier' );
         }
     }
 
@@ -257,18 +257,18 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function bin2hex($string)
+    public static function bin2hex( $string )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $string, 'string', 1 );
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_bin2hex($string);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_bin2hex( $string );
         }
-        if (self::use_fallback('bin2hex')) {
-            return (string) call_user_func('\\Sodium\\bin2hex', $string);
+        if ( self::use_fallback( 'bin2hex' ) ) {
+            return (string)call_user_func( '\\Sodium\\bin2hex', $string );
         }
-        return ParagonIE_Sodium_Core_Util::bin2hex($string);
+        return ParagonIE_Sodium_Core_Util::bin2hex( $string );
     }
 
     /**
@@ -284,19 +284,19 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function compare($left, $right)
+    public static function compare( $left, $right )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($left, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($right, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $left, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $right, 'string', 2 );
 
-        if (self::useNewSodiumAPI()) {
-            return (int) sodium_compare($left, $right);
+        if ( self::useNewSodiumAPI() ) {
+            return (int)sodium_compare( $left, $right );
         }
-        if (self::use_fallback('compare')) {
-            return (int) call_user_func('\\Sodium\\compare', $left, $right);
+        if ( self::use_fallback( 'compare' ) ) {
+            return (int)call_user_func( '\\Sodium\\compare', $left, $right );
         }
-        return ParagonIE_Sodium_Core_Util::compare($left, $right);
+        return ParagonIE_Sodium_Core_Util::compare( $left, $right );
     }
 
     /**
@@ -309,21 +309,21 @@ 
      */
     public static function crypto_aead_aes256gcm_is_available()
     {
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             return sodium_crypto_aead_aes256gcm_is_available();
         }
-        if (self::use_fallback('crypto_aead_aes256gcm_is_available')) {
-            return call_user_func('\\Sodium\\crypto_aead_aes256gcm_is_available');
+        if ( self::use_fallback( 'crypto_aead_aes256gcm_is_available' ) ) {
+            return call_user_func( '\\Sodium\\crypto_aead_aes256gcm_is_available' );
         }
-        if (PHP_VERSION_ID < 70100) {
+        if ( PHP_VERSION_ID < 70100 ) {
             // OpenSSL doesn't support AEAD before 7.1.0
             return false;
         }
-        if (!is_callable('openssl_encrypt') || !is_callable('openssl_decrypt')) {
+        if ( ! is_callable( 'openssl_encrypt' ) || ! is_callable( 'openssl_decrypt' ) ) {
             // OpenSSL isn't installed
             return false;
         }
-        return (bool) in_array('aes-256-gcm', openssl_get_cipher_methods());
+        return (bool)in_array( 'aes-256-gcm', openssl_get_cipher_methods() );
     }
 
     /**
@@ -353,32 +353,32 @@ 
         $nonce = '',
         $key = ''
     ) {
-        if (!self::crypto_aead_aes256gcm_is_available()) {
-            throw new SodiumException('AES-256-GCM is not available');
+        if ( ! self::crypto_aead_aes256gcm_is_available() ) {
+            throw new SodiumException( 'AES-256-GCM is not available' );
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_AES256GCM_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_AES256GCM_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_AES256GCM_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_AES256GCM_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_AES256GCM_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_AES256GCM_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_AES256GCM_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_AES256GCM_KEYBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($ciphertext) < self::CRYPTO_AEAD_AES256GCM_ABYTES) {
-            throw new SodiumException('Message must be at least CRYPTO_AEAD_AES256GCM_ABYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $ciphertext ) < self::CRYPTO_AEAD_AES256GCM_ABYTES ) {
+            throw new SodiumException( 'Message must be at least CRYPTO_AEAD_AES256GCM_ABYTES long' );
         }
-        if (!is_callable('openssl_decrypt')) {
-            throw new SodiumException('The OpenSSL extension is not installed, or openssl_decrypt() is not available');
+        if ( ! is_callable( 'openssl_decrypt' ) ) {
+            throw new SodiumException( 'The OpenSSL extension is not installed, or openssl_decrypt() is not available' );
         }
 
         /** @var string $ctext */
-        $ctext = ParagonIE_Sodium_Core_Util::substr($ciphertext, 0, -self::CRYPTO_AEAD_AES256GCM_ABYTES);
+        $ctext = ParagonIE_Sodium_Core_Util::substr( $ciphertext, 0, -self::CRYPTO_AEAD_AES256GCM_ABYTES );
         /** @var string $authTag */
-        $authTag = ParagonIE_Sodium_Core_Util::substr($ciphertext, -self::CRYPTO_AEAD_AES256GCM_ABYTES, 16);
+        $authTag = ParagonIE_Sodium_Core_Util::substr( $ciphertext, -self::CRYPTO_AEAD_AES256GCM_ABYTES, 16 );
         return openssl_decrypt(
             $ctext,
             'aes-256-gcm',
@@ -413,24 +413,24 @@ 
         $nonce = '',
         $key = ''
     ) {
-        if (!self::crypto_aead_aes256gcm_is_available()) {
-            throw new SodiumException('AES-256-GCM is not available');
+        if ( ! self::crypto_aead_aes256gcm_is_available() ) {
+            throw new SodiumException( 'AES-256-GCM is not available' );
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_AES256GCM_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_AES256GCM_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_AES256GCM_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_AES256GCM_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_AES256GCM_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_AES256GCM_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_AES256GCM_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_AES256GCM_KEYBYTES long' );
         }
 
-        if (!is_callable('openssl_encrypt')) {
-            throw new SodiumException('The OpenSSL extension is not installed, or openssl_encrypt() is not available');
+        if ( ! is_callable( 'openssl_encrypt' ) ) {
+            throw new SodiumException( 'The OpenSSL extension is not installed, or openssl_encrypt() is not available' );
         }
 
         $authTag = '';
@@ -456,7 +456,7 @@ 
      */
     public static function crypto_aead_aes256gcm_keygen()
     {
-        return random_bytes(self::CRYPTO_AEAD_AES256GCM_KEYBYTES);
+        return random_bytes( self::CRYPTO_AEAD_AES256GCM_KEYBYTES );
     }
 
     /**
@@ -487,23 +487,23 @@ 
         $key = ''
     ) {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($ciphertext) < self::CRYPTO_AEAD_CHACHA20POLY1305_ABYTES) {
-            throw new SodiumException('Message must be at least CRYPTO_AEAD_CHACHA20POLY1305_ABYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $ciphertext ) < self::CRYPTO_AEAD_CHACHA20POLY1305_ABYTES ) {
+            throw new SodiumException( 'Message must be at least CRYPTO_AEAD_CHACHA20POLY1305_ABYTES long' );
         }
 
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             /**
              * @psalm-suppress InvalidReturnStatement
              * @psalm-suppress FalsableReturnStatement
@@ -515,7 +515,7 @@ 
                 $key
             );
         }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_decrypt')) {
+        if ( self::use_fallback( 'crypto_aead_chacha20poly1305_decrypt' ) ) {
             return call_user_func(
                 '\\Sodium\\crypto_aead_chacha20poly1305_decrypt',
                 $ciphertext,
@@ -524,7 +524,7 @@ 
                 $key
             );
         }
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_decrypt(
                 $ciphertext,
                 $assocData,
@@ -567,29 +567,29 @@ 
         $key = ''
     ) {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_aead_chacha20poly1305_encrypt(
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_aead_chacha20poly1305_encrypt(
                 $plaintext,
                 $assocData,
                 $nonce,
                 $key
             );
         }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_encrypt')) {
-            return (string) call_user_func(
+        if ( self::use_fallback( 'crypto_aead_chacha20poly1305_encrypt' ) ) {
+            return (string)call_user_func(
                 '\\Sodium\\crypto_aead_chacha20poly1305_encrypt',
                 $plaintext,
                 $assocData,
@@ -597,7 +597,7 @@ 
                 $key
             );
         }
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_encrypt(
                 $plaintext,
                 $assocData,
@@ -641,23 +641,23 @@ 
         $key = ''
     ) {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($ciphertext) < self::CRYPTO_AEAD_CHACHA20POLY1305_ABYTES) {
-            throw new SodiumException('Message must be at least CRYPTO_AEAD_CHACHA20POLY1305_ABYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $ciphertext ) < self::CRYPTO_AEAD_CHACHA20POLY1305_ABYTES ) {
+            throw new SodiumException( 'Message must be at least CRYPTO_AEAD_CHACHA20POLY1305_ABYTES long' );
         }
 
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             /**
              * @psalm-suppress InvalidReturnStatement
              * @psalm-suppress FalsableReturnStatement
@@ -669,7 +669,7 @@ 
                 $key
             );
         }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_ietf_decrypt')) {
+        if ( self::use_fallback( 'crypto_aead_chacha20poly1305_ietf_decrypt' ) ) {
             return call_user_func(
                 '\\Sodium\\crypto_aead_chacha20poly1305_ietf_decrypt',
                 $ciphertext,
@@ -678,7 +678,7 @@ 
                 $key
             );
         }
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_ietf_decrypt(
                 $ciphertext,
                 $assocData,
@@ -704,7 +704,7 @@ 
      */
     public static function crypto_aead_chacha20poly1305_keygen()
     {
-        return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES);
+        return random_bytes( self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES );
     }
 
     /**
@@ -734,31 +734,31 @@ 
         $key = ''
     ) {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        if (!is_null($assocData)) {
-            ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        if ( ! is_null( $assocData ) ) {
+            ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES long' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_aead_chacha20poly1305_ietf_encrypt(
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_aead_chacha20poly1305_ietf_encrypt(
                 $plaintext,
                 $assocData,
                 $nonce,
                 $key
             );
         }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_ietf_encrypt')) {
-            return (string) call_user_func(
+        if ( self::use_fallback( 'crypto_aead_chacha20poly1305_ietf_encrypt' ) ) {
+            return (string)call_user_func(
                 '\\Sodium\\crypto_aead_chacha20poly1305_ietf_encrypt',
                 $plaintext,
                 $assocData,
@@ -766,7 +766,7 @@ 
                 $key
             );
         }
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_ietf_encrypt(
                 $plaintext,
                 $assocData,
@@ -792,7 +792,7 @@ 
      */
     public static function crypto_aead_chacha20poly1305_ietf_keygen()
     {
-        return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES);
+        return random_bytes( self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES );
     }
 
     /**
@@ -823,27 +823,27 @@ 
         $dontFallback = false
     ) {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        if (!is_null($assocData)) {
-            ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        if ( ! is_null( $assocData ) ) {
+            ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
         } else {
             $assocData = '';
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($ciphertext) < self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES) {
-            throw new SodiumException('Message must be at least CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $ciphertext ) < self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES ) {
+            throw new SodiumException( 'Message must be at least CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES long' );
         }
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            if (is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            if ( is_callable( 'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt' ) ) {
                 return sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(
                     $ciphertext,
                     $assocData,
@@ -853,7 +853,7 @@ 
             }
         }
 
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_decrypt(
                 $ciphertext,
                 $assocData,
@@ -898,24 +898,24 @@ 
         $dontFallback = false
     ) {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        if (!is_null($assocData)) {
-            ParagonIE_Sodium_Core_Util::declareScalarType($assocData, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        if ( ! is_null( $assocData ) ) {
+            ParagonIE_Sodium_Core_Util::declareScalarType( $assocData, 'string', 2 );
         } else {
             $assocData = '';
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES) {
-            throw new SodiumException('Nonce must be CRYPTO_AEAD_XCHACHA20POLY1305_NPUBBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES ) {
+            throw new SodiumException( 'Nonce must be CRYPTO_AEAD_XCHACHA20POLY1305_NPUBBYTES long' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES) {
-            throw new SodiumException('Key must be CRYPTO_AEAD_XCHACHA20POLY1305_KEYBYTES long');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES ) {
+            throw new SodiumException( 'Key must be CRYPTO_AEAD_XCHACHA20POLY1305_KEYBYTES long' );
         }
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            if (is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            if ( is_callable( 'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt' ) ) {
                 return sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
                     $plaintext,
                     $assocData,
@@ -925,7 +925,7 @@ 
             }
         }
 
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_encrypt(
                 $plaintext,
                 $assocData,
@@ -951,7 +951,7 @@ 
      */
     public static function crypto_aead_xchacha20poly1305_ietf_keygen()
     {
-        return random_bytes(self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES);
+        return random_bytes( self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES );
     }
 
     /**
@@ -971,27 +971,27 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_auth($message, $key)
+    public static function crypto_auth( $message, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AUTH_KEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_AUTH_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AUTH_KEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_AUTH_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_auth($message, $key);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_auth( $message, $key );
         }
-        if (self::use_fallback('crypto_auth')) {
-            return (string) call_user_func('\\Sodium\\crypto_auth', $message, $key);
+        if ( self::use_fallback( 'crypto_auth' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_auth', $message, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::auth($message, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::auth( $message, $key );
         }
-        return ParagonIE_Sodium_Crypto::auth($message, $key);
+        return ParagonIE_Sodium_Crypto::auth( $message, $key );
     }
 
     /**
@@ -1001,7 +1001,7 @@ 
      */
     public static function crypto_auth_keygen()
     {
-        return random_bytes(self::CRYPTO_AUTH_KEYBYTES);
+        return random_bytes( self::CRYPTO_AUTH_KEYBYTES );
     }
 
     /**
@@ -1016,31 +1016,31 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_auth_verify($mac, $message, $key)
+    public static function crypto_auth_verify( $mac, $message, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($mac, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $mac, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($mac) !== self::CRYPTO_AUTH_BYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_AUTH_BYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $mac ) !== self::CRYPTO_AUTH_BYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_AUTH_BYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_AUTH_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_AUTH_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_AUTH_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_AUTH_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (bool) sodium_crypto_auth_verify($mac, $message, $key);
+        if ( self::useNewSodiumAPI() ) {
+            return (bool)sodium_crypto_auth_verify( $mac, $message, $key );
         }
-        if (self::use_fallback('crypto_auth_verify')) {
-            return (bool) call_user_func('\\Sodium\\crypto_auth_verify', $mac, $message, $key);
+        if ( self::use_fallback( 'crypto_auth_verify' ) ) {
+            return (bool)call_user_func( '\\Sodium\\crypto_auth_verify', $mac, $message, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::auth_verify($mac, $message, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::auth_verify( $mac, $message, $key );
         }
-        return ParagonIE_Sodium_Crypto::auth_verify($mac, $message, $key);
+        return ParagonIE_Sodium_Crypto::auth_verify( $mac, $message, $key );
     }
 
     /**
@@ -1060,31 +1060,31 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_box($plaintext, $nonce, $keypair)
+    public static function crypto_box( $plaintext, $nonce, $keypair )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_BOX_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_BOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_BOX_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_BOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box($plaintext, $nonce, $keypair);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box( $plaintext, $nonce, $keypair );
         }
-        if (self::use_fallback('crypto_box')) {
-            return (string) call_user_func('\\Sodium\\crypto_box', $plaintext, $nonce, $keypair);
+        if ( self::use_fallback( 'crypto_box' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box', $plaintext, $nonce, $keypair );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box($plaintext, $nonce, $keypair);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box( $plaintext, $nonce, $keypair );
         }
-        return ParagonIE_Sodium_Crypto::box($plaintext, $nonce, $keypair);
+        return ParagonIE_Sodium_Crypto::box( $plaintext, $nonce, $keypair );
     }
 
     /**
@@ -1104,27 +1104,27 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_box_seal($plaintext, $publicKey)
+    public static function crypto_box_seal( $plaintext, $publicKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($publicKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $publicKey, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($publicKey) !== self::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $publicKey ) !== self::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box_seal($plaintext, $publicKey);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box_seal( $plaintext, $publicKey );
         }
-        if (self::use_fallback('crypto_box_seal')) {
-            return (string) call_user_func('\\Sodium\\crypto_box_seal', $plaintext, $publicKey);
+        if ( self::use_fallback( 'crypto_box_seal' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box_seal', $plaintext, $publicKey );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_seal($plaintext, $publicKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_seal( $plaintext, $publicKey );
         }
-        return ParagonIE_Sodium_Crypto::box_seal($plaintext, $publicKey);
+        return ParagonIE_Sodium_Crypto::box_seal( $plaintext, $publicKey );
     }
 
     /**
@@ -1142,31 +1142,31 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress MixedReturnStatement
      */
-    public static function crypto_box_seal_open($ciphertext, $keypair)
+    public static function crypto_box_seal_open( $ciphertext, $keypair )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             /**
              * @psalm-suppress InvalidReturnStatement
              * @psalm-suppress FalsableReturnStatement
              */
-            return sodium_crypto_box_seal_open($ciphertext, $keypair);
+            return sodium_crypto_box_seal_open( $ciphertext, $keypair );
         }
-        if (self::use_fallback('crypto_box_seal_open')) {
-            return call_user_func('\\Sodium\\crypto_box_seal_open', $ciphertext, $keypair);
+        if ( self::use_fallback( 'crypto_box_seal_open' ) ) {
+            return call_user_func( '\\Sodium\\crypto_box_seal_open', $ciphertext, $keypair );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_seal_open($ciphertext, $keypair);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_seal_open( $ciphertext, $keypair );
         }
-        return ParagonIE_Sodium_Crypto::box_seal_open($ciphertext, $keypair);
+        return ParagonIE_Sodium_Crypto::box_seal_open( $ciphertext, $keypair );
     }
 
     /**
@@ -1182,13 +1182,13 @@ 
      */
     public static function crypto_box_keypair()
     {
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box_keypair();
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box_keypair();
         }
-        if (self::use_fallback('crypto_box_keypair')) {
-            return (string) call_user_func('\\Sodium\\crypto_box_keypair');
+        if ( self::use_fallback( 'crypto_box_keypair' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box_keypair' );
         }
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::box_keypair();
         }
         return ParagonIE_Sodium_Crypto::box_keypair();
@@ -1205,30 +1205,30 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_box_keypair_from_secretkey_and_publickey($secretKey, $publicKey)
+    public static function crypto_box_keypair_from_secretkey_and_publickey( $secretKey, $publicKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($publicKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $secretKey, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $publicKey, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($secretKey) !== self::CRYPTO_BOX_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $secretKey ) !== self::CRYPTO_BOX_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($publicKey) !== self::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $publicKey ) !== self::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box_keypair_from_secretkey_and_publickey($secretKey, $publicKey);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box_keypair_from_secretkey_and_publickey( $secretKey, $publicKey );
         }
-        if (self::use_fallback('crypto_box_keypair_from_secretkey_and_publickey')) {
-            return (string) call_user_func('\\Sodium\\crypto_box_keypair_from_secretkey_and_publickey', $secretKey, $publicKey);
+        if ( self::use_fallback( 'crypto_box_keypair_from_secretkey_and_publickey' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box_keypair_from_secretkey_and_publickey', $secretKey, $publicKey );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_keypair_from_secretkey_and_publickey($secretKey, $publicKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_keypair_from_secretkey_and_publickey( $secretKey, $publicKey );
         }
-        return ParagonIE_Sodium_Crypto::box_keypair_from_secretkey_and_publickey($secretKey, $publicKey);
+        return ParagonIE_Sodium_Crypto::box_keypair_from_secretkey_and_publickey( $secretKey, $publicKey );
     }
 
     /**
@@ -1244,38 +1244,38 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress MixedReturnStatement
      */
-    public static function crypto_box_open($ciphertext, $nonce, $keypair)
+    public static function crypto_box_open( $ciphertext, $nonce, $keypair )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($ciphertext) < self::CRYPTO_BOX_MACBYTES) {
-            throw new SodiumException('Argument 1 must be at least CRYPTO_BOX_MACBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $ciphertext ) < self::CRYPTO_BOX_MACBYTES ) {
+            throw new SodiumException( 'Argument 1 must be at least CRYPTO_BOX_MACBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_BOX_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_BOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_BOX_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_BOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             /**
              * @psalm-suppress InvalidReturnStatement
              * @psalm-suppress FalsableReturnStatement
              */
-            return sodium_crypto_box_open($ciphertext, $nonce, $keypair);
+            return sodium_crypto_box_open( $ciphertext, $nonce, $keypair );
         }
-        if (self::use_fallback('crypto_box_open')) {
-            return call_user_func('\\Sodium\\crypto_box_open', $ciphertext, $nonce, $keypair);
+        if ( self::use_fallback( 'crypto_box_open' ) ) {
+            return call_user_func( '\\Sodium\\crypto_box_open', $ciphertext, $nonce, $keypair );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_open($ciphertext, $nonce, $keypair);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_open( $ciphertext, $nonce, $keypair );
         }
-        return ParagonIE_Sodium_Crypto::box_open($ciphertext, $nonce, $keypair);
+        return ParagonIE_Sodium_Crypto::box_open( $ciphertext, $nonce, $keypair );
     }
 
     /**
@@ -1287,26 +1287,26 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_box_publickey($keypair)
+    public static function crypto_box_publickey( $keypair )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_BOX_KEYPAIRBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_BOX_KEYPAIRBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box_publickey($keypair);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box_publickey( $keypair );
         }
-        if (self::use_fallback('crypto_box_publickey')) {
-            return (string) call_user_func('\\Sodium\\crypto_box_publickey', $keypair);
+        if ( self::use_fallback( 'crypto_box_publickey' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box_publickey', $keypair );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_publickey($keypair);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_publickey( $keypair );
         }
-        return ParagonIE_Sodium_Crypto::box_publickey($keypair);
+        return ParagonIE_Sodium_Crypto::box_publickey( $keypair );
     }
 
     /**
@@ -1318,26 +1318,26 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_box_publickey_from_secretkey($secretKey)
+    public static function crypto_box_publickey_from_secretkey( $secretKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $secretKey, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($secretKey) !== self::CRYPTO_BOX_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $secretKey ) !== self::CRYPTO_BOX_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box_publickey_from_secretkey($secretKey);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box_publickey_from_secretkey( $secretKey );
         }
-        if (self::use_fallback('crypto_box_publickey_from_secretkey')) {
-            return (string) call_user_func('\\Sodium\\crypto_box_publickey_from_secretkey', $secretKey);
+        if ( self::use_fallback( 'crypto_box_publickey_from_secretkey' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box_publickey_from_secretkey', $secretKey );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_publickey_from_secretkey($secretKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_publickey_from_secretkey( $secretKey );
         }
-        return ParagonIE_Sodium_Crypto::box_publickey_from_secretkey($secretKey);
+        return ParagonIE_Sodium_Crypto::box_publickey_from_secretkey( $secretKey );
     }
 
     /**
@@ -1349,26 +1349,26 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_box_secretkey($keypair)
+    public static function crypto_box_secretkey( $keypair )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_BOX_KEYPAIRBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_BOX_KEYPAIRBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box_secretkey($keypair);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box_secretkey( $keypair );
         }
-        if (self::use_fallback('crypto_box_secretkey')) {
-            return (string) call_user_func('\\Sodium\\crypto_box_secretkey', $keypair);
+        if ( self::use_fallback( 'crypto_box_secretkey' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box_secretkey', $keypair );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_secretkey($keypair);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_secretkey( $keypair );
         }
-        return ParagonIE_Sodium_Crypto::box_secretkey($keypair);
+        return ParagonIE_Sodium_Crypto::box_secretkey( $keypair );
     }
 
     /**
@@ -1381,21 +1381,21 @@ 
      * @psalm-suppress MixedArgument
      * @psalm-suppress UndefinedFunction
      */
-    public static function crypto_box_seed_keypair($seed)
+    public static function crypto_box_seed_keypair( $seed )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $seed, 'string', 1 );
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_box_seed_keypair($seed);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_box_seed_keypair( $seed );
         }
-        if (self::use_fallback('crypto_box_seed_keypair')) {
-            return (string) call_user_func('\\Sodium\\crypto_box_seed_keypair', $seed);
+        if ( self::use_fallback( 'crypto_box_seed_keypair' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_box_seed_keypair', $seed );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_seed_keypair($seed);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::box_seed_keypair( $seed );
         }
-        return ParagonIE_Sodium_Crypto::box_seed_keypair($seed);
+        return ParagonIE_Sodium_Crypto::box_seed_keypair( $seed );
     }
 
     /**
@@ -1411,36 +1411,36 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_generichash($message, $key = '', $length = self::CRYPTO_GENERICHASH_BYTES)
+    public static function crypto_generichash( $message, $key = '', $length = self::CRYPTO_GENERICHASH_BYTES )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
-        if (is_null($key)) {
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 1 );
+        if ( is_null( $key ) ) {
             $key = '';
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($length, 'int', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $length, 'int', 3 );
 
         /* Input validation: */
-        if (!empty($key)) {
-            if (ParagonIE_Sodium_Core_Util::strlen($key) < self::CRYPTO_GENERICHASH_KEYBYTES_MIN) {
-                throw new SodiumException('Unsupported key size. Must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes long.');
+        if ( ! empty( $key ) ) {
+            if ( ParagonIE_Sodium_Core_Util::strlen( $key ) < self::CRYPTO_GENERICHASH_KEYBYTES_MIN ) {
+                throw new SodiumException( 'Unsupported key size. Must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes long.' );
             }
-            if (ParagonIE_Sodium_Core_Util::strlen($key) > self::CRYPTO_GENERICHASH_KEYBYTES_MAX) {
-                throw new SodiumException('Unsupported key size. Must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes long.');
+            if ( ParagonIE_Sodium_Core_Util::strlen( $key ) > self::CRYPTO_GENERICHASH_KEYBYTES_MAX ) {
+                throw new SodiumException( 'Unsupported key size. Must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes long.' );
             }
         }
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_generichash($message, $key, $length);
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_generichash( $message, $key, $length );
         }
-        if (self::use_fallback('crypto_generichash')) {
-            return (string) call_user_func('\\Sodium\\crypto_generichash', $message, $key, $length);
+        if ( self::use_fallback( 'crypto_generichash' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_generichash', $message, $key, $length );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::generichash($message, $key, $length);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::generichash( $message, $key, $length );
         }
-        return ParagonIE_Sodium_Crypto::generichash($message, $key, $length);
+        return ParagonIE_Sodium_Crypto::generichash( $message, $key, $length );
     }
 
     /**
@@ -1455,36 +1455,36 @@ 
      * @psalm-suppress ReferenceConstraintViolation
      * @psalm-suppress ConflictingReferenceConstraint
      */
-    public static function crypto_generichash_final(&$ctx, $length = self::CRYPTO_GENERICHASH_BYTES)
+    public static function crypto_generichash_final( &$ctx, $length = self::CRYPTO_GENERICHASH_BYTES )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ctx, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($length, 'int', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ctx, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $length, 'int', 2 );
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_generichash_final($ctx, $length);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_generichash_final( $ctx, $length );
         }
-        if (self::use_fallback('crypto_generichash_final')) {
+        if ( self::use_fallback( 'crypto_generichash_final' ) ) {
             $func = '\\Sodium\\crypto_generichash_final';
-            return (string) $func($ctx, $length);
+            return (string)$func( $ctx, $length );
         }
-        if ($length < 1) {
+        if ( $length < 1 ) {
             try {
-                self::memzero($ctx);
-            } catch (SodiumException $ex) {
-                unset($ctx);
+                self::memzero( $ctx );
+            } catch ( SodiumException $ex ) {
+                unset( $ctx );
             }
             return '';
         }
-        if (PHP_INT_SIZE === 4) {
-            $result = ParagonIE_Sodium_Crypto32::generichash_final($ctx, $length);
+        if ( PHP_INT_SIZE === 4 ) {
+            $result = ParagonIE_Sodium_Crypto32::generichash_final( $ctx, $length );
         } else {
-            $result = ParagonIE_Sodium_Crypto::generichash_final($ctx, $length);
+            $result = ParagonIE_Sodium_Crypto::generichash_final( $ctx, $length );
         }
         try {
-            self::memzero($ctx);
-        } catch (SodiumException $ex) {
-            unset($ctx);
+            self::memzero( $ctx );
+        } catch ( SodiumException $ex ) {
+            unset( $ctx );
         }
         return $result;
     }
@@ -1500,35 +1500,35 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_generichash_init($key = '', $length = self::CRYPTO_GENERICHASH_BYTES)
+    public static function crypto_generichash_init( $key = '', $length = self::CRYPTO_GENERICHASH_BYTES )
     {
         /* Type checks: */
-        if (is_null($key)) {
+        if ( is_null( $key ) ) {
             $key = '';
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($length, 'int', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $length, 'int', 2 );
 
         /* Input validation: */
-        if (!empty($key)) {
-            if (ParagonIE_Sodium_Core_Util::strlen($key) < self::CRYPTO_GENERICHASH_KEYBYTES_MIN) {
-                throw new SodiumException('Unsupported key size. Must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes long.');
+        if ( ! empty( $key ) ) {
+            if ( ParagonIE_Sodium_Core_Util::strlen( $key ) < self::CRYPTO_GENERICHASH_KEYBYTES_MIN ) {
+                throw new SodiumException( 'Unsupported key size. Must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes long.' );
             }
-            if (ParagonIE_Sodium_Core_Util::strlen($key) > self::CRYPTO_GENERICHASH_KEYBYTES_MAX) {
-                throw new SodiumException('Unsupported key size. Must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes long.');
+            if ( ParagonIE_Sodium_Core_Util::strlen( $key ) > self::CRYPTO_GENERICHASH_KEYBYTES_MAX ) {
+                throw new SodiumException( 'Unsupported key size. Must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes long.' );
             }
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_generichash_init($key, $length);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_generichash_init( $key, $length );
         }
-        if (self::use_fallback('crypto_generichash_init')) {
-            return (string) call_user_func('\\Sodium\\crypto_generichash_init', $key, $length);
+        if ( self::use_fallback( 'crypto_generichash_init' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_generichash_init', $key, $length );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::generichash_init($key, $length);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::generichash_init( $key, $length );
         }
-        return ParagonIE_Sodium_Crypto::generichash_init($key, $length);
+        return ParagonIE_Sodium_Crypto::generichash_init( $key, $length );
     }
 
     /**
@@ -1551,31 +1551,31 @@ 
         $personal = ''
     ) {
         /* Type checks: */
-        if (is_null($key)) {
+        if ( is_null( $key ) ) {
             $key = '';
         }
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($length, 'int', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($salt, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($personal, 'string', 4);
-        $salt = str_pad($salt, 16, "\0", STR_PAD_RIGHT);
-        $personal = str_pad($personal, 16, "\0", STR_PAD_RIGHT);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $length, 'int', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $salt, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $personal, 'string', 4 );
+        $salt = str_pad( $salt, 16, "\0", STR_PAD_RIGHT );
+        $personal = str_pad( $personal, 16, "\0", STR_PAD_RIGHT );
 
         /* Input validation: */
-        if (!empty($key)) {
+        if ( ! empty( $key ) ) {
             /*
             if (ParagonIE_Sodium_Core_Util::strlen($key) < self::CRYPTO_GENERICHASH_KEYBYTES_MIN) {
                 throw new SodiumException('Unsupported key size. Must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes long.');
             }
             */
-            if (ParagonIE_Sodium_Core_Util::strlen($key) > self::CRYPTO_GENERICHASH_KEYBYTES_MAX) {
-                throw new SodiumException('Unsupported key size. Must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes long.');
+            if ( ParagonIE_Sodium_Core_Util::strlen( $key ) > self::CRYPTO_GENERICHASH_KEYBYTES_MAX ) {
+                throw new SodiumException( 'Unsupported key size. Must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes long.' );
             }
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::generichash_init_salt_personal($key, $length, $salt, $personal);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::generichash_init_salt_personal( $key, $length, $salt, $personal );
         }
-        return ParagonIE_Sodium_Crypto::generichash_init_salt_personal($key, $length, $salt, $personal);
+        return ParagonIE_Sodium_Crypto::generichash_init_salt_personal( $key, $length, $salt, $personal );
     }
 
     /**
@@ -1591,25 +1591,25 @@ 
      * @psalm-suppress MixedArgument
      * @psalm-suppress ReferenceConstraintViolation
      */
-    public static function crypto_generichash_update(&$ctx, $message)
+    public static function crypto_generichash_update( &$ctx, $message )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ctx, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ctx, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 2 );
 
-        if (self::useNewSodiumAPI()) {
-            sodium_crypto_generichash_update($ctx, $message);
+        if ( self::useNewSodiumAPI() ) {
+            sodium_crypto_generichash_update( $ctx, $message );
             return;
         }
-        if (self::use_fallback('crypto_generichash_update')) {
+        if ( self::use_fallback( 'crypto_generichash_update' ) ) {
             $func = '\\Sodium\\crypto_generichash_update';
-            $func($ctx, $message);
+            $func( $ctx, $message );
             return;
         }
-        if (PHP_INT_SIZE === 4) {
-            $ctx = ParagonIE_Sodium_Crypto32::generichash_update($ctx, $message);
+        if ( PHP_INT_SIZE === 4 ) {
+            $ctx = ParagonIE_Sodium_Crypto32::generichash_update( $ctx, $message );
         } else {
-            $ctx = ParagonIE_Sodium_Crypto::generichash_update($ctx, $message);
+            $ctx = ParagonIE_Sodium_Crypto::generichash_update( $ctx, $message );
         }
     }
 
@@ -1620,7 +1620,7 @@ 
      */
     public static function crypto_generichash_keygen()
     {
-        return random_bytes(self::CRYPTO_GENERICHASH_KEYBYTES);
+        return random_bytes( self::CRYPTO_GENERICHASH_KEYBYTES );
     }
 
     /**
@@ -1637,39 +1637,39 @@ 
         $context,
         $key
     ) {
-        ParagonIE_Sodium_Core_Util::declareScalarType($subkey_len, 'int', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($subkey_id, 'int', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($context, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 4);
-        $subkey_id = (int) $subkey_id;
-        $subkey_len = (int) $subkey_len;
-        $context = (string) $context;
-        $key = (string) $key;
+        ParagonIE_Sodium_Core_Util::declareScalarType( $subkey_len, 'int', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $subkey_id, 'int', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $context, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 4 );
+        $subkey_id = (int)$subkey_id;
+        $subkey_len = (int)$subkey_len;
+        $context = (string)$context;
+        $key = (string)$key;
 
-        if ($subkey_len < self::CRYPTO_KDF_BYTES_MIN) {
-            throw new SodiumException('subkey cannot be smaller than SODIUM_CRYPTO_KDF_BYTES_MIN');
+        if ( $subkey_len < self::CRYPTO_KDF_BYTES_MIN ) {
+            throw new SodiumException( 'subkey cannot be smaller than SODIUM_CRYPTO_KDF_BYTES_MIN' );
         }
-        if ($subkey_len > self::CRYPTO_KDF_BYTES_MAX) {
-            throw new SodiumException('subkey cannot be larger than SODIUM_CRYPTO_KDF_BYTES_MAX');
+        if ( $subkey_len > self::CRYPTO_KDF_BYTES_MAX ) {
+            throw new SodiumException( 'subkey cannot be larger than SODIUM_CRYPTO_KDF_BYTES_MAX' );
         }
-        if ($subkey_id < 0) {
-            throw new SodiumException('subkey_id cannot be negative');
+        if ( $subkey_id < 0 ) {
+            throw new SodiumException( 'subkey_id cannot be negative' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($context) !== self::CRYPTO_KDF_CONTEXTBYTES) {
-            throw new SodiumException('context should be SODIUM_CRYPTO_KDF_CONTEXTBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $context ) !== self::CRYPTO_KDF_CONTEXTBYTES ) {
+            throw new SodiumException( 'context should be SODIUM_CRYPTO_KDF_CONTEXTBYTES bytes' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_KDF_KEYBYTES) {
-            throw new SodiumException('key should be SODIUM_CRYPTO_KDF_KEYBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_KDF_KEYBYTES ) {
+            throw new SodiumException( 'key should be SODIUM_CRYPTO_KDF_KEYBYTES bytes' );
         }
 
-        $salt = ParagonIE_Sodium_Core_Util::store64_le($subkey_id);
+        $salt = ParagonIE_Sodium_Core_Util::store64_le( $subkey_id );
         $state = self::crypto_generichash_init_salt_personal(
             $key,
             $subkey_len,
             $salt,
             $context
         );
-        return self::crypto_generichash_final($state, $subkey_len);
+        return self::crypto_generichash_final( $state, $subkey_len );
     }
 
     /**
@@ -1679,7 +1679,7 @@ 
      */
     public static function crypto_kdf_keygen()
     {
-        return random_bytes(self::CRYPTO_KDF_KEYBYTES);
+        return random_bytes( self::CRYPTO_KDF_KEYBYTES );
     }
 
     /**
@@ -1712,31 +1712,31 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_kx($my_secret, $their_public, $client_public, $server_public, $dontFallback = false)
+    public static function crypto_kx( $my_secret, $their_public, $client_public, $server_public, $dontFallback = false )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($my_secret, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($their_public, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($client_public, 'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($server_public, 'string', 4);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $my_secret, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $their_public, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $client_public, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $server_public, 'string', 4 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($my_secret) !== self::CRYPTO_BOX_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $my_secret ) !== self::CRYPTO_BOX_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($their_public) !== self::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $their_public ) !== self::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($client_public) !== self::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_BOX_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $client_public ) !== self::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_BOX_PUBLICKEYBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($server_public) !== self::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 4 must be CRYPTO_BOX_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $server_public ) !== self::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 4 must be CRYPTO_BOX_PUBLICKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            if (is_callable('sodium_crypto_kx')) {
-                return (string) sodium_crypto_kx(
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            if ( is_callable( 'sodium_crypto_kx' ) ) {
+                return (string)sodium_crypto_kx(
                     $my_secret,
                     $their_public,
                     $client_public,
@@ -1744,8 +1744,8 @@ 
                 );
             }
         }
-        if (self::use_fallback('crypto_kx')) {
-            return (string) call_user_func(
+        if ( self::use_fallback( 'crypto_kx' ) ) {
+            return (string)call_user_func(
                 '\\Sodium\\crypto_kx',
                 $my_secret,
                 $their_public,
@@ -1753,7 +1753,7 @@ 
                 $server_public
             );
         }
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::keyExchange(
                 $my_secret,
                 $their_public,
@@ -1774,18 +1774,18 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function crypto_kx_seed_keypair($seed)
+    public static function crypto_kx_seed_keypair( $seed )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $seed, 'string', 1 );
 
-        $seed = (string) $seed;
+        $seed = (string)$seed;
 
-        if (ParagonIE_Sodium_Core_Util::strlen($seed) !== self::CRYPTO_KX_SEEDBYTES) {
-            throw new SodiumException('seed must be SODIUM_CRYPTO_KX_SEEDBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $seed ) !== self::CRYPTO_KX_SEEDBYTES ) {
+            throw new SodiumException( 'seed must be SODIUM_CRYPTO_KX_SEEDBYTES bytes' );
         }
 
-        $sk = self::crypto_generichash($seed, '', self::CRYPTO_KX_SECRETKEYBYTES);
-        $pk = self::crypto_scalarmult_base($sk);
+        $sk = self::crypto_generichash( $seed, '', self::CRYPTO_KX_SECRETKEYBYTES );
+        $pk = self::crypto_scalarmult_base( $sk );
         return $sk . $pk;
     }
 
@@ -1795,8 +1795,8 @@ 
      */
     public static function crypto_kx_keypair()
     {
-        $sk = self::randombytes_buf(self::CRYPTO_KX_SECRETKEYBYTES);
-        $pk = self::crypto_scalarmult_base($sk);
+        $sk = self::randombytes_buf( self::CRYPTO_KX_SECRETKEYBYTES );
+        $pk = self::crypto_scalarmult_base( $sk );
         return $sk . $pk;
     }
 
@@ -1806,28 +1806,28 @@ 
      * @return array{0: string, 1: string}
      * @throws SodiumException
      */
-    public static function crypto_kx_client_session_keys($keypair, $serverPublicKey)
+    public static function crypto_kx_client_session_keys( $keypair, $serverPublicKey )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($serverPublicKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $serverPublicKey, 'string', 2 );
 
-        $keypair = (string) $keypair;
-        $serverPublicKey = (string) $serverPublicKey;
+        $keypair = (string)$keypair;
+        $serverPublicKey = (string)$serverPublicKey;
 
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_KX_KEYPAIRBYTES) {
-            throw new SodiumException('keypair should be SODIUM_CRYPTO_KX_KEYPAIRBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_KX_KEYPAIRBYTES ) {
+            throw new SodiumException( 'keypair should be SODIUM_CRYPTO_KX_KEYPAIRBYTES bytes' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($serverPublicKey) !== self::CRYPTO_KX_PUBLICKEYBYTES) {
-            throw new SodiumException('public keys must be SODIUM_CRYPTO_KX_PUBLICKEYBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $serverPublicKey ) !== self::CRYPTO_KX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'public keys must be SODIUM_CRYPTO_KX_PUBLICKEYBYTES bytes' );
         }
 
-        $sk = self::crypto_kx_secretkey($keypair);
-        $pk = self::crypto_kx_publickey($keypair);
-        $h = self::crypto_generichash_init(null, self::CRYPTO_KX_SESSIONKEYBYTES * 2);
-        self::crypto_generichash_update($h, self::crypto_scalarmult($sk, $serverPublicKey));
-        self::crypto_generichash_update($h, $pk);
-        self::crypto_generichash_update($h, $serverPublicKey);
-        $sessionKeys = self::crypto_generichash_final($h, self::CRYPTO_KX_SESSIONKEYBYTES * 2);
+        $sk = self::crypto_kx_secretkey( $keypair );
+        $pk = self::crypto_kx_publickey( $keypair );
+        $h = self::crypto_generichash_init( null, self::CRYPTO_KX_SESSIONKEYBYTES * 2 );
+        self::crypto_generichash_update( $h, self::crypto_scalarmult( $sk, $serverPublicKey ) );
+        self::crypto_generichash_update( $h, $pk );
+        self::crypto_generichash_update( $h, $serverPublicKey );
+        $sessionKeys = self::crypto_generichash_final( $h, self::CRYPTO_KX_SESSIONKEYBYTES * 2 );
         return array(
             ParagonIE_Sodium_Core_Util::substr(
                 $sessionKeys,
@@ -1848,28 +1848,28 @@ 
      * @return array{0: string, 1: string}
      * @throws SodiumException
      */
-    public static function crypto_kx_server_session_keys($keypair, $clientPublicKey)
+    public static function crypto_kx_server_session_keys( $keypair, $clientPublicKey )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($clientPublicKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $clientPublicKey, 'string', 2 );
 
-        $keypair = (string) $keypair;
-        $clientPublicKey = (string) $clientPublicKey;
+        $keypair = (string)$keypair;
+        $clientPublicKey = (string)$clientPublicKey;
 
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_KX_KEYPAIRBYTES) {
-            throw new SodiumException('keypair should be SODIUM_CRYPTO_KX_KEYPAIRBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_KX_KEYPAIRBYTES ) {
+            throw new SodiumException( 'keypair should be SODIUM_CRYPTO_KX_KEYPAIRBYTES bytes' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($clientPublicKey) !== self::CRYPTO_KX_PUBLICKEYBYTES) {
-            throw new SodiumException('public keys must be SODIUM_CRYPTO_KX_PUBLICKEYBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $clientPublicKey ) !== self::CRYPTO_KX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'public keys must be SODIUM_CRYPTO_KX_PUBLICKEYBYTES bytes' );
         }
 
-        $sk = self::crypto_kx_secretkey($keypair);
-        $pk = self::crypto_kx_publickey($keypair);
-        $h = self::crypto_generichash_init(null, self::CRYPTO_KX_SESSIONKEYBYTES * 2);
-        self::crypto_generichash_update($h, self::crypto_scalarmult($sk, $clientPublicKey));
-        self::crypto_generichash_update($h, $clientPublicKey);
-        self::crypto_generichash_update($h, $pk);
-        $sessionKeys = self::crypto_generichash_final($h, self::CRYPTO_KX_SESSIONKEYBYTES * 2);
+        $sk = self::crypto_kx_secretkey( $keypair );
+        $pk = self::crypto_kx_publickey( $keypair );
+        $h = self::crypto_generichash_init( null, self::CRYPTO_KX_SESSIONKEYBYTES * 2 );
+        self::crypto_generichash_update( $h, self::crypto_scalarmult( $sk, $clientPublicKey ) );
+        self::crypto_generichash_update( $h, $clientPublicKey );
+        self::crypto_generichash_update( $h, $pk );
+        $sessionKeys = self::crypto_generichash_final( $h, self::CRYPTO_KX_SESSIONKEYBYTES * 2 );
         return array(
             ParagonIE_Sodium_Core_Util::substr(
                 $sessionKeys,
@@ -1889,7 +1889,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function crypto_kx_secretkey($kp)
+    public static function crypto_kx_secretkey( $kp )
     {
         return ParagonIE_Sodium_Core_Util::substr(
             $kp,
@@ -1903,7 +1903,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function crypto_kx_publickey($kp)
+    public static function crypto_kx_publickey( $kp )
     {
         return ParagonIE_Sodium_Core_Util::substr(
             $kp,
@@ -1924,23 +1924,23 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $alg = null)
+    public static function crypto_pwhash( $outlen, $passwd, $salt, $opslimit, $memlimit, $alg = null )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($outlen, 'int', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($salt,  'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 4);
-        ParagonIE_Sodium_Core_Util::declareScalarType($memlimit, 'int', 5);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $outlen, 'int', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $passwd, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $salt, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $opslimit, 'int', 4 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $memlimit, 'int', 5 );
 
-        if (self::useNewSodiumAPI()) {
-            if (!is_null($alg)) {
-                ParagonIE_Sodium_Core_Util::declareScalarType($alg, 'int', 6);
-                return sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $alg);
+        if ( self::useNewSodiumAPI() ) {
+            if ( ! is_null( $alg ) ) {
+                ParagonIE_Sodium_Core_Util::declareScalarType( $alg, 'int', 6 );
+                return sodium_crypto_pwhash( $outlen, $passwd, $salt, $opslimit, $memlimit, $alg );
             }
-            return sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit);
+            return sodium_crypto_pwhash( $outlen, $passwd, $salt, $opslimit, $memlimit );
         }
-        if (self::use_fallback('crypto_pwhash')) {
-            return (string) call_user_func('\\Sodium\\crypto_pwhash', $outlen, $passwd, $salt, $opslimit, $memlimit);
+        if ( self::use_fallback( 'crypto_pwhash' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_pwhash', $outlen, $passwd, $salt, $opslimit, $memlimit );
         }
         // This is the best we can do.
         throw new SodiumException(
@@ -1958,10 +1958,10 @@ 
      */
     public static function crypto_pwhash_is_available()
     {
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             return true;
         }
-        if (self::use_fallback('crypto_pwhash')) {
+        if ( self::use_fallback( 'crypto_pwhash' ) ) {
             return true;
         }
         return false;
@@ -1976,17 +1976,17 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_pwhash_str($passwd, $opslimit, $memlimit)
+    public static function crypto_pwhash_str( $passwd, $opslimit, $memlimit )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($memlimit, 'int', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $passwd, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $opslimit, 'int', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $memlimit, 'int', 3 );
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_pwhash_str( $passwd, $opslimit, $memlimit );
         }
-        if (self::use_fallback('crypto_pwhash_str')) {
-            return (string) call_user_func('\\Sodium\\crypto_pwhash_str', $passwd, $opslimit, $memlimit);
+        if ( self::use_fallback( 'crypto_pwhash_str' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_pwhash_str', $passwd, $opslimit, $memlimit );
         }
         // This is the best we can do.
         throw new SodiumException(
@@ -2003,25 +2003,25 @@ 
      * @return bool
      * @throws SodiumException
      */
-    public static function crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
+    public static function crypto_pwhash_str_needs_rehash( $hash, $opslimit, $memlimit )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($hash, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($memlimit, 'int', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $hash, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $opslimit, 'int', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $memlimit, 'int', 3 );
 
         // Just grab the first 4 pieces.
-        $pieces = explode('$', (string) $hash);
-        $prefix = implode('$', array_slice($pieces, 0, 4));
+        $pieces = explode( '$', (string)$hash );
+        $prefix = implode( '$', array_slice( $pieces, 0, 4 ) );
 
         // Rebuild the expected header.
         /** @var int $ops */
-        $ops = (int) $opslimit;
+        $ops = (int)$opslimit;
         /** @var int $mem */
-        $mem = (int) $memlimit >> 10;
+        $mem = (int)$memlimit >> 10;
         $encoded = self::CRYPTO_PWHASH_STRPREFIX . 'v=19$m=' . $mem . ',t=' . $ops . ',p=1';
 
         // Do they match? If so, we don't need to rehash, so return false.
-        return !ParagonIE_Sodium_Core_Util::hashEquals($encoded, $prefix);
+        return ! ParagonIE_Sodium_Core_Util::hashEquals( $encoded, $prefix );
     }
 
     /**
@@ -2032,16 +2032,16 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_pwhash_str_verify($passwd, $hash)
+    public static function crypto_pwhash_str_verify( $passwd, $hash )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($hash, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $passwd, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $hash, 'string', 2 );
 
-        if (self::useNewSodiumAPI()) {
-            return (bool) sodium_crypto_pwhash_str_verify($passwd, $hash);
+        if ( self::useNewSodiumAPI() ) {
+            return (bool)sodium_crypto_pwhash_str_verify( $passwd, $hash );
         }
-        if (self::use_fallback('crypto_pwhash_str_verify')) {
-            return (bool) call_user_func('\\Sodium\\crypto_pwhash_str_verify', $passwd, $hash);
+        if ( self::use_fallback( 'crypto_pwhash_str_verify' ) ) {
+            return (bool)call_user_func( '\\Sodium\\crypto_pwhash_str_verify', $passwd, $hash );
         }
         // This is the best we can do.
         throw new SodiumException(
@@ -2059,31 +2059,31 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
-    {
-        ParagonIE_Sodium_Core_Util::declareScalarType($outlen, 'int', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($salt,  'string', 3);
-        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 4);
-        ParagonIE_Sodium_Core_Util::declareScalarType($memlimit, 'int', 5);
-
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_pwhash_scryptsalsa208sha256(
-                (int) $outlen,
-                (string) $passwd,
-                (string) $salt,
-                (int) $opslimit,
-                (int) $memlimit
+    public static function crypto_pwhash_scryptsalsa208sha256( $outlen, $passwd, $salt, $opslimit, $memlimit )
+    {
+        ParagonIE_Sodium_Core_Util::declareScalarType( $outlen, 'int', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $passwd, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $salt, 'string', 3 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $opslimit, 'int', 4 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $memlimit, 'int', 5 );
+
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_pwhash_scryptsalsa208sha256(
+                (int)$outlen,
+                (string)$passwd,
+                (string)$salt,
+                (int)$opslimit,
+                (int)$memlimit
             );
         }
-        if (self::use_fallback('crypto_pwhash_scryptsalsa208sha256')) {
-            return (string) call_user_func(
+        if ( self::use_fallback( 'crypto_pwhash_scryptsalsa208sha256' ) ) {
+            return (string)call_user_func(
                 '\\Sodium\\crypto_pwhash_scryptsalsa208sha256',
-                (int) $outlen,
-                (string) $passwd,
-                (string) $salt,
-                (int) $opslimit,
-                (int) $memlimit
+                (int)$outlen,
+                (string)$passwd,
+                (string)$salt,
+                (int)$opslimit,
+                (int)$memlimit
             );
         }
         // This is the best we can do.
@@ -2102,10 +2102,10 @@ 
      */
     public static function crypto_pwhash_scryptsalsa208sha256_is_available()
     {
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             return true;
         }
-        if (self::use_fallback('crypto_pwhash_scryptsalsa208sha256')) {
+        if ( self::use_fallback( 'crypto_pwhash_scryptsalsa208sha256' ) ) {
             return true;
         }
         return false;
@@ -2119,25 +2119,25 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
+    public static function crypto_pwhash_scryptsalsa208sha256_str( $passwd, $opslimit, $memlimit )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($opslimit, 'int', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($memlimit, 'int', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $passwd, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $opslimit, 'int', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $memlimit, 'int', 3 );
 
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_crypto_pwhash_scryptsalsa208sha256_str(
-                (string) $passwd,
-                (int) $opslimit,
-                (int) $memlimit
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_crypto_pwhash_scryptsalsa208sha256_str(
+                (string)$passwd,
+                (int)$opslimit,
+                (int)$memlimit
             );
         }
-        if (self::use_fallback('crypto_pwhash_scryptsalsa208sha256_str')) {
-            return (string) call_user_func(
+        if ( self::use_fallback( 'crypto_pwhash_scryptsalsa208sha256_str' ) ) {
+            return (string)call_user_func(
                 '\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str',
-                (string) $passwd,
-                (int) $opslimit,
-                (int) $memlimit
+                (string)$passwd,
+                (int)$opslimit,
+                (int)$memlimit
             );
         }
         // This is the best we can do.
@@ -2153,22 +2153,22 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
+    public static function crypto_pwhash_scryptsalsa208sha256_str_verify( $passwd, $hash )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($passwd, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($hash, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $passwd, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $hash, 'string', 2 );
 
-        if (self::useNewSodiumAPI()) {
-            return (bool) sodium_crypto_pwhash_scryptsalsa208sha256_str_verify(
-                (string) $passwd,
-                (string) $hash
+        if ( self::useNewSodiumAPI() ) {
+            return (bool)sodium_crypto_pwhash_scryptsalsa208sha256_str_verify(
+                (string)$passwd,
+                (string)$hash
             );
         }
-        if (self::use_fallback('crypto_pwhash_scryptsalsa208sha256_str_verify')) {
-            return (bool) call_user_func(
+        if ( self::use_fallback( 'crypto_pwhash_scryptsalsa208sha256_str_verify' ) ) {
+            return (bool)call_user_func(
                 '\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str_verify',
-                (string) $passwd,
-                (string) $hash
+                (string)$passwd,
+                (string)$hash
             );
         }
         // This is the best we can do.
@@ -2190,38 +2190,38 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_scalarmult($secretKey, $publicKey)
+    public static function crypto_scalarmult( $secretKey, $publicKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($publicKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $secretKey, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $publicKey, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($secretKey) !== self::CRYPTO_BOX_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $secretKey ) !== self::CRYPTO_BOX_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($publicKey) !== self::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $publicKey ) !== self::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_BOX_PUBLICKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_scalarmult($secretKey, $publicKey);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_scalarmult( $secretKey, $publicKey );
         }
-        if (self::use_fallback('crypto_scalarmult')) {
-            return (string) call_user_func('\\Sodium\\crypto_scalarmult', $secretKey, $publicKey);
+        if ( self::use_fallback( 'crypto_scalarmult' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_scalarmult', $secretKey, $publicKey );
         }
 
         /* Output validation: Forbid all-zero keys */
-        if (ParagonIE_Sodium_Core_Util::hashEquals($secretKey, str_repeat("\0", self::CRYPTO_BOX_SECRETKEYBYTES))) {
-            throw new SodiumException('Zero secret key is not allowed');
+        if ( ParagonIE_Sodium_Core_Util::hashEquals( $secretKey, str_repeat( "\0", self::CRYPTO_BOX_SECRETKEYBYTES ) ) ) {
+            throw new SodiumException( 'Zero secret key is not allowed' );
         }
-        if (ParagonIE_Sodium_Core_Util::hashEquals($publicKey, str_repeat("\0", self::CRYPTO_BOX_PUBLICKEYBYTES))) {
-            throw new SodiumException('Zero public key is not allowed');
+        if ( ParagonIE_Sodium_Core_Util::hashEquals( $publicKey, str_repeat( "\0", self::CRYPTO_BOX_PUBLICKEYBYTES ) ) ) {
+            throw new SodiumException( 'Zero public key is not allowed' );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::scalarmult($secretKey, $publicKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::scalarmult( $secretKey, $publicKey );
         }
-        return ParagonIE_Sodium_Crypto::scalarmult($secretKey, $publicKey);
+        return ParagonIE_Sodium_Crypto::scalarmult( $secretKey, $publicKey );
     }
 
     /**
@@ -2234,29 +2234,29 @@ 
      * @psalm-suppress TooFewArguments
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_scalarmult_base($secretKey)
+    public static function crypto_scalarmult_base( $secretKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $secretKey, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($secretKey) !== self::CRYPTO_BOX_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $secretKey ) !== self::CRYPTO_BOX_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_BOX_SECRETKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_scalarmult_base($secretKey);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_scalarmult_base( $secretKey );
         }
-        if (self::use_fallback('crypto_scalarmult_base')) {
-            return (string) call_user_func('\\Sodium\\crypto_scalarmult_base', $secretKey);
+        if ( self::use_fallback( 'crypto_scalarmult_base' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_scalarmult_base', $secretKey );
         }
-        if (ParagonIE_Sodium_Core_Util::hashEquals($secretKey, str_repeat("\0", self::CRYPTO_BOX_SECRETKEYBYTES))) {
-            throw new SodiumException('Zero secret key is not allowed');
+        if ( ParagonIE_Sodium_Core_Util::hashEquals( $secretKey, str_repeat( "\0", self::CRYPTO_BOX_SECRETKEYBYTES ) ) ) {
+            throw new SodiumException( 'Zero secret key is not allowed' );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::scalarmult_base($secretKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::scalarmult_base( $secretKey );
         }
-        return ParagonIE_Sodium_Crypto::scalarmult_base($secretKey);
+        return ParagonIE_Sodium_Crypto::scalarmult_base( $secretKey );
     }
 
     /**
@@ -2272,31 +2272,31 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_secretbox($plaintext, $nonce, $key)
+    public static function crypto_secretbox( $plaintext, $nonce, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_SECRETBOX_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_SECRETBOX_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_secretbox($plaintext, $nonce, $key);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_secretbox( $plaintext, $nonce, $key );
         }
-        if (self::use_fallback('crypto_secretbox')) {
-            return (string) call_user_func('\\Sodium\\crypto_secretbox', $plaintext, $nonce, $key);
+        if ( self::use_fallback( 'crypto_secretbox' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_secretbox', $plaintext, $nonce, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretbox($plaintext, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::secretbox( $plaintext, $nonce, $key );
         }
-        return ParagonIE_Sodium_Crypto::secretbox($plaintext, $nonce, $key);
+        return ParagonIE_Sodium_Crypto::secretbox( $plaintext, $nonce, $key );
     }
 
     /**
@@ -2312,35 +2312,35 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress MixedReturnStatement
      */
-    public static function crypto_secretbox_open($ciphertext, $nonce, $key)
+    public static function crypto_secretbox_open( $ciphertext, $nonce, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_SECRETBOX_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_SECRETBOX_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             /**
              * @psalm-suppress InvalidReturnStatement
              * @psalm-suppress FalsableReturnStatement
              */
-            return sodium_crypto_secretbox_open($ciphertext, $nonce, $key);
+            return sodium_crypto_secretbox_open( $ciphertext, $nonce, $key );
         }
-        if (self::use_fallback('crypto_secretbox_open')) {
-            return call_user_func('\\Sodium\\crypto_secretbox_open', $ciphertext, $nonce, $key);
+        if ( self::use_fallback( 'crypto_secretbox_open' ) ) {
+            return call_user_func( '\\Sodium\\crypto_secretbox_open', $ciphertext, $nonce, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretbox_open($ciphertext, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::secretbox_open( $ciphertext, $nonce, $key );
         }
-        return ParagonIE_Sodium_Crypto::secretbox_open($ciphertext, $nonce, $key);
+        return ParagonIE_Sodium_Crypto::secretbox_open( $ciphertext, $nonce, $key );
     }
 
     /**
@@ -2352,7 +2352,7 @@ 
      */
     public static function crypto_secretbox_keygen()
     {
-        return random_bytes(self::CRYPTO_SECRETBOX_KEYBYTES);
+        return random_bytes( self::CRYPTO_SECRETBOX_KEYBYTES );
     }
 
     /**
@@ -2368,24 +2368,24 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_secretbox_xchacha20poly1305($plaintext, $nonce, $key)
+    public static function crypto_secretbox_xchacha20poly1305( $plaintext, $nonce, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($plaintext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $plaintext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_SECRETBOX_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_SECRETBOX_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.' );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretbox_xchacha20poly1305($plaintext, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::secretbox_xchacha20poly1305( $plaintext, $nonce, $key );
         }
-        return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305($plaintext, $nonce, $key);
+        return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305( $plaintext, $nonce, $key );
     }
     /**
      * Decrypts a message previously encrypted with crypto_secretbox_xchacha20poly1305().
@@ -2398,25 +2398,25 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key)
+    public static function crypto_secretbox_xchacha20poly1305_open( $ciphertext, $nonce, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($ciphertext, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $ciphertext, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_SECRETBOX_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_SECRETBOX_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.' );
         }
 
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::secretbox_xchacha20poly1305_open( $ciphertext, $nonce, $key );
         }
-        return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key);
+        return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305_open( $ciphertext, $nonce, $key );
     }
 
     /**
@@ -2425,12 +2425,12 @@ 
      * @throws Exception
      * @throws SodiumException
      */
-    public static function crypto_secretstream_xchacha20poly1305_init_push($key)
+    public static function crypto_secretstream_xchacha20poly1305_init_push( $key )
     {
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_init_push($key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_init_push( $key );
         }
-        return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_init_push($key);
+        return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_init_push( $key );
     }
 
     /**
@@ -2439,17 +2439,17 @@ 
      * @return string Returns a state.
      * @throws Exception
      */
-    public static function crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
+    public static function crypto_secretstream_xchacha20poly1305_init_pull( $header, $key )
     {
-        if (ParagonIE_Sodium_Core_Util::strlen($header) < self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES) {
+        if ( ParagonIE_Sodium_Core_Util::strlen( $header ) < self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES ) {
             throw new SodiumException(
                 'header size should be SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES bytes'
             );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_init_pull($key, $header);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_init_pull( $key, $header );
         }
-        return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_init_pull($key, $header);
+        return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_init_pull( $key, $header );
     }
 
     /**
@@ -2460,9 +2460,9 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
+    public static function crypto_secretstream_xchacha20poly1305_push( &$state, $msg, $aad = '', $tag = 0 )
     {
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_push(
                 $state,
                 $msg,
@@ -2485,9 +2485,9 @@ 
      * @return bool|array{0: string, 1: int}
      * @throws SodiumException
      */
-    public static function crypto_secretstream_xchacha20poly1305_pull(&$state, $msg, $aad = '')
+    public static function crypto_secretstream_xchacha20poly1305_pull( &$state, $msg, $aad = '' )
     {
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_pull(
                 $state,
                 $msg,
@@ -2507,7 +2507,7 @@ 
      */
     public static function crypto_secretstream_xchacha20poly1305_keygen()
     {
-        return random_bytes(self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES);
+        return random_bytes( self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES );
     }
 
     /**
@@ -2515,12 +2515,12 @@ 
      * @return void
      * @throws SodiumException
      */
-    public static function crypto_secretstream_xchacha20poly1305_rekey(&$state)
+    public static function crypto_secretstream_xchacha20poly1305_rekey( &$state )
     {
-        if (PHP_INT_SIZE === 4) {
-            ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_rekey($state);
+        if ( PHP_INT_SIZE === 4 ) {
+            ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_rekey( $state );
         } else {
-            ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_rekey($state);
+            ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_rekey( $state );
         }
     }
 
@@ -2536,27 +2536,27 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress MixedReturnStatement
      */
-    public static function crypto_shorthash($message, $key)
+    public static function crypto_shorthash( $message, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_SHORTHASH_KEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SHORTHASH_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_SHORTHASH_KEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SHORTHASH_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_shorthash($message, $key);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_shorthash( $message, $key );
         }
-        if (self::use_fallback('crypto_shorthash')) {
-            return (string) call_user_func('\\Sodium\\crypto_shorthash', $message, $key);
+        if ( self::use_fallback( 'crypto_shorthash' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_shorthash', $message, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_SipHash::sipHash24($message, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_SipHash::sipHash24( $message, $key );
         }
-        return ParagonIE_Sodium_Core_SipHash::sipHash24($message, $key);
+        return ParagonIE_Sodium_Core_SipHash::sipHash24( $message, $key );
     }
 
     /**
@@ -2568,7 +2568,7 @@ 
      */
     public static function crypto_shorthash_keygen()
     {
-        return random_bytes(self::CRYPTO_SHORTHASH_KEYBYTES);
+        return random_bytes( self::CRYPTO_SHORTHASH_KEYBYTES );
     }
 
     /**
@@ -2586,27 +2586,27 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress MixedReturnStatement
      */
-    public static function crypto_sign($message, $secretKey)
+    public static function crypto_sign( $message, $secretKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $secretKey, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($secretKey) !== self::CRYPTO_SIGN_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $secretKey ) !== self::CRYPTO_SIGN_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign($message, $secretKey);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign( $message, $secretKey );
         }
-        if (self::use_fallback('crypto_sign')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign', $message, $secretKey);
+        if ( self::use_fallback( 'crypto_sign' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign', $message, $secretKey );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::sign($message, $secretKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::sign( $message, $secretKey );
         }
-        return ParagonIE_Sodium_Crypto::sign($message, $secretKey);
+        return ParagonIE_Sodium_Crypto::sign( $message, $secretKey );
     }
 
     /**
@@ -2622,34 +2622,34 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress MixedReturnStatement
      */
-    public static function crypto_sign_open($signedMessage, $publicKey)
+    public static function crypto_sign_open( $signedMessage, $publicKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($signedMessage, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($publicKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $signedMessage, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $publicKey, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($signedMessage) < self::CRYPTO_SIGN_BYTES) {
-            throw new SodiumException('Argument 1 must be at least CRYPTO_SIGN_BYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $signedMessage ) < self::CRYPTO_SIGN_BYTES ) {
+            throw new SodiumException( 'Argument 1 must be at least CRYPTO_SIGN_BYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($publicKey) !== self::CRYPTO_SIGN_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SIGN_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $publicKey ) !== self::CRYPTO_SIGN_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SIGN_PUBLICKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             /**
              * @psalm-suppress InvalidReturnStatement
              * @psalm-suppress FalsableReturnStatement
              */
-            return sodium_crypto_sign_open($signedMessage, $publicKey);
+            return sodium_crypto_sign_open( $signedMessage, $publicKey );
         }
-        if (self::use_fallback('crypto_sign_open')) {
-            return call_user_func('\\Sodium\\crypto_sign_open', $signedMessage, $publicKey);
+        if ( self::use_fallback( 'crypto_sign_open' ) ) {
+            return call_user_func( '\\Sodium\\crypto_sign_open', $signedMessage, $publicKey );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::sign_open($signedMessage, $publicKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::sign_open( $signedMessage, $publicKey );
         }
-        return ParagonIE_Sodium_Crypto::sign_open($signedMessage, $publicKey);
+        return ParagonIE_Sodium_Crypto::sign_open( $signedMessage, $publicKey );
     }
 
     /**
@@ -2661,13 +2661,13 @@ 
      */
     public static function crypto_sign_keypair()
     {
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             return sodium_crypto_sign_keypair();
         }
-        if (self::use_fallback('crypto_sign_keypair')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_keypair');
+        if ( self::use_fallback( 'crypto_sign_keypair' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_keypair' );
         }
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return ParagonIE_Sodium_Core32_Ed25519::keypair();
         }
         return ParagonIE_Sodium_Core_Ed25519::keypair();
@@ -2679,22 +2679,22 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
+    public static function crypto_sign_keypair_from_secretkey_and_publickey( $sk, $pk )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($sk, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($pk, 'string', 1);
-        $sk = (string) $sk;
-        $pk = (string) $pk;
+        ParagonIE_Sodium_Core_Util::declareScalarType( $sk, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $pk, 'string', 1 );
+        $sk = (string)$sk;
+        $pk = (string)$pk;
 
-        if (ParagonIE_Sodium_Core_Util::strlen($sk) !== self::CRYPTO_SIGN_SECRETKEYBYTES) {
-            throw new SodiumException('secretkey should be SODIUM_CRYPTO_SIGN_SECRETKEYBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $sk ) !== self::CRYPTO_SIGN_SECRETKEYBYTES ) {
+            throw new SodiumException( 'secretkey should be SODIUM_CRYPTO_SIGN_SECRETKEYBYTES bytes' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($pk) !== self::CRYPTO_SIGN_PUBLICKEYBYTES) {
-            throw new SodiumException('publickey should be SODIUM_CRYPTO_SIGN_PUBLICKEYBYTES bytes');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $pk ) !== self::CRYPTO_SIGN_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'publickey should be SODIUM_CRYPTO_SIGN_PUBLICKEYBYTES bytes' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign_keypair_from_secretkey_and_publickey( $sk, $pk );
         }
         return $sk . $pk;
     }
@@ -2708,22 +2708,22 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_seed_keypair($seed)
+    public static function crypto_sign_seed_keypair( $seed )
     {
-        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $seed, 'string', 1 );
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_seed_keypair($seed);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign_seed_keypair( $seed );
         }
-        if (self::use_fallback('crypto_sign_keypair')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_seed_keypair', $seed);
+        if ( self::use_fallback( 'crypto_sign_keypair' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_seed_keypair', $seed );
         }
         $publicKey = '';
         $secretKey = '';
-        if (PHP_INT_SIZE === 4) {
-            ParagonIE_Sodium_Core32_Ed25519::seed_keypair($publicKey, $secretKey, $seed);
+        if ( PHP_INT_SIZE === 4 ) {
+            ParagonIE_Sodium_Core32_Ed25519::seed_keypair( $publicKey, $secretKey, $seed );
         } else {
-            ParagonIE_Sodium_Core_Ed25519::seed_keypair($publicKey, $secretKey, $seed);
+            ParagonIE_Sodium_Core_Ed25519::seed_keypair( $publicKey, $secretKey, $seed );
         }
         return $secretKey . $publicKey;
     }
@@ -2737,26 +2737,26 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_publickey($keypair)
+    public static function crypto_sign_publickey( $keypair )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_SIGN_KEYPAIRBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_SIGN_KEYPAIRBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_SIGN_KEYPAIRBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_SIGN_KEYPAIRBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_publickey($keypair);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign_publickey( $keypair );
         }
-        if (self::use_fallback('crypto_sign_publickey')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_publickey', $keypair);
+        if ( self::use_fallback( 'crypto_sign_publickey' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_publickey', $keypair );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::publickey($keypair);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_Ed25519::publickey( $keypair );
         }
-        return ParagonIE_Sodium_Core_Ed25519::publickey($keypair);
+        return ParagonIE_Sodium_Core_Ed25519::publickey( $keypair );
     }
 
     /**
@@ -2768,26 +2768,26 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_publickey_from_secretkey($secretKey)
+    public static function crypto_sign_publickey_from_secretkey( $secretKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $secretKey, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($secretKey) !== self::CRYPTO_SIGN_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_SIGN_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $secretKey ) !== self::CRYPTO_SIGN_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_SIGN_SECRETKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_publickey_from_secretkey($secretKey);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign_publickey_from_secretkey( $secretKey );
         }
-        if (self::use_fallback('crypto_sign_publickey_from_secretkey')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_publickey_from_secretkey', $secretKey);
+        if ( self::use_fallback( 'crypto_sign_publickey_from_secretkey' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_publickey_from_secretkey', $secretKey );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::publickey_from_secretkey($secretKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_Ed25519::publickey_from_secretkey( $secretKey );
         }
-        return ParagonIE_Sodium_Core_Ed25519::publickey_from_secretkey($secretKey);
+        return ParagonIE_Sodium_Core_Ed25519::publickey_from_secretkey( $secretKey );
     }
 
     /**
@@ -2799,26 +2799,26 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_secretkey($keypair)
+    public static function crypto_sign_secretkey( $keypair )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($keypair, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $keypair, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== self::CRYPTO_SIGN_KEYPAIRBYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_SIGN_KEYPAIRBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== self::CRYPTO_SIGN_KEYPAIRBYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_SIGN_KEYPAIRBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_secretkey($keypair);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign_secretkey( $keypair );
         }
-        if (self::use_fallback('crypto_sign_secretkey')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_secretkey', $keypair);
+        if ( self::use_fallback( 'crypto_sign_secretkey' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_secretkey', $keypair );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::secretkey($keypair);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_Ed25519::secretkey( $keypair );
         }
-        return ParagonIE_Sodium_Core_Ed25519::secretkey($keypair);
+        return ParagonIE_Sodium_Core_Ed25519::secretkey( $keypair );
     }
 
     /**
@@ -2833,27 +2833,27 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_detached($message, $secretKey)
+    public static function crypto_sign_detached( $message, $secretKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($secretKey, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $secretKey, 'string', 2 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($secretKey) !== self::CRYPTO_SIGN_SECRETKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $secretKey ) !== self::CRYPTO_SIGN_SECRETKEYBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_detached($message, $secretKey);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign_detached( $message, $secretKey );
         }
-        if (self::use_fallback('crypto_sign_detached')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_detached', $message, $secretKey);
+        if ( self::use_fallback( 'crypto_sign_detached' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_detached', $message, $secretKey );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::sign_detached($message, $secretKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::sign_detached( $message, $secretKey );
         }
-        return ParagonIE_Sodium_Crypto::sign_detached($message, $secretKey);
+        return ParagonIE_Sodium_Crypto::sign_detached( $message, $secretKey );
     }
 
     /**
@@ -2868,36 +2868,36 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_verify_detached($signature, $message, $publicKey)
+    public static function crypto_sign_verify_detached( $signature, $message, $publicKey )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($signature, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($publicKey, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $signature, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $publicKey, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($signature) !== self::CRYPTO_SIGN_BYTES) {
-            throw new SodiumException('Argument 1 must be CRYPTO_SIGN_BYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $signature ) !== self::CRYPTO_SIGN_BYTES ) {
+            throw new SodiumException( 'Argument 1 must be CRYPTO_SIGN_BYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($publicKey) !== self::CRYPTO_SIGN_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SIGN_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $publicKey ) !== self::CRYPTO_SIGN_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_SIGN_PUBLICKEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_verify_detached($signature, $message, $publicKey);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_sign_verify_detached( $signature, $message, $publicKey );
         }
-        if (self::use_fallback('crypto_sign_verify_detached')) {
-            return (bool) call_user_func(
+        if ( self::use_fallback( 'crypto_sign_verify_detached' ) ) {
+            return (bool)call_user_func(
                 '\\Sodium\\crypto_sign_verify_detached',
                 $signature,
                 $message,
                 $publicKey
             );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::sign_verify_detached($signature, $message, $publicKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Crypto32::sign_verify_detached( $signature, $message, $publicKey );
         }
-        return ParagonIE_Sodium_Crypto::sign_verify_detached($signature, $message, $publicKey);
+        return ParagonIE_Sodium_Crypto::sign_verify_detached( $signature, $message, $publicKey );
     }
 
     /**
@@ -2909,27 +2909,27 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_ed25519_pk_to_curve25519($pk)
+    public static function crypto_sign_ed25519_pk_to_curve25519( $pk )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($pk, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $pk, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($pk) < self::CRYPTO_SIGN_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 1 must be at least CRYPTO_SIGN_PUBLICKEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $pk ) < self::CRYPTO_SIGN_PUBLICKEYBYTES ) {
+            throw new SodiumException( 'Argument 1 must be at least CRYPTO_SIGN_PUBLICKEYBYTES long.' );
         }
-        if (self::useNewSodiumAPI()) {
-            if (is_callable('crypto_sign_ed25519_pk_to_curve25519')) {
-                return (string) sodium_crypto_sign_ed25519_pk_to_curve25519($pk);
+        if ( self::useNewSodiumAPI() ) {
+            if ( is_callable( 'crypto_sign_ed25519_pk_to_curve25519' ) ) {
+                return (string)sodium_crypto_sign_ed25519_pk_to_curve25519( $pk );
             }
         }
-        if (self::use_fallback('crypto_sign_ed25519_pk_to_curve25519')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_ed25519_pk_to_curve25519', $pk);
+        if ( self::use_fallback( 'crypto_sign_ed25519_pk_to_curve25519' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_ed25519_pk_to_curve25519', $pk );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::pk_to_curve25519($pk);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_Ed25519::pk_to_curve25519( $pk );
         }
-        return ParagonIE_Sodium_Core_Ed25519::pk_to_curve25519($pk);
+        return ParagonIE_Sodium_Core_Ed25519::pk_to_curve25519( $pk );
     }
 
     /**
@@ -2941,32 +2941,32 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_sign_ed25519_sk_to_curve25519($sk)
+    public static function crypto_sign_ed25519_sk_to_curve25519( $sk )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($sk, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $sk, 'string', 1 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($sk) < self::CRYPTO_SIGN_SEEDBYTES) {
-            throw new SodiumException('Argument 1 must be at least CRYPTO_SIGN_SEEDBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $sk ) < self::CRYPTO_SIGN_SEEDBYTES ) {
+            throw new SodiumException( 'Argument 1 must be at least CRYPTO_SIGN_SEEDBYTES long.' );
         }
-        if (self::useNewSodiumAPI()) {
-            if (is_callable('crypto_sign_ed25519_sk_to_curve25519')) {
-                return sodium_crypto_sign_ed25519_sk_to_curve25519($sk);
+        if ( self::useNewSodiumAPI() ) {
+            if ( is_callable( 'crypto_sign_ed25519_sk_to_curve25519' ) ) {
+                return sodium_crypto_sign_ed25519_sk_to_curve25519( $sk );
             }
         }
-        if (self::use_fallback('crypto_sign_ed25519_sk_to_curve25519')) {
-            return (string) call_user_func('\\Sodium\\crypto_sign_ed25519_sk_to_curve25519', $sk);
+        if ( self::use_fallback( 'crypto_sign_ed25519_sk_to_curve25519' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_sign_ed25519_sk_to_curve25519', $sk );
         }
 
-        $h = hash('sha512', ParagonIE_Sodium_Core_Util::substr($sk, 0, 32), true);
-        $h[0] = ParagonIE_Sodium_Core_Util::intToChr(
-            ParagonIE_Sodium_Core_Util::chrToInt($h[0]) & 248
+        $h = hash( 'sha512', ParagonIE_Sodium_Core_Util::substr( $sk, 0, 32 ), true );
+        $h[ 0 ] = ParagonIE_Sodium_Core_Util::intToChr(
+            ParagonIE_Sodium_Core_Util::chrToInt( $h[ 0 ] ) & 248
         );
-        $h[31] = ParagonIE_Sodium_Core_Util::intToChr(
-            (ParagonIE_Sodium_Core_Util::chrToInt($h[31]) & 127) | 64
+        $h[ 31 ] = ParagonIE_Sodium_Core_Util::intToChr(
+            ( ParagonIE_Sodium_Core_Util::chrToInt( $h[ 31 ] ) & 127 ) | 64
         );
-        return ParagonIE_Sodium_Core_Util::substr($h, 0, 32);
+        return ParagonIE_Sodium_Core_Util::substr( $h, 0, 32 );
     }
 
     /**
@@ -2983,31 +2983,31 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_stream($len, $nonce, $key)
+    public static function crypto_stream( $len, $nonce, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($len, 'int', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $len, 'int', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_STREAM_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_STREAM_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_STREAM_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_STREAM_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_STREAM_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_STREAM_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_stream($len, $nonce, $key);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_stream( $len, $nonce, $key );
         }
-        if (self::use_fallback('crypto_stream')) {
-            return (string) call_user_func('\\Sodium\\crypto_stream', $len, $nonce, $key);
+        if ( self::use_fallback( 'crypto_stream' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_stream', $len, $nonce, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_XSalsa20::xsalsa20($len, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_XSalsa20::xsalsa20( $len, $nonce, $key );
         }
-        return ParagonIE_Sodium_Core_XSalsa20::xsalsa20($len, $nonce, $key);
+        return ParagonIE_Sodium_Core_XSalsa20::xsalsa20( $len, $nonce, $key );
     }
 
     /**
@@ -3030,31 +3030,31 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_stream_xor($message, $nonce, $key)
+    public static function crypto_stream_xor( $message, $nonce, $key )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_STREAM_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_STREAM_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_STREAM_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_STREAM_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_stream_xor($message, $nonce, $key);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_crypto_stream_xor( $message, $nonce, $key );
         }
-        if (self::use_fallback('crypto_stream_xor')) {
-            return (string) call_user_func('\\Sodium\\crypto_stream_xor', $message, $nonce, $key);
+        if ( self::use_fallback( 'crypto_stream_xor' ) ) {
+            return (string)call_user_func( '\\Sodium\\crypto_stream_xor', $message, $nonce, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_XSalsa20::xsalsa20_xor($message, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_XSalsa20::xsalsa20_xor( $message, $nonce, $key );
         }
-        return ParagonIE_Sodium_Core_XSalsa20::xsalsa20_xor($message, $nonce, $key);
+        return ParagonIE_Sodium_Core_XSalsa20::xsalsa20_xor( $message, $nonce, $key );
     }
 
     /**
@@ -3066,7 +3066,7 @@ 
      */
     public static function crypto_stream_keygen()
     {
-        return random_bytes(self::CRYPTO_STREAM_KEYBYTES);
+        return random_bytes( self::CRYPTO_STREAM_KEYBYTES );
     }
 
 
@@ -3085,28 +3085,28 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_stream_xchacha20($len, $nonce, $key, $dontFallback = false)
+    public static function crypto_stream_xchacha20( $len, $nonce, $key, $dontFallback = false )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($len, 'int', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $len, 'int', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_STREAM_XCHACHA20_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_XCHACHA20_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_STREAM_XCHACHA20_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_XCHACHA20_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_STREAM_XCHACHA20_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_STREAM_XCHACHA20_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_STREAM_XCHACHA20_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_STREAM_XCHACHA20_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_stream_xchacha20($len, $nonce, $key);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_stream_xchacha20( $len, $nonce, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_XChaCha20::stream($len, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_XChaCha20::stream( $len, $nonce, $key );
         }
-        return ParagonIE_Sodium_Core_XChaCha20::stream($len, $nonce, $key);
+        return ParagonIE_Sodium_Core_XChaCha20::stream( $len, $nonce, $key );
     }
 
     /**
@@ -3130,28 +3130,28 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_stream_xchacha20_xor($message, $nonce, $key, $dontFallback = false)
+    public static function crypto_stream_xchacha20_xor( $message, $nonce, $key, $dontFallback = false )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($message, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($nonce, 'string', 2);
-        ParagonIE_Sodium_Core_Util::declareScalarType($key, 'string', 3);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $message, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $nonce, 'string', 2 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $key, 'string', 3 );
 
         /* Input validation: */
-        if (ParagonIE_Sodium_Core_Util::strlen($nonce) !== self::CRYPTO_STREAM_XCHACHA20_NONCEBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SECRETBOX_XCHACHA20_NONCEBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $nonce ) !== self::CRYPTO_STREAM_XCHACHA20_NONCEBYTES ) {
+            throw new SodiumException( 'Argument 2 must be CRYPTO_SECRETBOX_XCHACHA20_NONCEBYTES long.' );
         }
-        if (ParagonIE_Sodium_Core_Util::strlen($key) !== self::CRYPTO_STREAM_XCHACHA20_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_XCHACHA20_KEYBYTES long.');
+        if ( ParagonIE_Sodium_Core_Util::strlen( $key ) !== self::CRYPTO_STREAM_XCHACHA20_KEYBYTES ) {
+            throw new SodiumException( 'Argument 3 must be CRYPTO_SECRETBOX_XCHACHA20_KEYBYTES long.' );
         }
 
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_stream_xchacha20_xor($message, $nonce, $key);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_stream_xchacha20_xor( $message, $nonce, $key );
         }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_XChaCha20::streamXorIc($message, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return ParagonIE_Sodium_Core32_XChaCha20::streamXorIc( $message, $nonce, $key );
         }
-        return ParagonIE_Sodium_Core_XChaCha20::streamXorIc($message, $nonce, $key);
+        return ParagonIE_Sodium_Core_XChaCha20::streamXorIc( $message, $nonce, $key );
     }
 
     /**
@@ -3163,7 +3163,7 @@ 
      */
     public static function crypto_stream_xchacha20_keygen()
     {
-        return random_bytes(self::CRYPTO_STREAM_XCHACHA20_KEYBYTES);
+        return random_bytes( self::CRYPTO_STREAM_XCHACHA20_KEYBYTES );
     }
 
     /**
@@ -3176,20 +3176,20 @@ 
      * @psalm-suppress TooFewArguments
      * @psalm-suppress MixedArgument
      */
-    public static function hex2bin($string)
+    public static function hex2bin( $string )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $string, 'string', 1 );
 
-        if (self::useNewSodiumAPI()) {
-            if (is_callable('sodium_hex2bin')) {
-                return (string) sodium_hex2bin($string);
+        if ( self::useNewSodiumAPI() ) {
+            if ( is_callable( 'sodium_hex2bin' ) ) {
+                return (string)sodium_hex2bin( $string );
             }
         }
-        if (self::use_fallback('hex2bin')) {
-            return (string) call_user_func('\\Sodium\\hex2bin', $string);
+        if ( self::use_fallback( 'hex2bin' ) ) {
+            return (string)call_user_func( '\\Sodium\\hex2bin', $string );
         }
-        return ParagonIE_Sodium_Core_Util::hex2bin($string);
+        return ParagonIE_Sodium_Core_Util::hex2bin( $string );
     }
 
     /**
@@ -3202,29 +3202,29 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function increment(&$var)
+    public static function increment( &$var )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $var, 'string', 1 );
 
-        if (self::useNewSodiumAPI()) {
-            sodium_increment($var);
+        if ( self::useNewSodiumAPI() ) {
+            sodium_increment( $var );
             return;
         }
-        if (self::use_fallback('increment')) {
+        if ( self::use_fallback( 'increment' ) ) {
             $func = '\\Sodium\\increment';
-            $func($var);
+            $func( $var );
             return;
         }
 
-        $len = ParagonIE_Sodium_Core_Util::strlen($var);
+        $len = ParagonIE_Sodium_Core_Util::strlen( $var );
         $c = 1;
         $copy = '';
-        for ($i = 0; $i < $len; ++$i) {
+        for ( $i = 0; $i < $len; ++$i ) {
             $c += ParagonIE_Sodium_Core_Util::chrToInt(
-                ParagonIE_Sodium_Core_Util::substr($var, $i, 1)
+                ParagonIE_Sodium_Core_Util::substr( $var, $i, 1 )
             );
-            $copy .= ParagonIE_Sodium_Core_Util::intToChr($c);
+            $copy .= ParagonIE_Sodium_Core_Util::intToChr( $c );
             $c >>= 8;
         }
         $var = $copy;
@@ -3236,13 +3236,13 @@ 
      *
      * @throws SodiumException
      */
-    public static function is_zero($str)
+    public static function is_zero( $str )
     {
         $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= ParagonIE_Sodium_Core_Util::chrToInt($str[$i]);
+        for ( $i = 0; $i < 32; ++$i ) {
+            $d |= ParagonIE_Sodium_Core_Util::chrToInt( $str[ $i ] );
         }
-        return ((($d - 1) >> 31) & 1) === 1;
+        return ( ( ( $d - 1 ) >> 31 ) & 1 ) === 1;
     }
 
     /**
@@ -3253,12 +3253,12 @@ 
      */
     public static function library_version_major()
     {
-        if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MAJOR_VERSION')) {
+        if ( self::useNewSodiumAPI() && defined( 'SODIUM_LIBRARY_MAJOR_VERSION' ) ) {
             return SODIUM_LIBRARY_MAJOR_VERSION;
         }
-        if (self::use_fallback('library_version_major')) {
+        if ( self::use_fallback( 'library_version_major' ) ) {
             /** @psalm-suppress UndefinedFunction */
-            return (int) call_user_func('\\Sodium\\library_version_major');
+            return (int)call_user_func( '\\Sodium\\library_version_major' );
         }
         return self::LIBRARY_VERSION_MAJOR;
     }
@@ -3271,12 +3271,12 @@ 
      */
     public static function library_version_minor()
     {
-        if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MINOR_VERSION')) {
+        if ( self::useNewSodiumAPI() && defined( 'SODIUM_LIBRARY_MINOR_VERSION' ) ) {
             return SODIUM_LIBRARY_MINOR_VERSION;
         }
-        if (self::use_fallback('library_version_minor')) {
+        if ( self::use_fallback( 'library_version_minor' ) ) {
             /** @psalm-suppress UndefinedFunction */
-            return (int) call_user_func('\\Sodium\\library_version_minor');
+            return (int)call_user_func( '\\Sodium\\library_version_minor' );
         }
         return self::LIBRARY_VERSION_MINOR;
     }
@@ -3291,21 +3291,21 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function memcmp($left, $right)
+    public static function memcmp( $left, $right )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($left, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($right, 'string', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $left, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $right, 'string', 2 );
 
-        if (self::useNewSodiumAPI()) {
-            return sodium_memcmp($left, $right);
+        if ( self::useNewSodiumAPI() ) {
+            return sodium_memcmp( $left, $right );
         }
-        if (self::use_fallback('memcmp')) {
-            return (int) call_user_func('\\Sodium\\memcmp', $left, $right);
+        if ( self::use_fallback( 'memcmp' ) ) {
+            return (int)call_user_func( '\\Sodium\\memcmp', $left, $right );
         }
         /** @var string $left */
         /** @var string $right */
-        return ParagonIE_Sodium_Core_Util::memcmp($left, $right);
+        return ParagonIE_Sodium_Core_Util::memcmp( $left, $right );
     }
 
     /**
@@ -3320,20 +3320,20 @@ 
      * @throws TypeError
      * @psalm-suppress TooFewArguments
      */
-    public static function memzero(&$var)
+    public static function memzero( &$var )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $var, 'string', 1 );
 
-        if (self::useNewSodiumAPI()) {
+        if ( self::useNewSodiumAPI() ) {
             /** @psalm-suppress MixedArgument */
-            sodium_memzero($var);
+            sodium_memzero( $var );
             return;
         }
-        if (self::use_fallback('memzero')) {
+        if ( self::use_fallback( 'memzero' ) ) {
             $func = '\\Sodium\\memzero';
-            $func($var);
-            if ($var === null) {
+            $func( $var );
+            if ( $var === null ) {
                 return;
             }
         }
@@ -3351,57 +3351,57 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function pad($unpadded, $blockSize, $dontFallback = false)
+    public static function pad( $unpadded, $blockSize, $dontFallback = false )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($unpadded, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($blockSize, 'int', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $unpadded, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $blockSize, 'int', 2 );
 
-        $unpadded = (string) $unpadded;
-        $blockSize = (int) $blockSize;
+        $unpadded = (string)$unpadded;
+        $blockSize = (int)$blockSize;
 
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return (string) sodium_pad($unpadded, $blockSize);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return (string)sodium_pad( $unpadded, $blockSize );
         }
 
-        if ($blockSize <= 0) {
+        if ( $blockSize <= 0 ) {
             throw new SodiumException(
                 'block size cannot be less than 1'
             );
         }
-        $unpadded_len = ParagonIE_Sodium_Core_Util::strlen($unpadded);
-        $xpadlen = ($blockSize - 1);
-        if (($blockSize & ($blockSize - 1)) === 0) {
-            $xpadlen -= $unpadded_len & ($blockSize - 1);
+        $unpadded_len = ParagonIE_Sodium_Core_Util::strlen( $unpadded );
+        $xpadlen = ( $blockSize - 1 );
+        if ( ( $blockSize & ( $blockSize - 1 ) ) === 0 ) {
+            $xpadlen -= $unpadded_len & ( $blockSize - 1 );
         } else {
             $xpadlen -= $unpadded_len % $blockSize;
         }
 
         $xpadded_len = $unpadded_len + $xpadlen;
-        $padded = str_repeat("\0", $xpadded_len - 1);
-        if ($unpadded_len > 0) {
+        $padded = str_repeat( "\0", $xpadded_len - 1 );
+        if ( $unpadded_len > 0 ) {
             $st = 1;
             $i = 0;
             $k = $unpadded_len;
-            for ($j = 0; $j <= $xpadded_len; ++$j) {
-                $i = (int) $i;
-                $k = (int) $k;
-                $st = (int) $st;
-                if ($j >= $unpadded_len) {
-                    $padded[$j] = "\0";
+            for ( $j = 0; $j <= $xpadded_len; ++$j ) {
+                $i = (int)$i;
+                $k = (int)$k;
+                $st = (int)$st;
+                if ( $j >= $unpadded_len ) {
+                    $padded[ $j ] = "\0";
                 } else {
-                    $padded[$j] = $unpadded[$j];
+                    $padded[ $j ] = $unpadded[ $j ];
                 }
                 /** @var int $k */
                 $k -= $st;
-                $st = (int) (~(
+                $st = (int)( ~(
                             (
                                 (
-                                    ($k >> 48)
+                                    ( $k >> 48 )
                                         |
-                                    ($k >> 32)
+                                    ( $k >> 32 )
                                         |
-                                    ($k >> 16)
+                                    ( $k >> 16 )
                                         |
                                     $k
                                 ) - 1
@@ -3414,15 +3414,15 @@ 
 
         $mask = 0;
         $tail = $xpadded_len;
-        for ($i = 0; $i < $blockSize; ++$i) {
+        for ( $i = 0; $i < $blockSize; ++$i ) {
             # barrier_mask = (unsigned char)
             #     (((i ^ xpadlen) - 1U) >> ((sizeof(size_t) - 1U) * CHAR_BIT));
-            $barrier_mask = (($i ^ $xpadlen) -1) >> ((PHP_INT_SIZE << 3) - 1);
+            $barrier_mask = ( ( $i ^ $xpadlen ) - 1 ) >> ( ( PHP_INT_SIZE << 3 ) - 1 );
             # tail[-i] = (tail[-i] & mask) | (0x80 & barrier_mask);
-            $padded[$tail - $i] = ParagonIE_Sodium_Core_Util::intToChr(
-                (ParagonIE_Sodium_Core_Util::chrToInt($padded[$tail - $i]) & $mask)
+            $padded[ $tail - $i ] = ParagonIE_Sodium_Core_Util::intToChr(
+                ( ParagonIE_Sodium_Core_Util::chrToInt( $padded[ $tail - $i ] ) & $mask )
                     |
-                (0x80 & $barrier_mask)
+                ( 0x80 & $barrier_mask )
             );
             # mask |= barrier_mask;
             $mask |= $barrier_mask;
@@ -3437,24 +3437,24 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function unpad($padded, $blockSize, $dontFallback = false)
+    public static function unpad( $padded, $blockSize, $dontFallback = false )
     {
         /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($padded, 'string', 1);
-        ParagonIE_Sodium_Core_Util::declareScalarType($blockSize, 'int', 2);
+        ParagonIE_Sodium_Core_Util::declareScalarType( $padded, 'string', 1 );
+        ParagonIE_Sodium_Core_Util::declareScalarType( $blockSize, 'int', 2 );
 
-        $padded = (string) $padded;
-        $blockSize = (int) $blockSize;
+        $padded = (string)$padded;
+        $blockSize = (int)$blockSize;
 
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return (string) sodium_unpad($padded, $blockSize);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return (string)sodium_unpad( $padded, $blockSize );
         }
-        if ($blockSize <= 0) {
-            throw new SodiumException('block size cannot be less than 1');
+        if ( $blockSize <= 0 ) {
+            throw new SodiumException( 'block size cannot be less than 1' );
         }
-        $padded_len = ParagonIE_Sodium_Core_Util::strlen($padded);
-        if ($padded_len < $blockSize) {
-            throw new SodiumException('invalid padding');
+        $padded_len = ParagonIE_Sodium_Core_Util::strlen( $padded );
+        if ( $padded_len < $blockSize ) {
+            throw new SodiumException( 'invalid padding' );
         }
 
         # tail = &padded[padded_len - 1U];
@@ -3465,15 +3465,15 @@ 
         $pad_len = 0;
 
         $found = 0;
-        for ($i = 0; $i < $blockSize; ++$i) {
+        for ( $i = 0; $i < $blockSize; ++$i ) {
             # c = tail[-i];
-            $c = ParagonIE_Sodium_Core_Util::chrToInt($padded[$tail - $i]);
+            $c = ParagonIE_Sodium_Core_Util::chrToInt( $padded[ $tail - $i ] );
 
             # is_barrier =
             #     (( (acc - 1U) & (pad_len - 1U) & ((c ^ 0x80) - 1U) ) >> 8) & 1U;
             $is_barrier = (
                 (
-                    ($acc - 1) & ($pad_len - 1) & (($c ^ 80) - 1)
+                    ( $acc - 1 ) & ( $pad_len - 1 ) & ( ( $c ^ 80 ) - 1 )
                 ) >> 7
             ) & 1;
             $is_barrier &= ~$found;
@@ -3483,17 +3483,17 @@ 
             $acc |= $c;
 
             # pad_len |= i & (1U + ~is_barrier);
-            $pad_len |= $i & (1 + ~$is_barrier);
+            $pad_len |= $i & ( 1 + ~$is_barrier );
 
             # valid |= (unsigned char) is_barrier;
-            $valid |= ($is_barrier & 0xff);
+            $valid |= ( $is_barrier & 0xff );
         }
         # unpadded_len = padded_len - 1U - pad_len;
         $unpadded_len = $padded_len - 1 - $pad_len;
-        if ($valid !== 1) {
-            throw new SodiumException('invalid padding');
+        if ( $valid !== 1 ) {
+            throw new SodiumException( 'invalid padding' );
         }
-        return ParagonIE_Sodium_Core_Util::substr($padded, 0, $unpadded_len);
+        return ParagonIE_Sodium_Core_Util::substr( $padded, 0, $unpadded_len );
     }
 
     /**
@@ -3503,10 +3503,10 @@ 
      */
     public static function polyfill_is_fast()
     {
-        if (extension_loaded('sodium')) {
+        if ( extension_loaded( 'sodium' ) ) {
             return true;
         }
-        if (extension_loaded('libsodium')) {
+        if ( extension_loaded( 'libsodium' ) ) {
             return true;
         }
         return PHP_INT_SIZE === 8;
@@ -3521,22 +3521,22 @@ 
      * @throws Exception
      * @throws TypeError
      */
-    public static function randombytes_buf($numBytes)
+    public static function randombytes_buf( $numBytes )
     {
         /* Type checks: */
-        if (!is_int($numBytes)) {
-            if (is_numeric($numBytes)) {
-                $numBytes = (int) $numBytes;
+        if ( ! is_int( $numBytes ) ) {
+            if ( is_numeric( $numBytes ) ) {
+                $numBytes = (int)$numBytes;
             } else {
                 throw new TypeError(
-                    'Argument 1 must be an integer, ' . gettype($numBytes) . ' given.'
+                    'Argument 1 must be an integer, ' . gettype( $numBytes ) . ' given.'
                 );
             }
         }
-        if (self::use_fallback('randombytes_buf')) {
-            return (string) call_user_func('\\Sodium\\randombytes_buf', $numBytes);
+        if ( self::use_fallback( 'randombytes_buf' ) ) {
+            return (string)call_user_func( '\\Sodium\\randombytes_buf', $numBytes );
         }
-        return random_bytes($numBytes);
+        return random_bytes( $numBytes );
     }
 
     /**
@@ -3548,22 +3548,22 @@ 
      * @throws Error
      * @throws TypeError
      */
-    public static function randombytes_uniform($range)
+    public static function randombytes_uniform( $range )
     {
         /* Type checks: */
-        if (!is_int($range)) {
-            if (is_numeric($range)) {
-                $range = (int) $range;
+        if ( ! is_int( $range ) ) {
+            if ( is_numeric( $range ) ) {
+                $range = (int)$range;
             } else {
                 throw new TypeError(
-                    'Argument 1 must be an integer, ' . gettype($range) . ' given.'
+                    'Argument 1 must be an integer, ' . gettype( $range ) . ' given.'
                 );
             }
         }
-        if (self::use_fallback('randombytes_uniform')) {
-            return (int) call_user_func('\\Sodium\\randombytes_uniform', $range);
+        if ( self::use_fallback( 'randombytes_uniform' ) ) {
+            return (int)call_user_func( '\\Sodium\\randombytes_uniform', $range );
         }
-        return random_int(0, $range - 1);
+        return random_int( 0, $range - 1 );
     }
 
     /**
@@ -3576,10 +3576,10 @@ 
      */
     public static function randombytes_random16()
     {
-        if (self::use_fallback('randombytes_random16')) {
-            return (int) call_user_func('\\Sodium\\randombytes_random16');
+        if ( self::use_fallback( 'randombytes_random16' ) ) {
+            return (int)call_user_func( '\\Sodium\\randombytes_random16' );
         }
-        return random_int(0, 65535);
+        return random_int( 0, 65535 );
     }
 
     /**
@@ -3588,17 +3588,17 @@ 
      * @return bool
      * @throws SodiumException
      */
-    public static function ristretto255_is_valid_point($p, $dontFallback = false)
+    public static function ristretto255_is_valid_point( $p, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_is_valid_point($p);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_is_valid_point( $p );
         }
         try {
-            $r = ParagonIE_Sodium_Core_Ristretto255::ristretto255_frombytes($p);
-            return $r['res'] === 0 &&
-                ParagonIE_Sodium_Core_Ristretto255::ristretto255_point_is_canonical($p) === 1;
-        } catch (SodiumException $ex) {
-            if ($ex->getMessage() === 'S is not canonical') {
+            $r = ParagonIE_Sodium_Core_Ristretto255::ristretto255_frombytes( $p );
+            return $r[ 'res' ] === 0 &&
+                ParagonIE_Sodium_Core_Ristretto255::ristretto255_point_is_canonical( $p ) === 1;
+        } catch ( SodiumException $ex ) {
+            if ( $ex->getMessage() === 'S is not canonical' ) {
                 return false;
             }
             throw $ex;
@@ -3612,12 +3612,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_add($p, $q, $dontFallback = false)
+    public static function ristretto255_add( $p, $q, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_add($p, $q);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_add( $p, $q );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_add($p, $q);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_add( $p, $q );
     }
 
     /**
@@ -3627,12 +3627,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_sub($p, $q, $dontFallback = false)
+    public static function ristretto255_sub( $p, $q, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_sub($p, $q);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_sub( $p, $q );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_sub($p, $q);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_sub( $p, $q );
     }
 
     /**
@@ -3642,12 +3642,12 @@ 
      *
      * @throws SodiumException
      */
-    public static function ristretto255_from_hash($r, $dontFallback = false)
+    public static function ristretto255_from_hash( $r, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_from_hash($r);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_from_hash( $r );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_from_hash($r);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_from_hash( $r );
     }
 
     /**
@@ -3656,9 +3656,9 @@ 
      *
      * @throws SodiumException
      */
-    public static function ristretto255_random($dontFallback = false)
+    public static function ristretto255_random( $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
             return sodium_crypto_core_ristretto255_random();
         }
         return ParagonIE_Sodium_Core_Ristretto255::ristretto255_random();
@@ -3670,9 +3670,9 @@ 
      *
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_random($dontFallback = false)
+    public static function ristretto255_scalar_random( $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
             return sodium_crypto_core_ristretto255_scalar_random();
         }
         return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_random();
@@ -3684,12 +3684,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_invert($s, $dontFallback = false)
+    public static function ristretto255_scalar_invert( $s, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_invert($s);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_scalar_invert( $s );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_invert($s);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_invert( $s );
     }
     /**
      * @param string $s
@@ -3697,12 +3697,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_negate($s, $dontFallback = false)
+    public static function ristretto255_scalar_negate( $s, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_negate($s);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_scalar_negate( $s );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_negate($s);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_negate( $s );
     }
 
     /**
@@ -3711,12 +3711,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_complement($s, $dontFallback = false)
+    public static function ristretto255_scalar_complement( $s, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_complement($s);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_scalar_complement( $s );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_complement($s);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_complement( $s );
     }
 
     /**
@@ -3726,12 +3726,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_add($x, $y, $dontFallback = false)
+    public static function ristretto255_scalar_add( $x, $y, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_add($x, $y);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_scalar_add( $x, $y );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_add($x, $y);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_add( $x, $y );
     }
 
     /**
@@ -3741,12 +3741,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_sub($x, $y, $dontFallback = false)
+    public static function ristretto255_scalar_sub( $x, $y, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_sub($x, $y);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_scalar_sub( $x, $y );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_sub($x, $y);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_sub( $x, $y );
     }
 
     /**
@@ -3756,12 +3756,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_mul($x, $y, $dontFallback = false)
+    public static function ristretto255_scalar_mul( $x, $y, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_mul($x, $y);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_scalar_mul( $x, $y );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_mul($x, $y);
+        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_mul( $x, $y );
     }
 
     /**
@@ -3771,12 +3771,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalarmult_ristretto255($n, $p, $dontFallback = false)
+    public static function scalarmult_ristretto255( $n, $p, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_scalarmult_ristretto255($n, $p);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_scalarmult_ristretto255( $n, $p );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255($n, $p);
+        return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255( $n, $p );
     }
 
     /**
@@ -3786,12 +3786,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalarmult_ristretto255_base($n, $dontFallback = false)
+    public static function scalarmult_ristretto255_base( $n, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_scalarmult_ristretto255_base($n);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_scalarmult_ristretto255_base( $n );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255_base($n);
+        return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255_base( $n );
     }
 
     /**
@@ -3800,12 +3800,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_reduce($s, $dontFallback = false)
+    public static function ristretto255_scalar_reduce( $s, $dontFallback = false )
     {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_reduce($s);
+        if ( self::useNewSodiumAPI() && ! $dontFallback ) {
+            return sodium_crypto_core_ristretto255_scalar_reduce( $s );
         }
-        return ParagonIE_Sodium_Core_Ristretto255::sc_reduce($s);
+        return ParagonIE_Sodium_Core_Ristretto255::sc_reduce( $s );
     }
 
     /**
@@ -3821,26 +3821,26 @@ 
      * @return bool           TRUE if we're fast enough, FALSE is not
      * @throws SodiumException
      */
-    public static function runtime_speed_test($iterations, $maxTimeout)
+    public static function runtime_speed_test( $iterations, $maxTimeout )
     {
-        if (self::polyfill_is_fast()) {
+        if ( self::polyfill_is_fast() ) {
             return true;
         }
         /** @var float $end */
         $end = 0.0;
         /** @var float $start */
-        $start = microtime(true);
+        $start = microtime( true );
         /** @var ParagonIE_Sodium_Core32_Int64 $a */
-        $a = ParagonIE_Sodium_Core32_Int64::fromInt(random_int(3, 1 << 16));
-        for ($i = 0; $i < $iterations; ++$i) {
+        $a = ParagonIE_Sodium_Core32_Int64::fromInt( random_int( 3, 1 << 16 ) );
+        for ( $i = 0; $i < $iterations; ++$i ) {
             /** @var ParagonIE_Sodium_Core32_Int64 $b */
-            $b = ParagonIE_Sodium_Core32_Int64::fromInt(random_int(3, 1 << 16));
-            $a->mulInt64($b);
+            $b = ParagonIE_Sodium_Core32_Int64::fromInt( random_int( 3, 1 << 16 ) );
+            $a->mulInt64( $b );
         }
         /** @var float $end */
-        $end = microtime(true);
+        $end = microtime( true );
         /** @var int $diff */
-        $diff = (int) ceil(($end - $start) * 1000);
+        $diff = (int)ceil( ( $end - $start ) * 1000 );
         return $diff < $maxTimeout;
     }
 
@@ -3855,23 +3855,23 @@ 
      * @return void
      * @throws SodiumException
      */
-    public static function sub(&$val, $addv)
+    public static function sub( &$val, $addv )
     {
-        $val_len = ParagonIE_Sodium_Core_Util::strlen($val);
-        $addv_len = ParagonIE_Sodium_Core_Util::strlen($addv);
-        if ($val_len !== $addv_len) {
-            throw new SodiumException('values must have the same length');
+        $val_len = ParagonIE_Sodium_Core_Util::strlen( $val );
+        $addv_len = ParagonIE_Sodium_Core_Util::strlen( $addv );
+        if ( $val_len !== $addv_len ) {
+            throw new SodiumException( 'values must have the same length' );
         }
-        $A = ParagonIE_Sodium_Core_Util::stringToIntArray($val);
-        $B = ParagonIE_Sodium_Core_Util::stringToIntArray($addv);
+        $A = ParagonIE_Sodium_Core_Util::stringToIntArray( $val );
+        $B = ParagonIE_Sodium_Core_Util::stringToIntArray( $addv );
 
         $c = 0;
-        for ($i = 0; $i < $val_len; $i++) {
-            $c = ($A[$i] - $B[$i] - $c);
-            $A[$i] = ($c & 0xff);
-            $c = ($c >> 8) & 1;
+        for ( $i = 0; $i < $val_len; $i++ ) {
+            $c = ( $A[ $i ] - $B[ $i ] - $c );
+            $A[ $i ] = ( $c & 0xff );
+            $c = ( $c >> 8 ) & 1;
         }
-        $val = ParagonIE_Sodium_Core_Util::intArrayToString($A);
+        $val = ParagonIE_Sodium_Core_Util::intArrayToString( $A );
     }
 
     /**
@@ -3884,13 +3884,13 @@ 
      */
     public static function version_string()
     {
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_version_string();
+        if ( self::useNewSodiumAPI() ) {
+            return (string)sodium_version_string();
         }
-        if (self::use_fallback('version_string')) {
-            return (string) call_user_func('\\Sodium\\version_string');
+        if ( self::use_fallback( 'version_string' ) ) {
+            return (string)call_user_func( '\\Sodium\\version_string' );
         }
-        return (string) self::VERSION_STRING;
+        return (string)self::VERSION_STRING;
     }
 
     /**
@@ -3905,22 +3905,22 @@ 
      *
      * @return bool
      */
-    protected static function use_fallback($sodium_func_name = '')
+    protected static function use_fallback( $sodium_func_name = '' )
     {
         static $res = null;
-        if ($res === null) {
-            $res = extension_loaded('libsodium') && PHP_VERSION_ID >= 50300;
+        if ( $res === null ) {
+            $res = extension_loaded( 'libsodium' ) && PHP_VERSION_ID >= 50300;
         }
-        if ($res === false) {
+        if ( $res === false ) {
             // No libsodium installed
             return false;
         }
-        if (self::$disableFallbackForUnitTests) {
+        if ( self::$disableFallbackForUnitTests ) {
             // Don't fallback. Use the PHP implementation.
             return false;
         }
-        if (!empty($sodium_func_name)) {
-            return is_callable('\\Sodium\\' . $sodium_func_name);
+        if ( ! empty( $sodium_func_name ) ) {
+            return is_callable( '\\Sodium\\' . $sodium_func_name );
         }
         return true;
     }
@@ -3935,13 +3935,13 @@ 
     protected static function useNewSodiumAPI()
     {
         static $res = null;
-        if ($res === null) {
-            $res = PHP_VERSION_ID >= 70000 && extension_loaded('sodium');
+        if ( $res === null ) {
+            $res = PHP_VERSION_ID >= 70000 && extension_loaded( 'sodium' );
         }
-        if (self::$disableFallbackForUnitTests) {
+        if ( self::$disableFallbackForUnitTests ) {
             // Don't fallback. Use the PHP implementation.
             return false;
         }
-        return (bool) $res;
+        return (bool)$res;
     }
 }

vendor/paragonie/sodium_compat/src/Crypto32.php

Spacing +290 added lines, -290 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Crypto32', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Crypto32', false ) ) {
     return;
 }
 
@@ -75,13 +75,13 @@ 
         $key = ''
     ) {
         /** @var int $len - Length of message (ciphertext + MAC) */
-        $len = ParagonIE_Sodium_Core32_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core32_Util::strlen( $message );
 
         /** @var int  $clen - Length of ciphertext */
         $clen = $len - self::aead_chacha20poly1305_ABYTES;
 
         /** @var int $adlen - Length of associated data */
-        $adlen = ParagonIE_Sodium_Core32_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core32_Util::strlen( $ad );
 
         /** @var string $mac - Message authentication code */
         $mac = ParagonIE_Sodium_Core32_Util::substr(
@@ -91,7 +91,7 @@ 
         );
 
         /** @var string $ciphertext - The encrypted message (sans MAC) */
-        $ciphertext = ParagonIE_Sodium_Core32_Util::substr($message, 0, $clen);
+        $ciphertext = ParagonIE_Sodium_Core32_Util::substr( $message, 0, $clen );
 
         /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
         $block0 = ParagonIE_Sodium_Core32_ChaCha20::stream(
@@ -101,21 +101,21 @@ 
         );
 
         /* Recalculate the Poly1305 authentication tag (MAC): */
-        $state = new ParagonIE_Sodium_Core32_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core32_Poly1305_State( $block0 );
         try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $block0 );
+        } catch ( SodiumException $ex ) {
             $block0 = null;
         }
-        $state->update($ad);
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($adlen));
-        $state->update($ciphertext);
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($clen));
+        $state->update( $ad );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $adlen ) );
+        $state->update( $ciphertext );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $clen ) );
         $computed_mac = $state->finish();
 
         /* Compare the given MAC with the recalculated MAC: */
-        if (!ParagonIE_Sodium_Core32_Util::verify_16($computed_mac, $mac)) {
-            throw new SodiumException('Invalid MAC');
+        if ( ! ParagonIE_Sodium_Core32_Util::verify_16( $computed_mac, $mac ) ) {
+            throw new SodiumException( 'Invalid MAC' );
         }
 
         // Here, we know that the MAC is valid, so we decrypt and return the plaintext
@@ -123,7 +123,7 @@ 
             $ciphertext,
             $nonce,
             $key,
-            ParagonIE_Sodium_Core32_Util::store64_le(1)
+            ParagonIE_Sodium_Core32_Util::store64_le( 1 )
         );
     }
 
@@ -147,10 +147,10 @@ 
         $key = ''
     ) {
         /** @var int $len - Length of the plaintext message */
-        $len = ParagonIE_Sodium_Core32_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core32_Util::strlen( $message );
 
         /** @var int $adlen - Length of the associated data */
-        $adlen = ParagonIE_Sodium_Core32_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core32_Util::strlen( $ad );
 
         /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
         $block0 = ParagonIE_Sodium_Core32_ChaCha20::stream(
@@ -158,10 +158,10 @@ 
             $nonce,
             $key
         );
-        $state = new ParagonIE_Sodium_Core32_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core32_Poly1305_State( $block0 );
         try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $block0 );
+        } catch ( SodiumException $ex ) {
             $block0 = null;
         }
 
@@ -170,13 +170,13 @@ 
             $message,
             $nonce,
             $key,
-            ParagonIE_Sodium_Core32_Util::store64_le(1)
+            ParagonIE_Sodium_Core32_Util::store64_le( 1 )
         );
 
-        $state->update($ad);
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($adlen));
-        $state->update($ciphertext);
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($len));
+        $state->update( $ad );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $adlen ) );
+        $state->update( $ciphertext );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $len ) );
         return $ciphertext . $state->finish();
     }
 
@@ -200,10 +200,10 @@ 
         $key = ''
     ) {
         /** @var int $adlen - Length of associated data */
-        $adlen = ParagonIE_Sodium_Core32_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core32_Util::strlen( $ad );
 
         /** @var int $len - Length of message (ciphertext + MAC) */
-        $len = ParagonIE_Sodium_Core32_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core32_Util::strlen( $message );
 
         /** @var int  $clen - Length of ciphertext */
         $clen = $len - self::aead_chacha20poly1305_IETF_ABYTES;
@@ -230,23 +230,23 @@ 
         );
 
         /* Recalculate the Poly1305 authentication tag (MAC): */
-        $state = new ParagonIE_Sodium_Core32_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core32_Poly1305_State( $block0 );
         try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $block0 );
+        } catch ( SodiumException $ex ) {
             $block0 = null;
         }
-        $state->update($ad);
-        $state->update(str_repeat("\x00", ((0x10 - $adlen) & 0xf)));
-        $state->update($ciphertext);
-        $state->update(str_repeat("\x00", (0x10 - $clen) & 0xf));
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($adlen));
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($clen));
+        $state->update( $ad );
+        $state->update( str_repeat( "\x00", ( ( 0x10 - $adlen ) & 0xf ) ) );
+        $state->update( $ciphertext );
+        $state->update( str_repeat( "\x00", ( 0x10 - $clen ) & 0xf ) );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $adlen ) );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $clen ) );
         $computed_mac = $state->finish();
 
         /* Compare the given MAC with the recalculated MAC: */
-        if (!ParagonIE_Sodium_Core32_Util::verify_16($computed_mac, $mac)) {
-            throw new SodiumException('Invalid MAC');
+        if ( ! ParagonIE_Sodium_Core32_Util::verify_16( $computed_mac, $mac ) ) {
+            throw new SodiumException( 'Invalid MAC' );
         }
 
         // Here, we know that the MAC is valid, so we decrypt and return the plaintext
@@ -254,7 +254,7 @@ 
             $ciphertext,
             $nonce,
             $key,
-            ParagonIE_Sodium_Core32_Util::store64_le(1)
+            ParagonIE_Sodium_Core32_Util::store64_le( 1 )
         );
     }
 
@@ -278,10 +278,10 @@ 
         $key = ''
     ) {
         /** @var int $len - Length of the plaintext message */
-        $len = ParagonIE_Sodium_Core32_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core32_Util::strlen( $message );
 
         /** @var int $adlen - Length of the associated data */
-        $adlen = ParagonIE_Sodium_Core32_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core32_Util::strlen( $ad );
 
         /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
         $block0 = ParagonIE_Sodium_Core32_ChaCha20::ietfStream(
@@ -289,10 +289,10 @@ 
             $nonce,
             $key
         );
-        $state = new ParagonIE_Sodium_Core32_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core32_Poly1305_State( $block0 );
         try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $block0 );
+        } catch ( SodiumException $ex ) {
             $block0 = null;
         }
 
@@ -301,15 +301,15 @@ 
             $message,
             $nonce,
             $key,
-            ParagonIE_Sodium_Core32_Util::store64_le(1)
+            ParagonIE_Sodium_Core32_Util::store64_le( 1 )
         );
 
-        $state->update($ad);
-        $state->update(str_repeat("\x00", ((0x10 - $adlen) & 0xf)));
-        $state->update($ciphertext);
-        $state->update(str_repeat("\x00", ((0x10 - $len) & 0xf)));
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($adlen));
-        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($len));
+        $state->update( $ad );
+        $state->update( str_repeat( "\x00", ( ( 0x10 - $adlen ) & 0xf ) ) );
+        $state->update( $ciphertext );
+        $state->update( str_repeat( "\x00", ( ( 0x10 - $len ) & 0xf ) ) );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $adlen ) );
+        $state->update( ParagonIE_Sodium_Core32_Util::store64_le( $len ) );
         return $ciphertext . $state->finish();
     }
 
@@ -333,13 +333,13 @@ 
         $key = ''
     ) {
         $subkey = ParagonIE_Sodium_Core32_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 0, 16),
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 0, 16 ),
             $key
         );
         $nonceLast = "\x00\x00\x00\x00" .
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 );
 
-        return self::aead_chacha20poly1305_ietf_decrypt($message, $ad, $nonceLast, $subkey);
+        return self::aead_chacha20poly1305_ietf_decrypt( $message, $ad, $nonceLast, $subkey );
     }
 
     /**
@@ -362,13 +362,13 @@ 
         $key = ''
     ) {
         $subkey = ParagonIE_Sodium_Core32_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 0, 16),
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 0, 16 ),
             $key
         );
         $nonceLast = "\x00\x00\x00\x00" .
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 );
 
-        return self::aead_chacha20poly1305_ietf_encrypt($message, $ad, $nonceLast, $subkey);
+        return self::aead_chacha20poly1305_ietf_encrypt( $message, $ad, $nonceLast, $subkey );
     }
 
     /**
@@ -381,10 +381,10 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function auth($message, $key)
+    public static function auth( $message, $key )
     {
         return ParagonIE_Sodium_Core32_Util::substr(
-            hash_hmac('sha512', $message, $key, true),
+            hash_hmac( 'sha512', $message, $key, true ),
             0,
             32
         );
@@ -402,11 +402,11 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function auth_verify($mac, $message, $key)
+    public static function auth_verify( $mac, $message, $key )
     {
         return ParagonIE_Sodium_Core32_Util::hashEquals(
             $mac,
-            self::auth($message, $key)
+            self::auth( $message, $key )
         );
     }
 
@@ -422,14 +422,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box($plaintext, $nonce, $keypair)
+    public static function box( $plaintext, $nonce, $keypair )
     {
         return self::secretbox(
             $plaintext,
             $nonce,
             self::box_beforenm(
-                self::box_secretkey($keypair),
-                self::box_publickey($keypair)
+                self::box_secretkey( $keypair ),
+                self::box_publickey( $keypair )
             )
         );
     }
@@ -445,16 +445,16 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seal($message, $publicKey)
+    public static function box_seal( $message, $publicKey )
     {
         /** @var string $ephemeralKeypair */
         $ephemeralKeypair = self::box_keypair();
 
         /** @var string $ephemeralSK */
-        $ephemeralSK = self::box_secretkey($ephemeralKeypair);
+        $ephemeralSK = self::box_secretkey( $ephemeralKeypair );
 
         /** @var string $ephemeralPK */
-        $ephemeralPK = self::box_publickey($ephemeralKeypair);
+        $ephemeralPK = self::box_publickey( $ephemeralKeypair );
 
         /** @var string $nonce */
         $nonce = self::generichash(
@@ -464,15 +464,15 @@ 
         );
 
         /** @var string $keypair - The combined keypair used in crypto_box() */
-        $keypair = self::box_keypair_from_secretkey_and_publickey($ephemeralSK, $publicKey);
+        $keypair = self::box_keypair_from_secretkey_and_publickey( $ephemeralSK, $publicKey );
 
         /** @var string $ciphertext Ciphertext + MAC from crypto_box */
-        $ciphertext = self::box($message, $nonce, $keypair);
+        $ciphertext = self::box( $message, $nonce, $keypair );
         try {
-            ParagonIE_Sodium_Compat::memzero($ephemeralKeypair);
-            ParagonIE_Sodium_Compat::memzero($ephemeralSK);
-            ParagonIE_Sodium_Compat::memzero($nonce);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $ephemeralKeypair );
+            ParagonIE_Sodium_Compat::memzero( $ephemeralSK );
+            ParagonIE_Sodium_Compat::memzero( $nonce );
+        } catch ( SodiumException $ex ) {
             $ephemeralKeypair = null;
             $ephemeralSK = null;
             $nonce = null;
@@ -491,19 +491,19 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seal_open($message, $keypair)
+    public static function box_seal_open( $message, $keypair )
     {
         /** @var string $ephemeralPK */
-        $ephemeralPK = ParagonIE_Sodium_Core32_Util::substr($message, 0, 32);
+        $ephemeralPK = ParagonIE_Sodium_Core32_Util::substr( $message, 0, 32 );
 
         /** @var string $ciphertext (ciphertext + MAC) */
-        $ciphertext = ParagonIE_Sodium_Core32_Util::substr($message, 32);
+        $ciphertext = ParagonIE_Sodium_Core32_Util::substr( $message, 32 );
 
         /** @var string $secretKey */
-        $secretKey = self::box_secretkey($keypair);
+        $secretKey = self::box_secretkey( $keypair );
 
         /** @var string $publicKey */
-        $publicKey = self::box_publickey($keypair);
+        $publicKey = self::box_publickey( $keypair );
 
         /** @var string $nonce */
         $nonce = self::generichash(
@@ -513,15 +513,15 @@ 
         );
 
         /** @var string $keypair */
-        $keypair = self::box_keypair_from_secretkey_and_publickey($secretKey, $ephemeralPK);
+        $keypair = self::box_keypair_from_secretkey_and_publickey( $secretKey, $ephemeralPK );
 
         /** @var string $m */
-        $m = self::box_open($ciphertext, $nonce, $keypair);
+        $m = self::box_open( $ciphertext, $nonce, $keypair );
         try {
-            ParagonIE_Sodium_Compat::memzero($secretKey);
-            ParagonIE_Sodium_Compat::memzero($ephemeralPK);
-            ParagonIE_Sodium_Compat::memzero($nonce);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $secretKey );
+            ParagonIE_Sodium_Compat::memzero( $ephemeralPK );
+            ParagonIE_Sodium_Compat::memzero( $nonce );
+        } catch ( SodiumException $ex ) {
             $secretKey = null;
             $ephemeralPK = null;
             $nonce = null;
@@ -540,11 +540,11 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_beforenm($sk, $pk)
+    public static function box_beforenm( $sk, $pk )
     {
         return ParagonIE_Sodium_Core32_HSalsa20::hsalsa20(
-            str_repeat("\x00", 16),
-            self::scalarmult($sk, $pk)
+            str_repeat( "\x00", 16 ),
+            self::scalarmult( $sk, $pk )
         );
     }
 
@@ -558,8 +558,8 @@ 
      */
     public static function box_keypair()
     {
-        $sKey = random_bytes(32);
-        $pKey = self::scalarmult_base($sKey);
+        $sKey = random_bytes( 32 );
+        $pKey = self::scalarmult_base( $sKey );
         return $sKey . $pKey;
     }
 
@@ -569,14 +569,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seed_keypair($seed)
+    public static function box_seed_keypair( $seed )
     {
         $sKey = ParagonIE_Sodium_Core32_Util::substr(
-            hash('sha512', $seed, true),
+            hash( 'sha512', $seed, true ),
             0,
             32
         );
-        $pKey = self::scalarmult_base($sKey);
+        $pKey = self::scalarmult_base( $sKey );
         return $sKey . $pKey;
     }
 
@@ -588,10 +588,10 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function box_keypair_from_secretkey_and_publickey($sKey, $pKey)
+    public static function box_keypair_from_secretkey_and_publickey( $sKey, $pKey )
     {
-        return ParagonIE_Sodium_Core32_Util::substr($sKey, 0, 32) .
-            ParagonIE_Sodium_Core32_Util::substr($pKey, 0, 32);
+        return ParagonIE_Sodium_Core32_Util::substr( $sKey, 0, 32 ) .
+            ParagonIE_Sodium_Core32_Util::substr( $pKey, 0, 32 );
     }
 
     /**
@@ -602,14 +602,14 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function box_secretkey($keypair)
+    public static function box_secretkey( $keypair )
     {
-        if (ParagonIE_Sodium_Core32_Util::strlen($keypair) !== 64) {
+        if ( ParagonIE_Sodium_Core32_Util::strlen( $keypair ) !== 64 ) {
             throw new RangeException(
                 'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES bytes long.'
             );
         }
-        return ParagonIE_Sodium_Core32_Util::substr($keypair, 0, 32);
+        return ParagonIE_Sodium_Core32_Util::substr( $keypair, 0, 32 );
     }
 
     /**
@@ -620,14 +620,14 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function box_publickey($keypair)
+    public static function box_publickey( $keypair )
     {
-        if (ParagonIE_Sodium_Core32_Util::strlen($keypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
+        if ( ParagonIE_Sodium_Core32_Util::strlen( $keypair ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES ) {
             throw new RangeException(
                 'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES bytes long.'
             );
         }
-        return ParagonIE_Sodium_Core32_Util::substr($keypair, 32, 32);
+        return ParagonIE_Sodium_Core32_Util::substr( $keypair, 32, 32 );
     }
 
     /**
@@ -639,14 +639,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_publickey_from_secretkey($sKey)
+    public static function box_publickey_from_secretkey( $sKey )
     {
-        if (ParagonIE_Sodium_Core32_Util::strlen($sKey) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES) {
+        if ( ParagonIE_Sodium_Core32_Util::strlen( $sKey ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES ) {
             throw new RangeException(
                 'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES bytes long.'
             );
         }
-        return self::scalarmult_base($sKey);
+        return self::scalarmult_base( $sKey );
     }
 
     /**
@@ -661,14 +661,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_open($ciphertext, $nonce, $keypair)
+    public static function box_open( $ciphertext, $nonce, $keypair )
     {
         return self::secretbox_open(
             $ciphertext,
             $nonce,
             self::box_beforenm(
-                self::box_secretkey($keypair),
-                self::box_publickey($keypair)
+                self::box_secretkey( $keypair ),
+                self::box_publickey( $keypair )
             )
         );
     }
@@ -686,34 +686,34 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function generichash($message, $key = '', $outlen = 32)
+    public static function generichash( $message, $key = '', $outlen = 32 )
     {
         // This ensures that ParagonIE_Sodium_Core32_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core32_BLAKE2b::pseudoConstructor();
 
         $k = null;
-        if (!empty($key)) {
+        if ( ! empty( $key ) ) {
             /** @var SplFixedArray $k */
-            $k = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core32_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
+            $k = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray( $key );
+            if ( $k->count() > ParagonIE_Sodium_Core32_BLAKE2b::KEYBYTES ) {
+                throw new RangeException( 'Invalid key size' );
             }
         }
 
         /** @var SplFixedArray $in */
-        $in = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray($message);
+        $in = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray( $message );
 
         /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core32_BLAKE2b::init($k, $outlen);
-        ParagonIE_Sodium_Core32_BLAKE2b::update($ctx, $in, $in->count());
+        $ctx = ParagonIE_Sodium_Core32_BLAKE2b::init( $k, $outlen );
+        ParagonIE_Sodium_Core32_BLAKE2b::update( $ctx, $in, $in->count() );
 
         /** @var SplFixedArray $out */
-        $out = new SplFixedArray($outlen);
-        $out = ParagonIE_Sodium_Core32_BLAKE2b::finish($ctx, $out);
+        $out = new SplFixedArray( $outlen );
+        $out = ParagonIE_Sodium_Core32_BLAKE2b::finish( $ctx, $out );
 
         /** @var array<int, int> */
         $outArray = $out->toArray();
-        return ParagonIE_Sodium_Core32_Util::intArrayToString($outArray);
+        return ParagonIE_Sodium_Core32_Util::intArrayToString( $outArray );
     }
 
     /**
@@ -727,22 +727,22 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function generichash_final($ctx, $outlen = 32)
+    public static function generichash_final( $ctx, $outlen = 32 )
     {
-        if (!is_string($ctx)) {
-            throw new TypeError('Context must be a string');
+        if ( ! is_string( $ctx ) ) {
+            throw new TypeError( 'Context must be a string' );
         }
-        $out = new SplFixedArray($outlen);
+        $out = new SplFixedArray( $outlen );
 
         /** @var SplFixedArray $context */
-        $context = ParagonIE_Sodium_Core32_BLAKE2b::stringToContext($ctx);
+        $context = ParagonIE_Sodium_Core32_BLAKE2b::stringToContext( $ctx );
 
         /** @var SplFixedArray $out */
-        $out = ParagonIE_Sodium_Core32_BLAKE2b::finish($context, $out);
+        $out = ParagonIE_Sodium_Core32_BLAKE2b::finish( $context, $out );
 
         /** @var array<int, int> */
         $outArray = $out->toArray();
-        return ParagonIE_Sodium_Core32_Util::intArrayToString($outArray);
+        return ParagonIE_Sodium_Core32_Util::intArrayToString( $outArray );
     }
 
     /**
@@ -757,23 +757,23 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function generichash_init($key = '', $outputLength = 32)
+    public static function generichash_init( $key = '', $outputLength = 32 )
     {
         // This ensures that ParagonIE_Sodium_Core32_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core32_BLAKE2b::pseudoConstructor();
 
         $k = null;
-        if (!empty($key)) {
-            $k = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core32_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
+        if ( ! empty( $key ) ) {
+            $k = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray( $key );
+            if ( $k->count() > ParagonIE_Sodium_Core32_BLAKE2b::KEYBYTES ) {
+                throw new RangeException( 'Invalid key size' );
             }
         }
 
         /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core32_BLAKE2b::init($k, $outputLength);
+        $ctx = ParagonIE_Sodium_Core32_BLAKE2b::init( $k, $outputLength );
 
-        return ParagonIE_Sodium_Core32_BLAKE2b::contextToString($ctx);
+        return ParagonIE_Sodium_Core32_BLAKE2b::contextToString( $ctx );
     }
 
     /**
@@ -800,27 +800,27 @@ 
         ParagonIE_Sodium_Core32_BLAKE2b::pseudoConstructor();
 
         $k = null;
-        if (!empty($key)) {
-            $k = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core32_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
+        if ( ! empty( $key ) ) {
+            $k = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray( $key );
+            if ( $k->count() > ParagonIE_Sodium_Core32_BLAKE2b::KEYBYTES ) {
+                throw new RangeException( 'Invalid key size' );
             }
         }
-        if (!empty($salt)) {
-            $s = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray($salt);
+        if ( ! empty( $salt ) ) {
+            $s = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray( $salt );
         } else {
             $s = null;
         }
-        if (!empty($salt)) {
-            $p = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray($personal);
+        if ( ! empty( $salt ) ) {
+            $p = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray( $personal );
         } else {
             $p = null;
         }
 
         /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core32_BLAKE2b::init($k, $outputLength, $s, $p);
+        $ctx = ParagonIE_Sodium_Core32_BLAKE2b::init( $k, $outputLength, $s, $p );
 
-        return ParagonIE_Sodium_Core32_BLAKE2b::contextToString($ctx);
+        return ParagonIE_Sodium_Core32_BLAKE2b::contextToString( $ctx );
     }
 
     /**
@@ -834,20 +834,20 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function generichash_update($ctx, $message)
+    public static function generichash_update( $ctx, $message )
     {
         // This ensures that ParagonIE_Sodium_Core32_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core32_BLAKE2b::pseudoConstructor();
 
         /** @var SplFixedArray $context */
-        $context = ParagonIE_Sodium_Core32_BLAKE2b::stringToContext($ctx);
+        $context = ParagonIE_Sodium_Core32_BLAKE2b::stringToContext( $ctx );
 
         /** @var SplFixedArray $in */
-        $in = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray($message);
+        $in = ParagonIE_Sodium_Core32_BLAKE2b::stringToSplFixedArray( $message );
 
-        ParagonIE_Sodium_Core32_BLAKE2b::update($context, $in, $in->count());
+        ParagonIE_Sodium_Core32_BLAKE2b::update( $context, $in, $in->count() );
 
-        return ParagonIE_Sodium_Core32_BLAKE2b::contextToString($context);
+        return ParagonIE_Sodium_Core32_BLAKE2b::contextToString( $context );
     }
 
     /**
@@ -863,10 +863,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function keyExchange($my_sk, $their_pk, $client_pk, $server_pk)
+    public static function keyExchange( $my_sk, $their_pk, $client_pk, $server_pk )
     {
         return self::generichash(
-            self::scalarmult($my_sk, $their_pk) .
+            self::scalarmult( $my_sk, $their_pk ) .
             $client_pk .
             $server_pk
         );
@@ -884,10 +884,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function scalarmult($sKey, $pKey)
+    public static function scalarmult( $sKey, $pKey )
     {
-        $q = ParagonIE_Sodium_Core32_X25519::crypto_scalarmult_curve25519_ref10($sKey, $pKey);
-        self::scalarmult_throw_if_zero($q);
+        $q = ParagonIE_Sodium_Core32_X25519::crypto_scalarmult_curve25519_ref10( $sKey, $pKey );
+        self::scalarmult_throw_if_zero( $q );
         return $q;
     }
 
@@ -901,10 +901,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function scalarmult_base($secret)
+    public static function scalarmult_base( $secret )
     {
-        $q = ParagonIE_Sodium_Core32_X25519::crypto_scalarmult_curve25519_ref10_base($secret);
-        self::scalarmult_throw_if_zero($q);
+        $q = ParagonIE_Sodium_Core32_X25519::crypto_scalarmult_curve25519_ref10_base( $secret );
+        self::scalarmult_throw_if_zero( $q );
         return $q;
     }
 
@@ -916,16 +916,16 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function scalarmult_throw_if_zero($q)
+    protected static function scalarmult_throw_if_zero( $q )
     {
         $d = 0;
-        for ($i = 0; $i < self::box_curve25519xsalsa20poly1305_SECRETKEYBYTES; ++$i) {
-            $d |= ParagonIE_Sodium_Core32_Util::chrToInt($q[$i]);
+        for ( $i = 0; $i < self::box_curve25519xsalsa20poly1305_SECRETKEYBYTES; ++$i ) {
+            $d |= ParagonIE_Sodium_Core32_Util::chrToInt( $q[ $i ] );
         }
 
         /* branch-free variant of === 0 */
-        if (-(1 & (($d - 1) >> 8))) {
-            throw new SodiumException('Zero public key is not allowed');
+        if (-( 1 & ( ( $d - 1 ) >> 8 ) )) {
+            throw new SodiumException( 'Zero public key is not allowed' );
         }
     }
 
@@ -941,26 +941,26 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox($plaintext, $nonce, $key)
+    public static function secretbox( $plaintext, $nonce, $key )
     {
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20( $nonce, $key );
 
         /** @var string $block0 */
-        $block0 = str_repeat("\x00", 32);
+        $block0 = str_repeat( "\x00", 32 );
 
         /** @var int $mlen - Length of the plaintext message */
-        $mlen = ParagonIE_Sodium_Core32_Util::strlen($plaintext);
+        $mlen = ParagonIE_Sodium_Core32_Util::strlen( $plaintext );
         $mlen0 = $mlen;
-        if ($mlen0 > 64 - self::secretbox_xsalsa20poly1305_ZEROBYTES) {
+        if ( $mlen0 > 64 - self::secretbox_xsalsa20poly1305_ZEROBYTES ) {
             $mlen0 = 64 - self::secretbox_xsalsa20poly1305_ZEROBYTES;
         }
-        $block0 .= ParagonIE_Sodium_Core32_Util::substr($plaintext, 0, $mlen0);
+        $block0 .= ParagonIE_Sodium_Core32_Util::substr( $plaintext, 0, $mlen0 );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor(
             $block0,
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 ),
             $subkey
         );
 
@@ -969,13 +969,13 @@ 
             $block0,
             self::secretbox_xsalsa20poly1305_ZEROBYTES
         );
-        if ($mlen > $mlen0) {
+        if ( $mlen > $mlen0 ) {
             $c .= ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
                 ParagonIE_Sodium_Core32_Util::substr(
                     $plaintext,
                     self::secretbox_xsalsa20poly1305_ZEROBYTES
                 ),
-                ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
+                ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 ),
                 1,
                 $subkey
             );
@@ -988,18 +988,18 @@ 
             )
         );
         try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-            ParagonIE_Sodium_Compat::memzero($subkey);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $block0 );
+            ParagonIE_Sodium_Compat::memzero( $subkey );
+        } catch ( SodiumException $ex ) {
             $block0 = null;
             $subkey = null;
         }
 
-        $state->update($c);
+        $state->update( $c );
 
         /** @var string $c - MAC || ciphertext */
         $c = $state->finish() . $c;
-        unset($state);
+        unset( $state );
 
         return $c;
     }
@@ -1016,7 +1016,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox_open($ciphertext, $nonce, $key)
+    public static function secretbox_open( $ciphertext, $nonce, $key )
     {
         /** @var string $mac */
         $mac = ParagonIE_Sodium_Core32_Util::substr(
@@ -1032,46 +1032,46 @@ 
         );
 
         /** @var int $clen */
-        $clen = ParagonIE_Sodium_Core32_Util::strlen($c);
+        $clen = ParagonIE_Sodium_Core32_Util::strlen( $c );
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20( $nonce, $key );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core32_Salsa20::salsa20(
             64,
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 ),
             $subkey
         );
         $verified = ParagonIE_Sodium_Core32_Poly1305::onetimeauth_verify(
             $mac,
             $c,
-            ParagonIE_Sodium_Core32_Util::substr($block0, 0, 32)
+            ParagonIE_Sodium_Core32_Util::substr( $block0, 0, 32 )
         );
-        if (!$verified) {
+        if ( ! $verified ) {
             try {
-                ParagonIE_Sodium_Compat::memzero($subkey);
-            } catch (SodiumException $ex) {
+                ParagonIE_Sodium_Compat::memzero( $subkey );
+            } catch ( SodiumException $ex ) {
                 $subkey = null;
             }
-            throw new SodiumException('Invalid MAC');
+            throw new SodiumException( 'Invalid MAC' );
         }
 
         /** @var string $m - Decrypted message */
         $m = ParagonIE_Sodium_Core32_Util::xorStrings(
-            ParagonIE_Sodium_Core32_Util::substr($block0, self::secretbox_xsalsa20poly1305_ZEROBYTES),
-            ParagonIE_Sodium_Core32_Util::substr($c, 0, self::secretbox_xsalsa20poly1305_ZEROBYTES)
+            ParagonIE_Sodium_Core32_Util::substr( $block0, self::secretbox_xsalsa20poly1305_ZEROBYTES ),
+            ParagonIE_Sodium_Core32_Util::substr( $c, 0, self::secretbox_xsalsa20poly1305_ZEROBYTES )
         );
-        if ($clen > self::secretbox_xsalsa20poly1305_ZEROBYTES) {
+        if ( $clen > self::secretbox_xsalsa20poly1305_ZEROBYTES ) {
             // We had more than 1 block, so let's continue to decrypt the rest.
             $m .= ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
                 ParagonIE_Sodium_Core32_Util::substr(
                     $c,
                     self::secretbox_xsalsa20poly1305_ZEROBYTES
                 ),
-                ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
+                ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 ),
                 1,
-                (string) $subkey
+                (string)$subkey
             );
         }
         return $m;
@@ -1089,25 +1089,25 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox_xchacha20poly1305($plaintext, $nonce, $key)
+    public static function secretbox_xchacha20poly1305( $plaintext, $nonce, $key )
     {
         /** @var string $subkey */
         $subkey = ParagonIE_Sodium_Core32_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 0, 16),
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 0, 16 ),
             $key
         );
-        $nonceLast = ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
+        $nonceLast = ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 );
 
         /** @var string $block0 */
-        $block0 = str_repeat("\x00", 32);
+        $block0 = str_repeat( "\x00", 32 );
 
         /** @var int $mlen - Length of the plaintext message */
-        $mlen = ParagonIE_Sodium_Core32_Util::strlen($plaintext);
+        $mlen = ParagonIE_Sodium_Core32_Util::strlen( $plaintext );
         $mlen0 = $mlen;
-        if ($mlen0 > 64 - self::secretbox_xchacha20poly1305_ZEROBYTES) {
+        if ( $mlen0 > 64 - self::secretbox_xchacha20poly1305_ZEROBYTES ) {
             $mlen0 = 64 - self::secretbox_xchacha20poly1305_ZEROBYTES;
         }
-        $block0 .= ParagonIE_Sodium_Core32_Util::substr($plaintext, 0, $mlen0);
+        $block0 .= ParagonIE_Sodium_Core32_Util::substr( $plaintext, 0, $mlen0 );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core32_ChaCha20::streamXorIc(
@@ -1121,7 +1121,7 @@ 
             $block0,
             self::secretbox_xchacha20poly1305_ZEROBYTES
         );
-        if ($mlen > $mlen0) {
+        if ( $mlen > $mlen0 ) {
             $c .= ParagonIE_Sodium_Core32_ChaCha20::streamXorIc(
                 ParagonIE_Sodium_Core32_Util::substr(
                     $plaintext,
@@ -1129,7 +1129,7 @@ 
                 ),
                 $nonceLast,
                 $subkey,
-                ParagonIE_Sodium_Core32_Util::store64_le(1)
+                ParagonIE_Sodium_Core32_Util::store64_le( 1 )
             );
         }
         $state = new ParagonIE_Sodium_Core32_Poly1305_State(
@@ -1140,18 +1140,18 @@ 
             )
         );
         try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-            ParagonIE_Sodium_Compat::memzero($subkey);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $block0 );
+            ParagonIE_Sodium_Compat::memzero( $subkey );
+        } catch ( SodiumException $ex ) {
             $block0 = null;
             $subkey = null;
         }
 
-        $state->update($c);
+        $state->update( $c );
 
         /** @var string $c - MAC || ciphertext */
         $c = $state->finish() . $c;
-        unset($state);
+        unset( $state );
 
         return $c;
     }
@@ -1168,7 +1168,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key)
+    public static function secretbox_xchacha20poly1305_open( $ciphertext, $nonce, $key )
     {
         /** @var string $mac */
         $mac = ParagonIE_Sodium_Core32_Util::substr(
@@ -1184,48 +1184,48 @@ 
         );
 
         /** @var int $clen */
-        $clen = ParagonIE_Sodium_Core32_Util::strlen($c);
+        $clen = ParagonIE_Sodium_Core32_Util::strlen( $c );
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core32_HChaCha20::hchacha20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core32_HChaCha20::hchacha20( $nonce, $key );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core32_ChaCha20::stream(
             64,
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
+            ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 ),
             $subkey
         );
         $verified = ParagonIE_Sodium_Core32_Poly1305::onetimeauth_verify(
             $mac,
             $c,
-            ParagonIE_Sodium_Core32_Util::substr($block0, 0, 32)
+            ParagonIE_Sodium_Core32_Util::substr( $block0, 0, 32 )
         );
 
-        if (!$verified) {
+        if ( ! $verified ) {
             try {
-                ParagonIE_Sodium_Compat::memzero($subkey);
-            } catch (SodiumException $ex) {
+                ParagonIE_Sodium_Compat::memzero( $subkey );
+            } catch ( SodiumException $ex ) {
                 $subkey = null;
             }
-            throw new SodiumException('Invalid MAC');
+            throw new SodiumException( 'Invalid MAC' );
         }
 
         /** @var string $m - Decrypted message */
         $m = ParagonIE_Sodium_Core32_Util::xorStrings(
-            ParagonIE_Sodium_Core32_Util::substr($block0, self::secretbox_xchacha20poly1305_ZEROBYTES),
-            ParagonIE_Sodium_Core32_Util::substr($c, 0, self::secretbox_xchacha20poly1305_ZEROBYTES)
+            ParagonIE_Sodium_Core32_Util::substr( $block0, self::secretbox_xchacha20poly1305_ZEROBYTES ),
+            ParagonIE_Sodium_Core32_Util::substr( $c, 0, self::secretbox_xchacha20poly1305_ZEROBYTES )
         );
 
-        if ($clen > self::secretbox_xchacha20poly1305_ZEROBYTES) {
+        if ( $clen > self::secretbox_xchacha20poly1305_ZEROBYTES ) {
             // We had more than 1 block, so let's continue to decrypt the rest.
             $m .= ParagonIE_Sodium_Core32_ChaCha20::streamXorIc(
                 ParagonIE_Sodium_Core32_Util::substr(
                     $c,
                     self::secretbox_xchacha20poly1305_ZEROBYTES
                 ),
-                ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
-                (string) $subkey,
-                ParagonIE_Sodium_Core32_Util::store64_le(1)
+                ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 ),
+                (string)$subkey,
+                ParagonIE_Sodium_Core32_Util::store64_le( 1 )
             );
         }
         return $m;
@@ -1237,16 +1237,16 @@ 
      * @throws Exception
      * @throws SodiumException
      */
-    public static function secretstream_xchacha20poly1305_init_push($key)
+    public static function secretstream_xchacha20poly1305_init_push( $key )
     {
         # randombytes_buf(out, crypto_secretstream_xchacha20poly1305_HEADERBYTES);
-        $out = random_bytes(24);
+        $out = random_bytes( 24 );
 
         # crypto_core_hchacha20(state->k, out, k, NULL);
-        $subkey = ParagonIE_Sodium_Core32_HChaCha20::hChaCha20($out, $key);
+        $subkey = ParagonIE_Sodium_Core32_HChaCha20::hChaCha20( $out, $key );
         $state = new ParagonIE_Sodium_Core32_SecretStream_State(
             $subkey,
-            ParagonIE_Sodium_Core32_Util::substr($out, 16, 8) . str_repeat("\0", 4)
+            ParagonIE_Sodium_Core32_Util::substr( $out, 16, 8 ) . str_repeat( "\0", 4 )
         );
 
         # _crypto_secretstream_xchacha20poly1305_counter_reset(state);
@@ -1267,16 +1267,16 @@ 
      * @return string Returns a state.
      * @throws Exception
      */
-    public static function secretstream_xchacha20poly1305_init_pull($key, $header)
+    public static function secretstream_xchacha20poly1305_init_pull( $key, $header )
     {
         # crypto_core_hchacha20(state->k, in, k, NULL);
         $subkey = ParagonIE_Sodium_Core32_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core32_Util::substr($header, 0, 16),
+            ParagonIE_Sodium_Core32_Util::substr( $header, 0, 16 ),
             $key
         );
         $state = new ParagonIE_Sodium_Core32_SecretStream_State(
             $subkey,
-            ParagonIE_Sodium_Core32_Util::substr($header, 16)
+            ParagonIE_Sodium_Core32_Util::substr( $header, 16 )
         );
         $state->counterReset();
         # memcpy(STATE_INONCE(state), in + crypto_core_hchacha20_INPUTBYTES,
@@ -1294,19 +1294,19 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
+    public static function secretstream_xchacha20poly1305_push( &$state, $msg, $aad = '', $tag = 0 )
     {
-        $st = ParagonIE_Sodium_Core32_SecretStream_State::fromString($state);
+        $st = ParagonIE_Sodium_Core32_SecretStream_State::fromString( $state );
         # crypto_onetimeauth_poly1305_state poly1305_state;
         # unsigned char                     block[64U];
         # unsigned char                     slen[8U];
         # unsigned char                    *c;
         # unsigned char                    *mac;
 
-        $msglen = ParagonIE_Sodium_Core32_Util::strlen($msg);
-        $aadlen = ParagonIE_Sodium_Core32_Util::strlen($aad);
+        $msglen = ParagonIE_Sodium_Core32_Util::strlen( $msg );
+        $aadlen = ParagonIE_Sodium_Core32_Util::strlen( $aad );
 
-        if ((($msglen + 63) >> 6) > 0xfffffffe) {
+        if ( ( ( $msglen + 63 ) >> 6 ) > 0xfffffffe ) {
             throw new SodiumException(
                 'message cannot be larger than SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX bytes'
             );
@@ -1323,62 +1323,62 @@ 
         # crypto_onetimeauth_poly1305_init(&poly1305_state, block);
         # sodium_memzero(block, sizeof block);
         $auth = new ParagonIE_Sodium_Core32_Poly1305_State(
-            ParagonIE_Sodium_Core32_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
+            ParagonIE_Sodium_Core32_ChaCha20::ietfStream( 32, $st->getCombinedNonce(), $st->getKey() )
         );
 
         # crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
-        $auth->update($aad);
+        $auth->update( $aad );
 
         # crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
         #     (0x10 - adlen) & 0xf);
-        $auth->update(str_repeat("\0", ((0x10 - $aadlen) & 0xf)));
+        $auth->update( str_repeat( "\0", ( ( 0x10 - $aadlen ) & 0xf ) ) );
 
         # memset(block, 0, sizeof block);
         # block[0] = tag;
         # crypto_stream_chacha20_ietf_xor_ic(block, block, sizeof block,
         #                                    state->nonce, 1U, state->k);
         $block = ParagonIE_Sodium_Core32_ChaCha20::ietfStreamXorIc(
-            ParagonIE_Sodium_Core32_Util::intToChr($tag) . str_repeat("\0", 63),
+            ParagonIE_Sodium_Core32_Util::intToChr( $tag ) . str_repeat( "\0", 63 ),
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core32_Util::store64_le(1)
+            ParagonIE_Sodium_Core32_Util::store64_le( 1 )
         );
 
         # crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
-        $auth->update($block);
+        $auth->update( $block );
 
         # out[0] = block[0];
-        $out = $block[0];
+        $out = $block[ 0 ];
         # c = out + (sizeof tag);
         # crypto_stream_chacha20_ietf_xor_ic(c, m, mlen, state->nonce, 2U, state->k);
         $cipher = ParagonIE_Sodium_Core32_ChaCha20::ietfStreamXorIc(
             $msg,
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core32_Util::store64_le(2)
+            ParagonIE_Sodium_Core32_Util::store64_le( 2 )
         );
 
         # crypto_onetimeauth_poly1305_update(&poly1305_state, c, mlen);
-        $auth->update($cipher);
+        $auth->update( $cipher );
 
         $out .= $cipher;
-        unset($cipher);
+        unset( $cipher );
 
         # crypto_onetimeauth_poly1305_update
         # (&poly1305_state, _pad0, (0x10 - (sizeof block) + mlen) & 0xf);
-        $auth->update(str_repeat("\0", ((0x10 - 64 + $msglen) & 0xf)));
+        $auth->update( str_repeat( "\0", ( ( 0x10 - 64 + $msglen ) & 0xf ) ) );
 
         # STORE64_LE(slen, (uint64_t) adlen);
-        $slen = ParagonIE_Sodium_Core32_Util::store64_le($aadlen);
+        $slen = ParagonIE_Sodium_Core32_Util::store64_le( $aadlen );
 
         # crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-        $auth->update($slen);
+        $auth->update( $slen );
 
         # STORE64_LE(slen, (sizeof block) + mlen);
-        $slen = ParagonIE_Sodium_Core32_Util::store64_le(64 + $msglen);
+        $slen = ParagonIE_Sodium_Core32_Util::store64_le( 64 + $msglen );
 
         # crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-        $auth->update($slen);
+        $auth->update( $slen );
 
         # mac = c + mlen;
         # crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
@@ -1386,12 +1386,12 @@ 
         $out .= $mac;
 
         # sodium_memzero(&poly1305_state, sizeof poly1305_state);
-        unset($auth);
+        unset( $auth );
 
 
         # XOR_BUF(STATE_INONCE(state), mac,
         #     crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-        $st->xorNonce($mac);
+        $st->xorNonce( $mac );
 
         # sodium_increment(STATE_COUNTER(state),
         #     crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
@@ -1400,15 +1400,15 @@ 
         $state = $st->toString();
 
         /** @var bool $rekey */
-        $rekey = ($tag & ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY) !== 0;
+        $rekey = ( $tag & ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY ) !== 0;
         # if ((tag & crypto_secretstream_xchacha20poly1305_TAG_REKEY) != 0 ||
         #     sodium_is_zero(STATE_COUNTER(state),
         #         crypto_secretstream_xchacha20poly1305_COUNTERBYTES)) {
         #     crypto_secretstream_xchacha20poly1305_rekey(state);
         # }
-        if ($rekey || $st->needsRekey()) {
+        if ( $rekey || $st->needsRekey() ) {
             // DO REKEY
-            self::secretstream_xchacha20poly1305_rekey($state);
+            self::secretstream_xchacha20poly1305_rekey( $state );
         }
         # if (outlen_p != NULL) {
         #     *outlen_p = crypto_secretstream_xchacha20poly1305_ABYTES + mlen;
@@ -1423,19 +1423,19 @@ 
      * @return bool|array{0: string, 1: int}
      * @throws SodiumException
      */
-    public static function secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
+    public static function secretstream_xchacha20poly1305_pull( &$state, $cipher, $aad = '' )
     {
-        $st = ParagonIE_Sodium_Core32_SecretStream_State::fromString($state);
+        $st = ParagonIE_Sodium_Core32_SecretStream_State::fromString( $state );
 
-        $cipherlen = ParagonIE_Sodium_Core32_Util::strlen($cipher);
+        $cipherlen = ParagonIE_Sodium_Core32_Util::strlen( $cipher );
         #     mlen = inlen - crypto_secretstream_xchacha20poly1305_ABYTES;
         $msglen = $cipherlen - ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES;
-        $aadlen = ParagonIE_Sodium_Core32_Util::strlen($aad);
+        $aadlen = ParagonIE_Sodium_Core32_Util::strlen( $aad );
 
         #     if (mlen > crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX) {
         #         sodium_misuse();
         #     }
-        if ((($msglen + 63) >> 6) > 0xfffffffe) {
+        if ( ( ( $msglen + 63 ) >> 6 ) > 0xfffffffe ) {
             throw new SodiumException(
                 'message cannot be larger than SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX bytes'
             );
@@ -1445,15 +1445,15 @@ 
         #     crypto_onetimeauth_poly1305_init(&poly1305_state, block);
         #     sodium_memzero(block, sizeof block);
         $auth = new ParagonIE_Sodium_Core32_Poly1305_State(
-            ParagonIE_Sodium_Core32_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
+            ParagonIE_Sodium_Core32_ChaCha20::ietfStream( 32, $st->getCombinedNonce(), $st->getKey() )
         );
 
         #     crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
-        $auth->update($aad);
+        $auth->update( $aad );
 
         #     crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
         #         (0x10 - adlen) & 0xf);
-        $auth->update(str_repeat("\0", ((0x10 - $aadlen) & 0xf)));
+        $auth->update( str_repeat( "\0", ( ( 0x10 - $aadlen ) & 0xf ) ) );
 
 
         #     memset(block, 0, sizeof block);
@@ -1461,36 +1461,36 @@ 
         #     crypto_stream_chacha20_ietf_xor_ic(block, block, sizeof block,
         #                                        state->nonce, 1U, state->k);
         $block = ParagonIE_Sodium_Core32_ChaCha20::ietfStreamXorIc(
-            $cipher[0] . str_repeat("\0", 63),
+            $cipher[ 0 ] . str_repeat( "\0", 63 ),
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core32_Util::store64_le(1)
+            ParagonIE_Sodium_Core32_Util::store64_le( 1 )
         );
         #     tag = block[0];
         #     block[0] = in[0];
         #     crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
-        $tag = ParagonIE_Sodium_Core32_Util::chrToInt($block[0]);
-        $block[0] = $cipher[0];
-        $auth->update($block);
+        $tag = ParagonIE_Sodium_Core32_Util::chrToInt( $block[ 0 ] );
+        $block[ 0 ] = $cipher[ 0 ];
+        $auth->update( $block );
 
 
         #     c = in + (sizeof tag);
         #     crypto_onetimeauth_poly1305_update(&poly1305_state, c, mlen);
-        $auth->update(ParagonIE_Sodium_Core32_Util::substr($cipher, 1, $msglen));
+        $auth->update( ParagonIE_Sodium_Core32_Util::substr( $cipher, 1, $msglen ) );
 
         #     crypto_onetimeauth_poly1305_update
         #     (&poly1305_state, _pad0, (0x10 - (sizeof block) + mlen) & 0xf);
-        $auth->update(str_repeat("\0", ((0x10 - 64 + $msglen) & 0xf)));
+        $auth->update( str_repeat( "\0", ( ( 0x10 - 64 + $msglen ) & 0xf ) ) );
 
         #     STORE64_LE(slen, (uint64_t) adlen);
         #     crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-        $slen = ParagonIE_Sodium_Core32_Util::store64_le($aadlen);
-        $auth->update($slen);
+        $slen = ParagonIE_Sodium_Core32_Util::store64_le( $aadlen );
+        $auth->update( $slen );
 
         #     STORE64_LE(slen, (sizeof block) + mlen);
         #     crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-        $slen = ParagonIE_Sodium_Core32_Util::store64_le(64 + $msglen);
-        $auth->update($slen);
+        $slen = ParagonIE_Sodium_Core32_Util::store64_le( 64 + $msglen );
+        $auth->update( $slen );
 
         #     crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
         #     sodium_memzero(&poly1305_state, sizeof poly1305_state);
@@ -1502,22 +1502,22 @@ 
         #         return -1;
         #     }
 
-        $stored = ParagonIE_Sodium_Core32_Util::substr($cipher, $msglen + 1, 16);
-        if (!ParagonIE_Sodium_Core32_Util::hashEquals($mac, $stored)) {
+        $stored = ParagonIE_Sodium_Core32_Util::substr( $cipher, $msglen + 1, 16 );
+        if ( ! ParagonIE_Sodium_Core32_Util::hashEquals( $mac, $stored ) ) {
             return false;
         }
 
         #     crypto_stream_chacha20_ietf_xor_ic(m, c, mlen, state->nonce, 2U, state->k);
         $out = ParagonIE_Sodium_Core32_ChaCha20::ietfStreamXorIc(
-            ParagonIE_Sodium_Core32_Util::substr($cipher, 1, $msglen),
+            ParagonIE_Sodium_Core32_Util::substr( $cipher, 1, $msglen ),
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core32_Util::store64_le(2)
+            ParagonIE_Sodium_Core32_Util::store64_le( 2 )
         );
 
         #     XOR_BUF(STATE_INONCE(state), mac,
         #         crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-        $st->xorNonce($mac);
+        $st->xorNonce( $mac );
 
         #     sodium_increment(STATE_COUNTER(state),
         #         crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
@@ -1533,12 +1533,12 @@ 
         $state = $st->toString();
 
         /** @var bool $rekey */
-        $rekey = ($tag & ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY) !== 0;
-        if ($rekey || $st->needsRekey()) {
+        $rekey = ( $tag & ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY ) !== 0;
+        if ( $rekey || $st->needsRekey() ) {
             // DO REKEY
-            self::secretstream_xchacha20poly1305_rekey($state);
+            self::secretstream_xchacha20poly1305_rekey( $state );
         }
-        return array($out, $tag);
+        return array( $out, $tag );
     }
 
     /**
@@ -1546,9 +1546,9 @@ 
      * @return void
      * @throws SodiumException
      */
-    public static function secretstream_xchacha20poly1305_rekey(&$state)
+    public static function secretstream_xchacha20poly1305_rekey( &$state )
     {
-        $st = ParagonIE_Sodium_Core32_SecretStream_State::fromString($state);
+        $st = ParagonIE_Sodium_Core32_SecretStream_State::fromString( $state );
         # unsigned char new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES +
         # crypto_secretstream_xchacha20poly1305_INONCEBYTES];
         # size_t        i;
@@ -1561,18 +1561,18 @@ 
         #     new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i] =
         #         STATE_INONCE(state)[i];
         # }
-        $new_key_and_inonce .= ParagonIE_Sodium_Core32_Util::substR($st->getNonce(), 0, 8);
+        $new_key_and_inonce .= ParagonIE_Sodium_Core32_Util::substR( $st->getNonce(), 0, 8 );
 
         # crypto_stream_chacha20_ietf_xor(new_key_and_inonce, new_key_and_inonce,
         #                                 sizeof new_key_and_inonce,
         #                                 state->nonce, state->k);
 
-        $st->rekey(ParagonIE_Sodium_Core32_ChaCha20::ietfStreamXorIc(
+        $st->rekey( ParagonIE_Sodium_Core32_ChaCha20::ietfStreamXorIc(
             $new_key_and_inonce,
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core32_Util::store64_le(0)
-        ));
+            ParagonIE_Sodium_Core32_Util::store64_le( 0 )
+        ) );
 
         # for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
         #     state->k[i] = new_key_and_inonce[i];
@@ -1598,9 +1598,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_detached($message, $sk)
+    public static function sign_detached( $message, $sk )
     {
-        return ParagonIE_Sodium_Core32_Ed25519::sign_detached($message, $sk);
+        return ParagonIE_Sodium_Core32_Ed25519::sign_detached( $message, $sk );
     }
 
     /**
@@ -1614,9 +1614,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($message, $sk)
+    public static function sign( $message, $sk )
     {
-        return ParagonIE_Sodium_Core32_Ed25519::sign($message, $sk);
+        return ParagonIE_Sodium_Core32_Ed25519::sign( $message, $sk );
     }
 
     /**
@@ -1630,9 +1630,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_open($signedMessage, $pk)
+    public static function sign_open( $signedMessage, $pk )
     {
-        return ParagonIE_Sodium_Core32_Ed25519::sign_open($signedMessage, $pk);
+        return ParagonIE_Sodium_Core32_Ed25519::sign_open( $signedMessage, $pk );
     }
 
     /**
@@ -1647,8 +1647,8 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_verify_detached($signature, $message, $pk)
+    public static function sign_verify_detached( $signature, $message, $pk )
     {
-        return ParagonIE_Sodium_Core32_Ed25519::verify_detached($signature, $message, $pk);
+        return ParagonIE_Sodium_Core32_Ed25519::verify_detached( $signature, $message, $pk );
     }
 }

vendor/paragonie/sodium_compat/src/Core/BLAKE2b.php

Spacing +257 added lines, -257 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_BLAKE2b', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_BLAKE2b', false ) ) {
     return;
 }
 
@@ -20,18 +20,18 @@ 
      * @var array<int, array<int, int>>
      */
     protected static $sigma = array(
-        array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
-        array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3),
-        array( 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4),
-        array(  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8),
-        array(  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13),
-        array(  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9),
-        array( 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11),
-        array( 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10),
-        array(  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5),
-        array( 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0),
-        array(  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15),
-        array( 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3)
+        array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ),
+        array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 ),
+        array( 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 ),
+        array( 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 ),
+        array( 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 ),
+        array( 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 ),
+        array( 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 ),
+        array( 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 ),
+        array( 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 ),
+        array( 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 ),
+        array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 ),
+        array( 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 )
     );
 
     const BLOCKBYTES = 128;
@@ -48,11 +48,11 @@ 
      * @return SplFixedArray
      * @psalm-suppress MixedAssignment
      */
-    public static function new64($high, $low)
+    public static function new64( $high, $low )
     {
-        $i64 = new SplFixedArray(2);
-        $i64[0] = $high & 0xffffffff;
-        $i64[1] = $low & 0xffffffff;
+        $i64 = new SplFixedArray( 2 );
+        $i64[ 0 ] = $high & 0xffffffff;
+        $i64[ 1 ] = $low & 0xffffffff;
         return $i64;
     }
 
@@ -65,10 +65,10 @@ 
      * @param int $num
      * @return SplFixedArray
      */
-    protected static function to64($num)
+    protected static function to64( $num )
     {
-        list($hi, $lo) = self::numericTo64BitInteger($num);
-        return self::new64($hi, $lo);
+        list( $hi, $lo ) = self::numericTo64BitInteger( $num );
+        return self::new64( $hi, $lo );
     }
 
     /**
@@ -84,14 +84,14 @@ 
      * @psalm-suppress MixedAssignment
      * @psalm-suppress MixedOperand
      */
-    protected static function add64($x, $y)
+    protected static function add64( $x, $y )
     {
-        $l = ($x[1] + $y[1]) & 0xffffffff;
+        $l = ( $x[ 1 ] + $y[ 1 ] ) & 0xffffffff;
         return self::new64(
-            (int) ($x[0] + $y[0] + (
-                ($l < $x[1]) ? 1 : 0
-            )),
-            (int) $l
+            (int)( $x[ 0 ] + $y[ 0 ] + (
+                ( $l < $x[ 1 ] ) ? 1 : 0
+            ) ),
+            (int)$l
         );
     }
 
@@ -103,9 +103,9 @@ 
      * @param SplFixedArray $z
      * @return SplFixedArray
      */
-    protected static function add364($x, $y, $z)
+    protected static function add364( $x, $y, $z )
     {
-        return self::add64($x, self::add64($y, $z));
+        return self::add64( $x, self::add64( $y, $z ) );
     }
 
     /**
@@ -117,23 +117,23 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function xor64(SplFixedArray $x, SplFixedArray $y)
+    protected static function xor64( SplFixedArray $x, SplFixedArray $y )
     {
-        if (!is_numeric($x[0])) {
-            throw new SodiumException('x[0] is not an integer');
+        if ( ! is_numeric( $x[ 0 ] ) ) {
+            throw new SodiumException( 'x[0] is not an integer' );
         }
-        if (!is_numeric($x[1])) {
-            throw new SodiumException('x[1] is not an integer');
+        if ( ! is_numeric( $x[ 1 ] ) ) {
+            throw new SodiumException( 'x[1] is not an integer' );
         }
-        if (!is_numeric($y[0])) {
-            throw new SodiumException('y[0] is not an integer');
+        if ( ! is_numeric( $y[ 0 ] ) ) {
+            throw new SodiumException( 'y[0] is not an integer' );
         }
-        if (!is_numeric($y[1])) {
-            throw new SodiumException('y[1] is not an integer');
+        if ( ! is_numeric( $y[ 1 ] ) ) {
+            throw new SodiumException( 'y[1] is not an integer' );
         }
         return self::new64(
-            (int) (($x[0] ^ $y[0]) & 0xffffffff),
-            (int) (($x[1] ^ $y[1]) & 0xffffffff)
+            (int)( ( $x[ 0 ] ^ $y[ 0 ] ) & 0xffffffff ),
+            (int)( ( $x[ 1 ] ^ $y[ 1 ] ) & 0xffffffff )
         );
     }
 
@@ -145,55 +145,55 @@ 
      * @return SplFixedArray
      * @psalm-suppress MixedAssignment
      */
-    public static function rotr64($x, $c)
+    public static function rotr64( $x, $c )
     {
-        if ($c >= 64) {
+        if ( $c >= 64 ) {
             $c %= 64;
         }
-        if ($c >= 32) {
+        if ( $c >= 32 ) {
             /** @var int $tmp */
-            $tmp = $x[0];
-            $x[0] = $x[1];
-            $x[1] = $tmp;
+            $tmp = $x[ 0 ];
+            $x[ 0 ] = $x[ 1 ];
+            $x[ 1 ] = $tmp;
             $c -= 32;
         }
-        if ($c === 0) {
+        if ( $c === 0 ) {
             return $x;
         }
 
         $l0 = 0;
         $c = 64 - $c;
 
-        if ($c < 32) {
+        if ( $c < 32 ) {
             /** @var int $h0 */
-            $h0 = ((int) ($x[0]) << $c) | (
+            $h0 = ( (int)( $x[ 0 ] ) << $c ) | (
                 (
-                    (int) ($x[1]) & ((1 << $c) - 1)
+                    (int)( $x[ 1 ] ) & ( ( 1 << $c ) - 1 )
                         <<
-                    (32 - $c)
-                ) >> (32 - $c)
+                    ( 32 - $c )
+                ) >> ( 32 - $c )
             );
             /** @var int $l0 */
-            $l0 = (int) ($x[1]) << $c;
+            $l0 = (int)( $x[ 1 ] ) << $c;
         } else {
             /** @var int $h0 */
-            $h0 = (int) ($x[1]) << ($c - 32);
+            $h0 = (int)( $x[ 1 ] ) << ( $c - 32 );
         }
 
         $h1 = 0;
         $c1 = 64 - $c;
 
-        if ($c1 < 32) {
+        if ( $c1 < 32 ) {
             /** @var int $h1 */
-            $h1 = (int) ($x[0]) >> $c1;
+            $h1 = (int)( $x[ 0 ] ) >> $c1;
             /** @var int $l1 */
-            $l1 = ((int) ($x[1]) >> $c1) | ((int) ($x[0]) & ((1 << $c1) - 1)) << (32 - $c1);
+            $l1 = ( (int)( $x[ 1 ] ) >> $c1 ) | ( (int)( $x[ 0 ] ) & ( ( 1 << $c1 ) - 1 ) ) << ( 32 - $c1 );
         } else {
             /** @var int $l1 */
-            $l1 = (int) ($x[0]) >> ($c1 - 32);
+            $l1 = (int)( $x[ 0 ] ) >> ( $c1 - 32 );
         }
 
-        return self::new64($h0 | $h1, $l0 | $l1);
+        return self::new64( $h0 | $h1, $l0 | $l1 );
     }
 
     /**
@@ -203,9 +203,9 @@ 
      * @return int
      * @psalm-suppress MixedOperand
      */
-    protected static function flatten64($x)
+    protected static function flatten64( $x )
     {
-        return (int) ($x[0] * 4294967296 + $x[1]);
+        return (int)( $x[ 0 ] * 4294967296 + $x[ 1 ] );
     }
 
     /**
@@ -217,19 +217,19 @@ 
      * @psalm-suppress MixedArgument
      * @psalm-suppress MixedArrayOffset
      */
-    protected static function load64(SplFixedArray $x, $i)
+    protected static function load64( SplFixedArray $x, $i )
     {
         /** @var int $l */
-        $l = (int) ($x[$i])
-             | ((int) ($x[$i+1]) << 8)
-             | ((int) ($x[$i+2]) << 16)
-             | ((int) ($x[$i+3]) << 24);
+        $l = (int)( $x[ $i ] )
+             | ( (int)( $x[ $i + 1 ] ) << 8 )
+             | ( (int)( $x[ $i + 2 ] ) << 16 )
+             | ( (int)( $x[ $i + 3 ] ) << 24 );
         /** @var int $h */
-        $h = (int) ($x[$i+4])
-             | ((int) ($x[$i+5]) << 8)
-             | ((int) ($x[$i+6]) << 16)
-             | ((int) ($x[$i+7]) << 24);
-        return self::new64($h, $l);
+        $h = (int)( $x[ $i + 4 ] )
+             | ( (int)( $x[ $i + 5 ] ) << 8 )
+             | ( (int)( $x[ $i + 6 ] ) << 16 )
+             | ( (int)( $x[ $i + 7 ] ) << 24 );
+        return self::new64( $h, $l );
     }
 
     /**
@@ -241,23 +241,23 @@ 
      * @return void
      * @psalm-suppress MixedAssignment
      */
-    protected static function store64(SplFixedArray $x, $i, SplFixedArray $u)
+    protected static function store64( SplFixedArray $x, $i, SplFixedArray $u )
     {
         $maxLength = $x->getSize() - 1;
-        for ($j = 0; $j < 8; ++$j) {
+        for ( $j = 0; $j < 8; ++$j ) {
             /*
                [0, 1, 2, 3, 4, 5, 6, 7]
                     ... becomes ...
                [0, 0, 0, 0, 1, 1, 1, 1]
             */
             /** @var int $uIdx */
-            $uIdx = ((7 - $j) & 4) >> 2;
-            $x[$i]   = ((int) ($u[$uIdx]) & 0xff);
+            $uIdx = ( ( 7 - $j ) & 4 ) >> 2;
+            $x[ $i ] = ( (int)( $u[ $uIdx ] ) & 0xff );
             if (++$i > $maxLength) {
                 return;
             }
             /** @psalm-suppress MixedOperand */
-            $u[$uIdx] >>= 8;
+            $u[ $uIdx ] >>= 8;
         }
     }
 
@@ -271,18 +271,18 @@ 
     public static function pseudoConstructor()
     {
         static $called = false;
-        if ($called) {
+        if ( $called ) {
             return;
         }
-        self::$iv = new SplFixedArray(8);
-        self::$iv[0] = self::new64(0x6a09e667, 0xf3bcc908);
-        self::$iv[1] = self::new64(0xbb67ae85, 0x84caa73b);
-        self::$iv[2] = self::new64(0x3c6ef372, 0xfe94f82b);
-        self::$iv[3] = self::new64(0xa54ff53a, 0x5f1d36f1);
-        self::$iv[4] = self::new64(0x510e527f, 0xade682d1);
-        self::$iv[5] = self::new64(0x9b05688c, 0x2b3e6c1f);
-        self::$iv[6] = self::new64(0x1f83d9ab, 0xfb41bd6b);
-        self::$iv[7] = self::new64(0x5be0cd19, 0x137e2179);
+        self::$iv = new SplFixedArray( 8 );
+        self::$iv[ 0 ] = self::new64( 0x6a09e667, 0xf3bcc908 );
+        self::$iv[ 1 ] = self::new64( 0xbb67ae85, 0x84caa73b );
+        self::$iv[ 2 ] = self::new64( 0x3c6ef372, 0xfe94f82b );
+        self::$iv[ 3 ] = self::new64( 0xa54ff53a, 0x5f1d36f1 );
+        self::$iv[ 4 ] = self::new64( 0x510e527f, 0xade682d1 );
+        self::$iv[ 5 ] = self::new64( 0x9b05688c, 0x2b3e6c1f );
+        self::$iv[ 6 ] = self::new64( 0x1f83d9ab, 0xfb41bd6b );
+        self::$iv[ 7 ] = self::new64( 0x5be0cd19, 0x137e2179 );
 
         $called = true;
     }
@@ -299,26 +299,26 @@ 
      */
     protected static function context()
     {
-        $ctx    = new SplFixedArray(6);
-        $ctx[0] = new SplFixedArray(8);   // h
-        $ctx[1] = new SplFixedArray(2);   // t
-        $ctx[2] = new SplFixedArray(2);   // f
-        $ctx[3] = new SplFixedArray(256); // buf
-        $ctx[4] = 0;                      // buflen
-        $ctx[5] = 0;                      // last_node (uint8_t)
+        $ctx    = new SplFixedArray( 6 );
+        $ctx[ 0 ] = new SplFixedArray( 8 ); // h
+        $ctx[ 1 ] = new SplFixedArray( 2 ); // t
+        $ctx[ 2 ] = new SplFixedArray( 2 ); // f
+        $ctx[ 3 ] = new SplFixedArray( 256 ); // buf
+        $ctx[ 4 ] = 0; // buflen
+        $ctx[ 5 ] = 0; // last_node (uint8_t)
 
-        for ($i = 8; $i--;) {
-            $ctx[0][$i] = self::$iv[$i];
+        for ( $i = 8; $i--; ) {
+            $ctx[ 0 ][ $i ] = self::$iv[ $i ];
         }
-        for ($i = 256; $i--;) {
-            $ctx[3][$i] = 0;
+        for ( $i = 256; $i--; ) {
+            $ctx[ 3 ][ $i ] = 0;
         }
 
-        $zero = self::new64(0, 0);
-        $ctx[1][0] = $zero;
-        $ctx[1][1] = $zero;
-        $ctx[2][0] = $zero;
-        $ctx[2][1] = $zero;
+        $zero = self::new64( 0, 0 );
+        $ctx[ 1 ][ 0 ] = $zero;
+        $ctx[ 1 ][ 1 ] = $zero;
+        $ctx[ 2 ][ 0 ] = $zero;
+        $ctx[ 2 ][ 1 ] = $zero;
 
         return $ctx;
     }
@@ -337,43 +337,43 @@ 
      * @psalm-suppress MixedArrayAssignment
      * @psalm-suppress MixedArrayOffset
      */
-    protected static function compress(SplFixedArray $ctx, SplFixedArray $buf)
+    protected static function compress( SplFixedArray $ctx, SplFixedArray $buf )
     {
-        $m = new SplFixedArray(16);
-        $v = new SplFixedArray(16);
+        $m = new SplFixedArray( 16 );
+        $v = new SplFixedArray( 16 );
 
-        for ($i = 16; $i--;) {
-            $m[$i] = self::load64($buf, $i << 3);
+        for ( $i = 16; $i--; ) {
+            $m[ $i ] = self::load64( $buf, $i << 3 );
         }
 
-        for ($i = 8; $i--;) {
-            $v[$i] = $ctx[0][$i];
+        for ( $i = 8; $i--; ) {
+            $v[ $i ] = $ctx[ 0 ][ $i ];
         }
 
-        $v[ 8] = self::$iv[0];
-        $v[ 9] = self::$iv[1];
-        $v[10] = self::$iv[2];
-        $v[11] = self::$iv[3];
+        $v[ 8 ] = self::$iv[ 0 ];
+        $v[ 9 ] = self::$iv[ 1 ];
+        $v[ 10 ] = self::$iv[ 2 ];
+        $v[ 11 ] = self::$iv[ 3 ];
 
-        $v[12] = self::xor64($ctx[1][0], self::$iv[4]);
-        $v[13] = self::xor64($ctx[1][1], self::$iv[5]);
-        $v[14] = self::xor64($ctx[2][0], self::$iv[6]);
-        $v[15] = self::xor64($ctx[2][1], self::$iv[7]);
+        $v[ 12 ] = self::xor64( $ctx[ 1 ][ 0 ], self::$iv[ 4 ] );
+        $v[ 13 ] = self::xor64( $ctx[ 1 ][ 1 ], self::$iv[ 5 ] );
+        $v[ 14 ] = self::xor64( $ctx[ 2 ][ 0 ], self::$iv[ 6 ] );
+        $v[ 15 ] = self::xor64( $ctx[ 2 ][ 1 ], self::$iv[ 7 ] );
 
-        for ($r = 0; $r < 12; ++$r) {
-            $v = self::G($r, 0, 0, 4, 8, 12, $v, $m);
-            $v = self::G($r, 1, 1, 5, 9, 13, $v, $m);
-            $v = self::G($r, 2, 2, 6, 10, 14, $v, $m);
-            $v = self::G($r, 3, 3, 7, 11, 15, $v, $m);
-            $v = self::G($r, 4, 0, 5, 10, 15, $v, $m);
-            $v = self::G($r, 5, 1, 6, 11, 12, $v, $m);
-            $v = self::G($r, 6, 2, 7, 8, 13, $v, $m);
-            $v = self::G($r, 7, 3, 4, 9, 14, $v, $m);
+        for ( $r = 0; $r < 12; ++$r ) {
+            $v = self::G( $r, 0, 0, 4, 8, 12, $v, $m );
+            $v = self::G( $r, 1, 1, 5, 9, 13, $v, $m );
+            $v = self::G( $r, 2, 2, 6, 10, 14, $v, $m );
+            $v = self::G( $r, 3, 3, 7, 11, 15, $v, $m );
+            $v = self::G( $r, 4, 0, 5, 10, 15, $v, $m );
+            $v = self::G( $r, 5, 1, 6, 11, 12, $v, $m );
+            $v = self::G( $r, 6, 2, 7, 8, 13, $v, $m );
+            $v = self::G( $r, 7, 3, 4, 9, 14, $v, $m );
         }
 
-        for ($i = 8; $i--;) {
-            $ctx[0][$i] = self::xor64(
-                $ctx[0][$i], self::xor64($v[$i], $v[$i+8])
+        for ( $i = 8; $i--; ) {
+            $ctx[ 0 ][ $i ] = self::xor64(
+                $ctx[ 0 ][ $i ], self::xor64( $v[ $i ], $v[ $i + 8 ] )
             );
         }
     }
@@ -395,16 +395,16 @@ 
      * @psalm-suppress MixedArgument
      * @psalm-suppress MixedArrayOffset
      */
-    public static function G($r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m)
+    public static function G( $r, $i, $a, $b, $c, $d, SplFixedArray $v, SplFixedArray $m )
     {
-        $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][$i << 1]]);
-        $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 32);
-        $v[$c] = self::add64($v[$c], $v[$d]);
-        $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 24);
-        $v[$a] = self::add364($v[$a], $v[$b], $m[self::$sigma[$r][($i << 1) + 1]]);
-        $v[$d] = self::rotr64(self::xor64($v[$d], $v[$a]), 16);
-        $v[$c] = self::add64($v[$c], $v[$d]);
-        $v[$b] = self::rotr64(self::xor64($v[$b], $v[$c]), 63);
+        $v[ $a ] = self::add364( $v[ $a ], $v[ $b ], $m[ self::$sigma[ $r ][ $i << 1 ] ] );
+        $v[ $d ] = self::rotr64( self::xor64( $v[ $d ], $v[ $a ] ), 32 );
+        $v[ $c ] = self::add64( $v[ $c ], $v[ $d ] );
+        $v[ $b ] = self::rotr64( self::xor64( $v[ $b ], $v[ $c ] ), 24 );
+        $v[ $a ] = self::add364( $v[ $a ], $v[ $b ], $m[ self::$sigma[ $r ][ ( $i << 1 ) + 1 ] ] );
+        $v[ $d ] = self::rotr64( self::xor64( $v[ $d ], $v[ $a ] ), 16 );
+        $v[ $c ] = self::add64( $v[ $c ], $v[ $d ] );
+        $v[ $b ] = self::rotr64( self::xor64( $v[ $b ], $v[ $c ] ), 63 );
         return $v;
     }
 
@@ -419,20 +419,20 @@ 
      * @psalm-suppress MixedArrayAccess
      * @psalm-suppress MixedArrayAssignment
      */
-    public static function increment_counter($ctx, $inc)
+    public static function increment_counter( $ctx, $inc )
     {
-        if ($inc < 0) {
-            throw new SodiumException('Increasing by a negative number makes no sense.');
+        if ( $inc < 0 ) {
+            throw new SodiumException( 'Increasing by a negative number makes no sense.' );
         }
-        $t = self::to64($inc);
+        $t = self::to64( $inc );
         # S->t is $ctx[1] in our implementation
 
         # S->t[0] = ( uint64_t )( t >> 0 );
-        $ctx[1][0] = self::add64($ctx[1][0], $t);
+        $ctx[ 1 ][ 0 ] = self::add64( $ctx[ 1 ][ 0 ], $t );
 
         # S->t[1] += ( S->t[0] < inc );
-        if (self::flatten64($ctx[1][0]) < $inc) {
-            $ctx[1][1] = self::add64($ctx[1][1], self::to64(1));
+        if ( self::flatten64( $ctx[ 1 ][ 0 ] ) < $inc ) {
+            $ctx[ 1 ][ 1 ] = self::add64( $ctx[ 1 ][ 1 ], self::to64( 1 ) );
         }
     }
 
@@ -452,37 +452,37 @@ 
      * @psalm-suppress MixedArrayOffset
      * @psalm-suppress MixedOperand
      */
-    public static function update(SplFixedArray $ctx, SplFixedArray $p, $plen)
+    public static function update( SplFixedArray $ctx, SplFixedArray $p, $plen )
     {
         self::pseudoConstructor();
 
         $offset = 0;
-        while ($plen > 0) {
-            $left = $ctx[4];
+        while ( $plen > 0 ) {
+            $left = $ctx[ 4 ];
             $fill = 256 - $left;
 
-            if ($plen > $fill) {
+            if ( $plen > $fill ) {
                 # memcpy( S->buf + left, in, fill ); /* Fill buffer */
-                for ($i = $fill; $i--;) {
-                    $ctx[3][$i + $left] = $p[$i + $offset];
+                for ( $i = $fill; $i--; ) {
+                    $ctx[ 3 ][ $i + $left ] = $p[ $i + $offset ];
                 }
 
                 # S->buflen += fill;
-                $ctx[4] += $fill;
+                $ctx[ 4 ] += $fill;
 
                 # blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
-                self::increment_counter($ctx, 128);
+                self::increment_counter( $ctx, 128 );
 
                 # blake2b_compress( S, S->buf ); /* Compress */
-                self::compress($ctx, $ctx[3]);
+                self::compress( $ctx, $ctx[ 3 ] );
 
                 # memcpy( S->buf, S->buf + BLAKE2B_BLOCKBYTES, BLAKE2B_BLOCKBYTES ); /* Shift buffer left */
-                for ($i = 128; $i--;) {
-                    $ctx[3][$i] = $ctx[3][$i + 128];
+                for ( $i = 128; $i--; ) {
+                    $ctx[ 3 ][ $i ] = $ctx[ 3 ][ $i + 128 ];
                 }
 
                 # S->buflen -= BLAKE2B_BLOCKBYTES;
-                $ctx[4] -= 128;
+                $ctx[ 4 ] -= 128;
 
                 # in += fill;
                 $offset += $fill;
@@ -490,10 +490,10 @@ 
                 # inlen -= fill;
                 $plen -= $fill;
             } else {
-                for ($i = $plen; $i--;) {
-                    $ctx[3][$i + $left] = $p[$i + $offset];
+                for ( $i = $plen; $i--; ) {
+                    $ctx[ 3 ][ $i + $left ] = $p[ $i + $offset ];
                 }
-                $ctx[4] += $plen;
+                $ctx[ 4 ] += $plen;
                 $offset += $plen;
                 $plen -= $plen;
             }
@@ -515,33 +515,33 @@ 
      * @psalm-suppress MixedArrayOffset
      * @psalm-suppress MixedOperand
      */
-    public static function finish(SplFixedArray $ctx, SplFixedArray $out)
+    public static function finish( SplFixedArray $ctx, SplFixedArray $out )
     {
         self::pseudoConstructor();
-        if ($ctx[4] > 128) {
-            self::increment_counter($ctx, 128);
-            self::compress($ctx, $ctx[3]);
-            $ctx[4] -= 128;
-            if ($ctx[4] > 128) {
-                throw new SodiumException('Failed to assert that buflen <= 128 bytes');
+        if ( $ctx[ 4 ] > 128 ) {
+            self::increment_counter( $ctx, 128 );
+            self::compress( $ctx, $ctx[ 3 ] );
+            $ctx[ 4 ] -= 128;
+            if ( $ctx[ 4 ] > 128 ) {
+                throw new SodiumException( 'Failed to assert that buflen <= 128 bytes' );
             }
-            for ($i = $ctx[4]; $i--;) {
-                $ctx[3][$i] = $ctx[3][$i + 128];
+            for ( $i = $ctx[ 4 ]; $i--; ) {
+                $ctx[ 3 ][ $i ] = $ctx[ 3 ][ $i + 128 ];
             }
         }
 
-        self::increment_counter($ctx, $ctx[4]);
-        $ctx[2][0] = self::new64(0xffffffff, 0xffffffff);
+        self::increment_counter( $ctx, $ctx[ 4 ] );
+        $ctx[ 2 ][ 0 ] = self::new64( 0xffffffff, 0xffffffff );
 
-        for ($i = 256 - $ctx[4]; $i--;) {
-            $ctx[3][$i+$ctx[4]] = 0;
+        for ( $i = 256 - $ctx[ 4 ]; $i--; ) {
+            $ctx[ 3 ][ $i + $ctx[ 4 ] ] = 0;
         }
 
-        self::compress($ctx, $ctx[3]);
+        self::compress( $ctx, $ctx[ 3 ] );
 
-        $i = (int) (($out->getSize() - 1) / 8);
-        for (; $i >= 0; --$i) {
-            self::store64($out, $i << 3, $ctx[0][$i]);
+        $i = (int)( ( $out->getSize() - 1 ) / 8 );
+        for ( ; $i >= 0; --$i ) {
+            self::store64( $out, $i << 3, $ctx[ 0 ][ $i ] );
         }
         return $out;
     }
@@ -571,67 +571,67 @@ 
         self::pseudoConstructor();
         $klen = 0;
 
-        if ($key !== null) {
-            if (count($key) > 64) {
-                throw new SodiumException('Invalid key size');
+        if ( $key !== null ) {
+            if ( count( $key ) > 64 ) {
+                throw new SodiumException( 'Invalid key size' );
             }
-            $klen = count($key);
+            $klen = count( $key );
         }
 
-        if ($outlen > 64) {
-            throw new SodiumException('Invalid output size');
+        if ( $outlen > 64 ) {
+            throw new SodiumException( 'Invalid output size' );
         }
 
         $ctx = self::context();
 
-        $p = new SplFixedArray(64);
+        $p = new SplFixedArray( 64 );
         // Zero our param buffer...
-        for ($i = 64; --$i;) {
-            $p[$i] = 0;
+        for ( $i = 64; --$i; ) {
+            $p[ $i ] = 0;
         }
 
-        $p[0] = $outlen; // digest_length
-        $p[1] = $klen;   // key_length
-        $p[2] = 1;       // fanout
-        $p[3] = 1;       // depth
+        $p[ 0 ] = $outlen; // digest_length
+        $p[ 1 ] = $klen; // key_length
+        $p[ 2 ] = 1; // fanout
+        $p[ 3 ] = 1; // depth
 
-        if ($salt instanceof SplFixedArray) {
+        if ( $salt instanceof SplFixedArray ) {
             // salt: [32] through [47]
-            for ($i = 0; $i < 16; ++$i) {
-                $p[32 + $i] = (int) $salt[$i];
+            for ( $i = 0; $i < 16; ++$i ) {
+                $p[ 32 + $i ] = (int)$salt[ $i ];
             }
         }
-        if ($personal instanceof SplFixedArray) {
+        if ( $personal instanceof SplFixedArray ) {
             // personal: [48] through [63]
-            for ($i = 0; $i < 16; ++$i) {
-                $p[48 + $i] = (int) $personal[$i];
+            for ( $i = 0; $i < 16; ++$i ) {
+                $p[ 48 + $i ] = (int)$personal[ $i ];
             }
         }
 
-        $ctx[0][0] = self::xor64(
-            $ctx[0][0],
-            self::load64($p, 0)
+        $ctx[ 0 ][ 0 ] = self::xor64(
+            $ctx[ 0 ][ 0 ],
+            self::load64( $p, 0 )
         );
-        if ($salt instanceof SplFixedArray || $personal instanceof SplFixedArray) {
+        if ( $salt instanceof SplFixedArray || $personal instanceof SplFixedArray ) {
             // We need to do what blake2b_init_param() does:
-            for ($i = 1; $i < 8; ++$i) {
-                $ctx[0][$i] = self::xor64(
-                    $ctx[0][$i],
-                    self::load64($p, $i << 3)
+            for ( $i = 1; $i < 8; ++$i ) {
+                $ctx[ 0 ][ $i ] = self::xor64(
+                    $ctx[ 0 ][ $i ],
+                    self::load64( $p, $i << 3 )
                 );
             }
         }
 
-        if ($klen > 0 && $key instanceof SplFixedArray) {
-            $block = new SplFixedArray(128);
-            for ($i = 128; $i--;) {
-                $block[$i] = 0;
+        if ( $klen > 0 && $key instanceof SplFixedArray ) {
+            $block = new SplFixedArray( 128 );
+            for ( $i = 128; $i--; ) {
+                $block[ $i ] = 0;
             }
-            for ($i = $klen; $i--;) {
-                $block[$i] = $key[$i];
+            for ( $i = $klen; $i--; ) {
+                $block[ $i ] = $key[ $i ];
             }
-            self::update($ctx, $block, 128);
-            $ctx[4] = 128;
+            self::update( $ctx, $block, 128 );
+            $ctx[ 4 ] = 128;
         }
 
         return $ctx;
@@ -646,10 +646,10 @@ 
      * @return SplFixedArray
      * @psalm-suppress MixedArgumentTypeCoercion
      */
-    public static function stringToSplFixedArray($str = '')
+    public static function stringToSplFixedArray( $str = '' )
     {
-        $values = unpack('C*', $str);
-        return SplFixedArray::fromArray(array_values($values));
+        $values = unpack( 'C*', $str );
+        return SplFixedArray::fromArray( array_values( $values ) );
     }
 
     /**
@@ -661,15 +661,15 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function SplFixedArrayToString(SplFixedArray $a)
+    public static function SplFixedArrayToString( SplFixedArray $a )
     {
         /**
          * @var array<int, int|string> $arr
          */
         $arr = $a->toArray();
         $c = $a->count();
-        array_unshift($arr, str_repeat('C', $c));
-        return (string) (call_user_func_array('pack', $arr));
+        array_unshift( $arr, str_repeat( 'C', $c ) );
+        return (string)( call_user_func_array( 'pack', $arr ) );
     }
 
     /**
@@ -685,47 +685,47 @@ 
      * @psalm-suppress MixedArrayOffset
      * @psalm-suppress MixedMethodCall
      */
-    public static function contextToString(SplFixedArray $ctx)
+    public static function contextToString( SplFixedArray $ctx )
     {
         $str = '';
         /** @var array<int, array<int, int>> $ctxA */
-        $ctxA = $ctx[0]->toArray();
+        $ctxA = $ctx[ 0 ]->toArray();
 
         # uint64_t h[8];
-        for ($i = 0; $i < 8; ++$i) {
-            $str .= self::store32_le($ctxA[$i][1]);
-            $str .= self::store32_le($ctxA[$i][0]);
+        for ( $i = 0; $i < 8; ++$i ) {
+            $str .= self::store32_le( $ctxA[ $i ][ 1 ] );
+            $str .= self::store32_le( $ctxA[ $i ][ 0 ] );
         }
 
         # uint64_t t[2];
         # uint64_t f[2];
-        for ($i = 1; $i < 3; ++$i) {
-            $ctxA = $ctx[$i]->toArray();
-            $str .= self::store32_le($ctxA[0][1]);
-            $str .= self::store32_le($ctxA[0][0]);
-            $str .= self::store32_le($ctxA[1][1]);
-            $str .= self::store32_le($ctxA[1][0]);
+        for ( $i = 1; $i < 3; ++$i ) {
+            $ctxA = $ctx[ $i ]->toArray();
+            $str .= self::store32_le( $ctxA[ 0 ][ 1 ] );
+            $str .= self::store32_le( $ctxA[ 0 ][ 0 ] );
+            $str .= self::store32_le( $ctxA[ 1 ][ 1 ] );
+            $str .= self::store32_le( $ctxA[ 1 ][ 0 ] );
         }
 
         # uint8_t buf[2 * 128];
-        $str .= self::SplFixedArrayToString($ctx[3]);
+        $str .= self::SplFixedArrayToString( $ctx[ 3 ] );
 
         /** @var int $ctx4 */
-        $ctx4 = (int) $ctx[4];
+        $ctx4 = (int)$ctx[ 4 ];
 
         # size_t buflen;
-        $str .= implode('', array(
-            self::intToChr($ctx4 & 0xff),
-            self::intToChr(($ctx4 >> 8) & 0xff),
-            self::intToChr(($ctx4 >> 16) & 0xff),
-            self::intToChr(($ctx4 >> 24) & 0xff),
-            self::intToChr(($ctx4 >> 32) & 0xff),
-            self::intToChr(($ctx4 >> 40) & 0xff),
-            self::intToChr(($ctx4 >> 48) & 0xff),
-            self::intToChr(($ctx4 >> 56) & 0xff)
-        ));
+        $str .= implode( '', array(
+            self::intToChr( $ctx4 & 0xff ),
+            self::intToChr( ( $ctx4 >> 8 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 16 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 24 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 32 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 40 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 48 ) & 0xff ),
+            self::intToChr( ( $ctx4 >> 56 ) & 0xff )
+        ) );
         # uint8_t last_node;
-        return $str . self::intToChr($ctx[5]) . str_repeat("\x00", 23);
+        return $str . self::intToChr( $ctx[ 5 ] ) . str_repeat( "\x00", 23 );
     }
 
     /**
@@ -740,19 +740,19 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArrayAssignment
      */
-    public static function stringToContext($string)
+    public static function stringToContext( $string )
     {
         $ctx = self::context();
 
         # uint64_t h[8];
-        for ($i = 0; $i < 8; ++$i) {
-            $ctx[0][$i] = SplFixedArray::fromArray(
+        for ( $i = 0; $i < 8; ++$i ) {
+            $ctx[ 0 ][ $i ] = SplFixedArray::fromArray(
                 array(
                     self::load_4(
-                        self::substr($string, (($i << 3) + 4), 4)
+                        self::substr( $string, ( ( $i << 3 ) + 4 ), 4 )
                     ),
                     self::load_4(
-                        self::substr($string, (($i << 3) + 0), 4)
+                        self::substr( $string, ( ( $i << 3 ) + 0 ), 4 )
                     )
                 )
             );
@@ -760,30 +760,30 @@ 
 
         # uint64_t t[2];
         # uint64_t f[2];
-        for ($i = 1; $i < 3; ++$i) {
-            $ctx[$i][1] = SplFixedArray::fromArray(
+        for ( $i = 1; $i < 3; ++$i ) {
+            $ctx[ $i ][ 1 ] = SplFixedArray::fromArray(
                 array(
-                    self::load_4(self::substr($string, 76 + (($i - 1) << 4), 4)),
-                    self::load_4(self::substr($string, 72 + (($i - 1) << 4), 4))
+                    self::load_4( self::substr( $string, 76 + ( ( $i - 1 ) << 4 ), 4 ) ),
+                    self::load_4( self::substr( $string, 72 + ( ( $i - 1 ) << 4 ), 4 ) )
                 )
             );
-            $ctx[$i][0] = SplFixedArray::fromArray(
+            $ctx[ $i ][ 0 ] = SplFixedArray::fromArray(
                 array(
-                    self::load_4(self::substr($string, 68 + (($i - 1) << 4), 4)),
-                    self::load_4(self::substr($string, 64 + (($i - 1) << 4), 4))
+                    self::load_4( self::substr( $string, 68 + ( ( $i - 1 ) << 4 ), 4 ) ),
+                    self::load_4( self::substr( $string, 64 + ( ( $i - 1 ) << 4 ), 4 ) )
                 )
             );
         }
 
         # uint8_t buf[2 * 128];
-        $ctx[3] = self::stringToSplFixedArray(self::substr($string, 96, 256));
+        $ctx[ 3 ] = self::stringToSplFixedArray( self::substr( $string, 96, 256 ) );
 
         # uint8_t buf[2 * 128];
         $int = 0;
-        for ($i = 0; $i < 8; ++$i) {
-            $int |= self::chrToInt($string[352 + $i]) << ($i << 3);
+        for ( $i = 0; $i < 8; ++$i ) {
+            $int |= self::chrToInt( $string[ 352 + $i ] ) << ( $i << 3 );
         }
-        $ctx[4] = $int;
+        $ctx[ 4 ] = $int;
 
         return $ctx;
     }

vendor/paragonie/sodium_compat/src/Core/Ed25519.php

Spacing +117 added lines, -117 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_Ed25519', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_Ed25519', false ) ) {
     return;
 }
 
@@ -23,10 +23,10 @@ 
      */
     public static function keypair()
     {
-        $seed = random_bytes(self::SEED_BYTES);
+        $seed = random_bytes( self::SEED_BYTES );
         $pk = '';
         $sk = '';
-        self::seed_keypair($pk, $sk, $seed);
+        self::seed_keypair( $pk, $sk, $seed );
         return $sk . $pk;
     }
 
@@ -40,14 +40,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function seed_keypair(&$pk, &$sk, $seed)
+    public static function seed_keypair( &$pk, &$sk, $seed )
     {
-        if (self::strlen($seed) !== self::SEED_BYTES) {
-            throw new RangeException('crypto_sign keypair seed must be 32 bytes long');
+        if ( self::strlen( $seed ) !== self::SEED_BYTES ) {
+            throw new RangeException( 'crypto_sign keypair seed must be 32 bytes long' );
         }
 
         /** @var string $pk */
-        $pk = self::publickey_from_secretkey($seed);
+        $pk = self::publickey_from_secretkey( $seed );
         $sk = $seed . $pk;
         return $sk;
     }
@@ -59,12 +59,12 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function secretkey($keypair)
+    public static function secretkey( $keypair )
     {
-        if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
-            throw new RangeException('crypto_sign keypair must be 96 bytes long');
+        if ( self::strlen( $keypair ) !== self::KEYPAIR_BYTES ) {
+            throw new RangeException( 'crypto_sign keypair must be 96 bytes long' );
         }
-        return self::substr($keypair, 0, 64);
+        return self::substr( $keypair, 0, 64 );
     }
 
     /**
@@ -74,12 +74,12 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function publickey($keypair)
+    public static function publickey( $keypair )
     {
-        if (self::strlen($keypair) !== self::KEYPAIR_BYTES) {
-            throw new RangeException('crypto_sign keypair must be 96 bytes long');
+        if ( self::strlen( $keypair ) !== self::KEYPAIR_BYTES ) {
+            throw new RangeException( 'crypto_sign keypair must be 96 bytes long' );
         }
-        return self::substr($keypair, 64, 32);
+        return self::substr( $keypair, 64, 32 );
     }
 
     /**
@@ -90,17 +90,17 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function publickey_from_secretkey($sk)
+    public static function publickey_from_secretkey( $sk )
     {
         /** @var string $sk */
-        $sk = hash('sha512', self::substr($sk, 0, 32), true);
-        $sk[0] = self::intToChr(
-            self::chrToInt($sk[0]) & 248
+        $sk = hash( 'sha512', self::substr( $sk, 0, 32 ), true );
+        $sk[ 0 ] = self::intToChr(
+            self::chrToInt( $sk[ 0 ] ) & 248
         );
-        $sk[31] = self::intToChr(
-            (self::chrToInt($sk[31]) & 63) | 64
+        $sk[ 31 ] = self::intToChr(
+            ( self::chrToInt( $sk[ 31 ] ) & 63 ) | 64
         );
-        return self::sk_to_pk($sk);
+        return self::sk_to_pk( $sk );
     }
 
     /**
@@ -109,15 +109,15 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function pk_to_curve25519($pk)
+    public static function pk_to_curve25519( $pk )
     {
-        if (self::small_order($pk)) {
-            throw new SodiumException('Public key is on a small order');
+        if ( self::small_order( $pk ) ) {
+            throw new SodiumException( 'Public key is on a small order' );
         }
-        $A = self::ge_frombytes_negate_vartime(self::substr($pk, 0, 32));
-        $p1 = self::ge_mul_l($A);
-        if (!self::fe_isnonzero($p1->X)) {
-            throw new SodiumException('Unexpected zero result');
+        $A = self::ge_frombytes_negate_vartime( self::substr( $pk, 0, 32 ) );
+        $p1 = self::ge_mul_l( $A );
+        if ( ! self::fe_isnonzero( $p1->X ) ) {
+            throw new SodiumException( 'Unexpected zero result' );
         }
 
         # fe_1(one_minus_y);
@@ -134,12 +134,12 @@ 
         # fe_add(x, x, A.Y);
         # fe_mul(x, x, one_minus_y);
         $x = self::fe_mul(
-            self::fe_add(self::fe_1(), $A->Y),
+            self::fe_add( self::fe_1(), $A->Y ),
             $one_minux_y
         );
 
         # fe_tobytes(curve25519_pk, x);
-        return self::fe_tobytes($x);
+        return self::fe_tobytes( $x );
     }
 
     /**
@@ -150,11 +150,11 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sk_to_pk($sk)
+    public static function sk_to_pk( $sk )
     {
         return self::ge_p3_tobytes(
             self::ge_scalarmult_base(
-                self::substr($sk, 0, 32)
+                self::substr( $sk, 0, 32 )
             )
         );
     }
@@ -168,10 +168,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($message, $sk)
+    public static function sign( $message, $sk )
     {
         /** @var string $signature */
-        $signature = self::sign_detached($message, $sk);
+        $signature = self::sign_detached( $message, $sk );
         return $signature . $message;
     }
 
@@ -184,18 +184,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_open($message, $pk)
+    public static function sign_open( $message, $pk )
     {
         /** @var string $signature */
-        $signature = self::substr($message, 0, 64);
+        $signature = self::substr( $message, 0, 64 );
 
         /** @var string $message */
-        $message = self::substr($message, 64);
+        $message = self::substr( $message, 64 );
 
-        if (self::verify_detached($signature, $message, $pk)) {
+        if ( self::verify_detached( $signature, $message, $pk ) ) {
             return $message;
         }
-        throw new SodiumException('Invalid signature');
+        throw new SodiumException( 'Invalid signature' );
     }
 
     /**
@@ -207,56 +207,56 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_detached($message, $sk)
+    public static function sign_detached( $message, $sk )
     {
         # crypto_hash_sha512(az, sk, 32);
-        $az =  hash('sha512', self::substr($sk, 0, 32), true);
+        $az = hash( 'sha512', self::substr( $sk, 0, 32 ), true );
 
         # az[0] &= 248;
         # az[31] &= 63;
         # az[31] |= 64;
-        $az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
-        $az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
+        $az[ 0 ] = self::intToChr( self::chrToInt( $az[ 0 ] ) & 248 );
+        $az[ 31 ] = self::intToChr( ( self::chrToInt( $az[ 31 ] ) & 63 ) | 64 );
 
         # crypto_hash_sha512_init(&hs);
         # crypto_hash_sha512_update(&hs, az + 32, 32);
         # crypto_hash_sha512_update(&hs, m, mlen);
         # crypto_hash_sha512_final(&hs, nonce);
-        $hs = hash_init('sha512');
-        hash_update($hs, self::substr($az, 32, 32));
-        hash_update($hs, $message);
-        $nonceHash = hash_final($hs, true);
+        $hs = hash_init( 'sha512' );
+        hash_update( $hs, self::substr( $az, 32, 32 ) );
+        hash_update( $hs, $message );
+        $nonceHash = hash_final( $hs, true );
 
         # memmove(sig + 32, sk + 32, 32);
-        $pk = self::substr($sk, 32, 32);
+        $pk = self::substr( $sk, 32, 32 );
 
         # sc_reduce(nonce);
         # ge_scalarmult_base(&R, nonce);
         # ge_p3_tobytes(sig, &R);
-        $nonce = self::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
+        $nonce = self::sc_reduce( $nonceHash ) . self::substr( $nonceHash, 32 );
         $sig = self::ge_p3_tobytes(
-            self::ge_scalarmult_base($nonce)
+            self::ge_scalarmult_base( $nonce )
         );
 
         # crypto_hash_sha512_init(&hs);
         # crypto_hash_sha512_update(&hs, sig, 64);
         # crypto_hash_sha512_update(&hs, m, mlen);
         # crypto_hash_sha512_final(&hs, hram);
-        $hs = hash_init('sha512');
-        hash_update($hs, self::substr($sig, 0, 32));
-        hash_update($hs, self::substr($pk, 0, 32));
-        hash_update($hs, $message);
-        $hramHash = hash_final($hs, true);
+        $hs = hash_init( 'sha512' );
+        hash_update( $hs, self::substr( $sig, 0, 32 ) );
+        hash_update( $hs, self::substr( $pk, 0, 32 ) );
+        hash_update( $hs, $message );
+        $hramHash = hash_final( $hs, true );
 
         # sc_reduce(hram);
         # sc_muladd(sig + 32, hram, az, nonce);
-        $hram = self::sc_reduce($hramHash);
-        $sigAfter = self::sc_muladd($hram, $az, $nonce);
-        $sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
+        $hram = self::sc_reduce( $hramHash );
+        $sigAfter = self::sc_muladd( $hram, $az, $nonce );
+        $sig = self::substr( $sig, 0, 32 ) . self::substr( $sigAfter, 0, 32 );
 
         try {
-            ParagonIE_Sodium_Compat::memzero($az);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $az );
+        } catch ( SodiumException $ex ) {
             $az = null;
         }
         return $sig;
@@ -272,26 +272,26 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_detached($sig, $message, $pk)
+    public static function verify_detached( $sig, $message, $pk )
     {
-        if (self::strlen($sig) < 64) {
-            throw new SodiumException('Signature is too short');
+        if ( self::strlen( $sig ) < 64 ) {
+            throw new SodiumException( 'Signature is too short' );
         }
-        if ((self::chrToInt($sig[63]) & 240) && self::check_S_lt_L(self::substr($sig, 32, 32))) {
-            throw new SodiumException('S < L - Invalid signature');
+        if ( ( self::chrToInt( $sig[ 63 ] ) & 240 ) && self::check_S_lt_L( self::substr( $sig, 32, 32 ) ) ) {
+            throw new SodiumException( 'S < L - Invalid signature' );
         }
-        if (self::small_order($sig)) {
-            throw new SodiumException('Signature is on too small of an order');
+        if ( self::small_order( $sig ) ) {
+            throw new SodiumException( 'Signature is on too small of an order' );
         }
-        if ((self::chrToInt($sig[63]) & 224) !== 0) {
-            throw new SodiumException('Invalid signature');
+        if ( ( self::chrToInt( $sig[ 63 ] ) & 224 ) !== 0 ) {
+            throw new SodiumException( 'Invalid signature' );
         }
         $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= self::chrToInt($pk[$i]);
+        for ( $i = 0; $i < 32; ++$i ) {
+            $d |= self::chrToInt( $pk[ $i ] );
         }
-        if ($d === 0) {
-            throw new SodiumException('All zero public key');
+        if ( $d === 0 ) {
+            throw new SodiumException( 'All zero public key' );
         }
 
         /** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
@@ -301,34 +301,34 @@ 
         ParagonIE_Sodium_Compat::$fastMult = true;
 
         /** @var ParagonIE_Sodium_Core_Curve25519_Ge_P3 $A */
-        $A = self::ge_frombytes_negate_vartime($pk);
+        $A = self::ge_frombytes_negate_vartime( $pk );
 
         /** @var string $hDigest */
         $hDigest = hash(
             'sha512',
-            self::substr($sig, 0, 32) .
-                self::substr($pk, 0, 32) .
+            self::substr( $sig, 0, 32 ) .
+                self::substr( $pk, 0, 32 ) .
                 $message,
             true
         );
 
         /** @var string $h */
-        $h = self::sc_reduce($hDigest) . self::substr($hDigest, 32);
+        $h = self::sc_reduce( $hDigest ) . self::substr( $hDigest, 32 );
 
         /** @var ParagonIE_Sodium_Core_Curve25519_Ge_P2 $R */
         $R = self::ge_double_scalarmult_vartime(
             $h,
             $A,
-            self::substr($sig, 32)
+            self::substr( $sig, 32 )
         );
 
         /** @var string $rcheck */
-        $rcheck = self::ge_tobytes($R);
+        $rcheck = self::ge_tobytes( $R );
 
         // Reset ParagonIE_Sodium_Compat::$fastMult to what it was before.
         ParagonIE_Sodium_Compat::$fastMult = $orig;
 
-        return self::verify_32($rcheck, self::substr($sig, 0, 32));
+        return self::verify_32( $rcheck, self::substr( $sig, 0, 32 ) );
     }
 
     /**
@@ -339,10 +339,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function check_S_lt_L($S)
+    public static function check_S_lt_L( $S )
     {
-        if (self::strlen($S) < 32) {
-            throw new SodiumException('Signature must be 32 bytes');
+        if ( self::strlen( $S ) < 32 ) {
+            throw new SodiumException( 'Signature must be 32 bytes' );
         }
         $L = array(
             0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58,
@@ -357,14 +357,14 @@ 
         /** @var array<int, int> $L */
         do {
             --$i;
-            $x = self::chrToInt($S[$i]);
+            $x = self::chrToInt( $S[ $i ] );
             $c |= (
-                (($x - $L[$i]) >> 8) & $n
+                ( ( $x - $L[ $i ] ) >> 8 ) & $n
             );
             $n &= (
-                (($x ^ $L[$i]) - 1) >> 8
+                ( ( $x ^ $L[ $i ] ) - 1 ) >> 8
             );
-        } while ($i !== 0);
+        } while ( $i !== 0 );
 
         return $c === 0;
     }
@@ -375,7 +375,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function small_order($R)
+    public static function small_order( $R )
     {
         /** @var array<int, array<int, int>> $blocklist */
         $blocklist = array(
@@ -465,14 +465,14 @@ 
             )
         );
         /** @var int $countBlocklist */
-        $countBlocklist = count($blocklist);
+        $countBlocklist = count( $blocklist );
 
-        for ($i = 0; $i < $countBlocklist; ++$i) {
+        for ( $i = 0; $i < $countBlocklist; ++$i ) {
             $c = 0;
-            for ($j = 0; $j < 32; ++$j) {
-                $c |= self::chrToInt($R[$j]) ^ (int) $blocklist[$i][$j];
+            for ( $j = 0; $j < 32; ++$j ) {
+                $c |= self::chrToInt( $R[ $j ] ) ^ (int)$blocklist[ $i ][ $j ];
             }
-            if ($c === 0) {
+            if ( $c === 0 ) {
                 return true;
             }
         }
@@ -484,13 +484,13 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_complement($s)
+    public static function scalar_complement( $s )
     {
-        $t_ = self::L . str_repeat("\x00", 32);
-        sodium_increment($t_);
-        $s_ = $s . str_repeat("\x00", 32);
-        ParagonIE_Sodium_Compat::sub($t_, $s_);
-        return self::sc_reduce($t_);
+        $t_ = self::L . str_repeat( "\x00", 32 );
+        sodium_increment( $t_ );
+        $s_ = $s . str_repeat( "\x00", 32 );
+        ParagonIE_Sodium_Compat::sub( $t_, $s_ );
+        return self::sc_reduce( $t_ );
     }
 
     /**
@@ -500,12 +500,12 @@ 
     public static function scalar_random()
     {
         do {
-            $r = ParagonIE_Sodium_Compat::randombytes_buf(self::SCALAR_BYTES);
-            $r[self::SCALAR_BYTES - 1] = self::intToChr(
-                self::chrToInt($r[self::SCALAR_BYTES - 1]) & 0x1f
+            $r = ParagonIE_Sodium_Compat::randombytes_buf( self::SCALAR_BYTES );
+            $r[ self::SCALAR_BYTES - 1 ] = self::intToChr(
+                self::chrToInt( $r[ self::SCALAR_BYTES - 1 ] ) & 0x1f
             );
         } while (
-            !self::check_S_lt_L($r) || ParagonIE_Sodium_Compat::is_zero($r)
+            ! self::check_S_lt_L( $r ) || ParagonIE_Sodium_Compat::is_zero( $r )
         );
         return $r;
     }
@@ -515,12 +515,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_negate($s)
+    public static function scalar_negate( $s )
     {
-        $t_ = self::L . str_repeat("\x00", 32) ;
-        $s_ = $s . str_repeat("\x00", 32) ;
-        ParagonIE_Sodium_Compat::sub($t_, $s_);
-        return self::sc_reduce($t_);
+        $t_ = self::L . str_repeat( "\x00", 32 );
+        $s_ = $s . str_repeat( "\x00", 32 );
+        ParagonIE_Sodium_Compat::sub( $t_, $s_ );
+        return self::sc_reduce( $t_ );
     }
 
     /**
@@ -529,12 +529,12 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_add($a, $b)
+    public static function scalar_add( $a, $b )
     {
-        $a_ = $a . str_repeat("\x00", 32);
-        $b_ = $b . str_repeat("\x00", 32);
-        ParagonIE_Sodium_Compat::add($a_, $b_);
-        return self::sc_reduce($a_);
+        $a_ = $a . str_repeat( "\x00", 32 );
+        $b_ = $b . str_repeat( "\x00", 32 );
+        ParagonIE_Sodium_Compat::add( $a_, $b_ );
+        return self::sc_reduce( $a_ );
     }
 
     /**
@@ -543,9 +543,9 @@ 
      * @return string
      * @throws SodiumException
      */
-    public static function scalar_sub($x, $y)
+    public static function scalar_sub( $x, $y )
     {
-        $yn = self::scalar_negate($y);
-        return self::scalar_add($x, $yn);
+        $yn = self::scalar_negate( $y );
+        return self::scalar_add( $x, $yn );
     }
 }

vendor/paragonie/sodium_compat/src/Core/Util.php

Spacing +257 added lines, -257 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_Util', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_Util', false ) ) {
     return;
 }
 
@@ -14,22 +14,22 @@ 
      * @param int $size (16, 32, 64)
      * @return int
      */
-    public static function abs($integer, $size = 0)
+    public static function abs( $integer, $size = 0 )
     {
         /** @var int $realSize */
-        $realSize = (PHP_INT_SIZE << 3) - 1;
-        if ($size) {
+        $realSize = ( PHP_INT_SIZE << 3 ) - 1;
+        if ( $size ) {
             --$size;
         } else {
             /** @var int $size */
             $size = $realSize;
         }
 
-        $negative = -(($integer >> $size) & 1);
-        return (int) (
-            ($integer ^ $negative)
+        $negative = -( ( $integer >> $size ) & 1 );
+        return (int)(
+            ( $integer ^ $negative )
                 +
-            (($negative >> $realSize) & 1)
+            ( ( $negative >> $realSize ) & 1 )
         );
     }
 
@@ -43,26 +43,26 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function bin2hex($binaryString)
+    public static function bin2hex( $binaryString )
     {
         /* Type checks: */
-        if (!is_string($binaryString)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($binaryString) . ' given.');
+        if ( ! is_string( $binaryString ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $binaryString ) . ' given.' );
         }
 
         $hex = '';
-        $len = self::strlen($binaryString);
-        for ($i = 0; $i < $len; ++$i) {
+        $len = self::strlen( $binaryString );
+        for ( $i = 0; $i < $len; ++$i ) {
             /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $binaryString[$i]);
+            $chunk = unpack( 'C', $binaryString[ $i ] );
             /** @var int $c */
-            $c = $chunk[1] & 0xf;
+            $c = $chunk[ 1 ] & 0xf;
             /** @var int $b */
-            $b = $chunk[1] >> 4;
+            $b = $chunk[ 1 ] >> 4;
             $hex .= pack(
                 'CC',
-                (87 + $b + ((($b - 10) >> 8) & ~38)),
-                (87 + $c + ((($c - 10) >> 8) & ~38))
+                ( 87 + $b + ( ( ( $b - 10 ) >> 8 ) & ~38 ) ),
+                ( 87 + $c + ( ( ( $c - 10 ) >> 8 ) & ~38 ) )
             );
         }
         return $hex;
@@ -78,25 +78,25 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function bin2hexUpper($bin_string)
+    public static function bin2hexUpper( $bin_string )
     {
         $hex = '';
-        $len = self::strlen($bin_string);
-        for ($i = 0; $i < $len; ++$i) {
+        $len = self::strlen( $bin_string );
+        for ( $i = 0; $i < $len; ++$i ) {
             /** @var array<int, int> $chunk */
-            $chunk = unpack('C', $bin_string[$i]);
+            $chunk = unpack( 'C', $bin_string[ $i ] );
             /**
              * Lower 16 bits
              *
              * @var int $c
              */
-            $c = $chunk[1] & 0xf;
+            $c = $chunk[ 1 ] & 0xf;
 
             /**
              * Upper 16 bits
              * @var int $b
              */
-            $b = $chunk[1] >> 4;
+            $b = $chunk[ 1 ] >> 4;
 
             /**
              * Use pack() and binary operators to turn the two integers
@@ -106,8 +106,8 @@ 
              */
             $hex .= pack(
                 'CC',
-                (55 + $b + ((($b - 10) >> 8) & ~6)),
-                (55 + $c + ((($c - 10) >> 8) & ~6))
+                ( 55 + $b + ( ( ( $b - 10 ) >> 8 ) & ~6 ) ),
+                ( 55 + $c + ( ( ( $c - 10 ) >> 8 ) & ~6 ) )
             );
         }
         return $hex;
@@ -123,18 +123,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function chrToInt($chr)
+    public static function chrToInt( $chr )
     {
         /* Type checks: */
-        if (!is_string($chr)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($chr) . ' given.');
+        if ( ! is_string( $chr ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $chr ) . ' given.' );
         }
-        if (self::strlen($chr) !== 1) {
-            throw new SodiumException('chrToInt() expects a string that is exactly 1 character long');
+        if ( self::strlen( $chr ) !== 1 ) {
+            throw new SodiumException( 'chrToInt() expects a string that is exactly 1 character long' );
         }
         /** @var array<int, int> $chunk */
-        $chunk = unpack('C', $chr);
-        return (int) ($chunk[1]);
+        $chunk = unpack( 'C', $chr );
+        return (int)( $chunk[ 1 ] );
     }
 
     /**
@@ -149,25 +149,25 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function compare($left, $right, $len = null)
+    public static function compare( $left, $right, $len = null )
     {
-        $leftLen = self::strlen($left);
-        $rightLen = self::strlen($right);
-        if ($len === null) {
-            $len = max($leftLen, $rightLen);
-            $left = str_pad($left, $len, "\x00", STR_PAD_RIGHT);
-            $right = str_pad($right, $len, "\x00", STR_PAD_RIGHT);
+        $leftLen = self::strlen( $left );
+        $rightLen = self::strlen( $right );
+        if ( $len === null ) {
+            $len = max( $leftLen, $rightLen );
+            $left = str_pad( $left, $len, "\x00", STR_PAD_RIGHT );
+            $right = str_pad( $right, $len, "\x00", STR_PAD_RIGHT );
         }
 
         $gt = 0;
         $eq = 1;
         $i = $len;
-        while ($i !== 0) {
+        while ( $i !== 0 ) {
             --$i;
-            $gt |= ((self::chrToInt($right[$i]) - self::chrToInt($left[$i])) >> 8) & $eq;
-            $eq &= ((self::chrToInt($right[$i]) ^ self::chrToInt($left[$i])) - 1) >> 8;
+            $gt |= ( ( self::chrToInt( $right[ $i ] ) - self::chrToInt( $left[ $i ] ) ) >> 8 ) & $eq;
+            $eq &= ( ( self::chrToInt( $right[ $i ] ) ^ self::chrToInt( $left[ $i ] ) ) - 1 ) >> 8;
         }
-        return ($gt + $gt + $eq) - 1;
+        return ( $gt + $gt + $eq ) - 1;
     }
 
     /**
@@ -180,71 +180,71 @@ 
      * @throws SodiumException
      * @return void
      */
-    public static function declareScalarType(&$mixedVar = null, $type = 'void', $argumentIndex = 0)
+    public static function declareScalarType( &$mixedVar = null, $type = 'void', $argumentIndex = 0 )
     {
-        if (func_num_args() === 0) {
+        if ( func_num_args() === 0 ) {
             /* Tautology, by default */
             return;
         }
-        if (func_num_args() === 1) {
-            throw new TypeError('Declared void, but passed a variable');
+        if ( func_num_args() === 1 ) {
+            throw new TypeError( 'Declared void, but passed a variable' );
         }
-        $realType = strtolower(gettype($mixedVar));
-        $type = strtolower($type);
-        switch ($type) {
+        $realType = strtolower( gettype( $mixedVar ) );
+        $type = strtolower( $type );
+        switch ( $type ) {
             case 'null':
-                if ($mixedVar !== null) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.');
+                if ( $mixedVar !== null ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be null, ' . $realType . ' given.' );
                 }
                 break;
             case 'integer':
             case 'int':
-                $allow = array('int', 'integer');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.');
+                $allow = array( 'int', 'integer' );
+                if ( ! in_array( $type, $allow ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be an integer, ' . $realType . ' given.' );
                 }
-                $mixedVar = (int) $mixedVar;
+                $mixedVar = (int)$mixedVar;
                 break;
             case 'boolean':
             case 'bool':
-                $allow = array('bool', 'boolean');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.');
+                $allow = array( 'bool', 'boolean' );
+                if ( ! in_array( $type, $allow ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be a boolean, ' . $realType . ' given.' );
                 }
-                $mixedVar = (bool) $mixedVar;
+                $mixedVar = (bool)$mixedVar;
                 break;
             case 'string':
-                if (!is_string($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.');
+                if ( ! is_string( $mixedVar ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be a string, ' . $realType . ' given.' );
                 }
-                $mixedVar = (string) $mixedVar;
+                $mixedVar = (string)$mixedVar;
                 break;
             case 'decimal':
             case 'double':
             case 'float':
-                $allow = array('decimal', 'double', 'float');
-                if (!in_array($type, $allow)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.');
+                $allow = array( 'decimal', 'double', 'float' );
+                if ( ! in_array( $type, $allow ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be a float, ' . $realType . ' given.' );
                 }
-                $mixedVar = (float) $mixedVar;
+                $mixedVar = (float)$mixedVar;
                 break;
             case 'object':
-                if (!is_object($mixedVar)) {
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.');
+                if ( ! is_object( $mixedVar ) ) {
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be an object, ' . $realType . ' given.' );
                 }
                 break;
             case 'array':
-                if (!is_array($mixedVar)) {
-                    if (is_object($mixedVar)) {
-                        if ($mixedVar instanceof ArrayAccess) {
+                if ( ! is_array( $mixedVar ) ) {
+                    if ( is_object( $mixedVar ) ) {
+                        if ( $mixedVar instanceof ArrayAccess ) {
                             return;
                         }
                     }
-                    throw new TypeError('Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.');
+                    throw new TypeError( 'Argument ' . $argumentIndex . ' must be an array, ' . $realType . ' given.' );
                 }
                 break;
             default:
-                throw new SodiumException('Unknown type (' . $realType .') does not match expect type (' . $type . ')');
+                throw new SodiumException( 'Unknown type (' . $realType . ') does not match expect type (' . $type . ')' );
         }
     }
 
@@ -257,30 +257,30 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function hashEquals($left, $right)
+    public static function hashEquals( $left, $right )
     {
         /* Type checks: */
-        if (!is_string($left)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($left) . ' given.');
+        if ( ! is_string( $left ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $left ) . ' given.' );
         }
-        if (!is_string($right)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($right) . ' given.');
+        if ( ! is_string( $right ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $right ) . ' given.' );
         }
 
-        if (is_callable('hash_equals')) {
-            return hash_equals($left, $right);
+        if ( is_callable( 'hash_equals' ) ) {
+            return hash_equals( $left, $right );
         }
         $d = 0;
         /** @var int $len */
-        $len = self::strlen($left);
-        if ($len !== self::strlen($right)) {
+        $len = self::strlen( $left );
+        if ( $len !== self::strlen( $right ) ) {
             return false;
         }
-        for ($i = 0; $i < $len; ++$i) {
-            $d |= self::chrToInt($left[$i]) ^ self::chrToInt($right[$i]);
+        for ( $i = 0; $i < $len; ++$i ) {
+            $d |= self::chrToInt( $left[ $i ] ) ^ self::chrToInt( $right[ $i ] );
         }
 
-        if ($d !== 0) {
+        if ( $d !== 0 ) {
             return false;
         }
         return $left === $right;
@@ -295,10 +295,10 @@ 
      * @throws SodiumException
      * @psalm-suppress PossiblyInvalidArgument
      */
-    protected static function hash_update(&$hs, $data)
+    protected static function hash_update( &$hs, $data )
     {
-        if (!hash_update($hs, $data)) {
-            throw new SodiumException('hash_update() failed');
+        if ( ! hash_update( $hs, $data ) ) {
+            throw new SodiumException( 'hash_update() failed' );
         }
     }
 
@@ -314,11 +314,11 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function hex2bin($hexString, $strictPadding = false)
+    public static function hex2bin( $hexString, $strictPadding = false )
     {
         /* Type checks: */
-        if (!is_string($hexString)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($hexString) . ' given.');
+        if ( ! is_string( $hexString ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $hexString ) . ' given.' );
         }
 
         /** @var int $hex_pos */
@@ -328,11 +328,11 @@ 
         /** @var int $c_acc */
         $c_acc = 0;
         /** @var int $hex_len */
-        $hex_len = self::strlen($hexString);
+        $hex_len = self::strlen( $hexString );
         /** @var int $state */
         $state = 0;
-        if (($hex_len & 1) !== 0) {
-            if ($strictPadding) {
+        if ( ( $hex_len & 1 ) !== 0 ) {
+            if ( $strictPadding ) {
                 throw new RangeException(
                     'Expected an even number of hexadecimal characters'
                 );
@@ -342,30 +342,30 @@ 
             }
         }
 
-        $chunk = unpack('C*', $hexString);
-        while ($hex_pos < $hex_len) {
+        $chunk = unpack( 'C*', $hexString );
+        while ( $hex_pos < $hex_len ) {
             ++$hex_pos;
             /** @var int $c */
-            $c = $chunk[$hex_pos];
+            $c = $chunk[ $hex_pos ];
             /** @var int $c_num */
             $c_num = $c ^ 48;
             /** @var int $c_num0 */
-            $c_num0 = ($c_num - 10) >> 8;
+            $c_num0 = ( $c_num - 10 ) >> 8;
             /** @var int $c_alpha */
-            $c_alpha = ($c & ~32) - 55;
+            $c_alpha = ( $c & ~32 ) - 55;
             /** @var int $c_alpha0 */
-            $c_alpha0 = (($c_alpha - 10) ^ ($c_alpha - 16)) >> 8;
-            if (($c_num0 | $c_alpha0) === 0) {
+            $c_alpha0 = ( ( $c_alpha - 10 ) ^ ( $c_alpha - 16 ) ) >> 8;
+            if ( ( $c_num0 | $c_alpha0 ) === 0 ) {
                 throw new RangeException(
                     'hex2bin() only expects hexadecimal characters'
                 );
             }
             /** @var int $c_val */
-            $c_val = ($c_num0 & $c_num) | ($c_alpha & $c_alpha0);
-            if ($state === 0) {
+            $c_val = ( $c_num0 & $c_num ) | ( $c_alpha & $c_alpha0 );
+            if ( $state === 0 ) {
                 $c_acc = $c_val * 16;
             } else {
-                $bin .= pack('C', $c_acc | $c_val);
+                $bin .= pack( 'C', $c_acc | $c_val );
             }
             $state ^= 1;
         }
@@ -380,15 +380,15 @@ 
      * @param array<int, int> $ints
      * @return string
      */
-    public static function intArrayToString(array $ints)
+    public static function intArrayToString( array $ints )
     {
         /** @var array<int, int> $args */
         $args = $ints;
-        foreach ($args as $i => $v) {
-            $args[$i] = (int) ($v & 0xff);
+        foreach ( $args as $i => $v ) {
+            $args[ $i ] = (int)( $v & 0xff );
         }
-        array_unshift($args, str_repeat('C', count($ints)));
-        return (string) (call_user_func_array('pack', $args));
+        array_unshift( $args, str_repeat( 'C', count( $ints ) ) );
+        return (string)( call_user_func_array( 'pack', $args ) );
     }
 
     /**
@@ -400,9 +400,9 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function intToChr($int)
+    public static function intToChr( $int )
     {
-        return pack('C', $int);
+        return pack( 'C', $int );
     }
 
     /**
@@ -415,22 +415,22 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function load_3($string)
+    public static function load_3( $string )
     {
         /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $string ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($string) < 3) {
+        if ( self::strlen( $string ) < 3 ) {
             throw new RangeException(
-                'String must be 3 bytes or more; ' . self::strlen($string) . ' given.'
+                'String must be 3 bytes or more; ' . self::strlen( $string ) . ' given.'
             );
         }
         /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string . "\0");
-        return (int) ($unpacked[1] & 0xffffff);
+        $unpacked = unpack( 'V', $string . "\0" );
+        return (int)( $unpacked[ 1 ] & 0xffffff );
     }
 
     /**
@@ -443,22 +443,22 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function load_4($string)
+    public static function load_4( $string )
     {
         /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $string ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($string) < 4) {
+        if ( self::strlen( $string ) < 4 ) {
             throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+                'String must be 4 bytes or more; ' . self::strlen( $string ) . ' given.'
             );
         }
         /** @var array<int, int> $unpacked */
-        $unpacked = unpack('V', $string);
-        return (int) ($unpacked[1] & 0xffffffff);
+        $unpacked = unpack( 'V', $string );
+        return (int)( $unpacked[ 1 ] & 0xffffffff );
     }
 
     /**
@@ -472,35 +472,35 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function load64_le($string)
+    public static function load64_le( $string )
     {
         /* Type checks: */
-        if (!is_string($string)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($string) . ' given.');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $string ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($string) < 4) {
+        if ( self::strlen( $string ) < 4 ) {
             throw new RangeException(
-                'String must be 4 bytes or more; ' . self::strlen($string) . ' given.'
+                'String must be 4 bytes or more; ' . self::strlen( $string ) . ' given.'
             );
         }
-        if (PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8) {
+        if ( PHP_VERSION_ID >= 50603 && PHP_INT_SIZE === 8 ) {
             /** @var array<int, int> $unpacked */
-            $unpacked = unpack('P', $string);
-            return (int) $unpacked[1];
+            $unpacked = unpack( 'P', $string );
+            return (int)$unpacked[ 1 ];
         }
 
         /** @var int $result */
-        $result  = (self::chrToInt($string[0]) & 0xff);
-        $result |= (self::chrToInt($string[1]) & 0xff) <<  8;
-        $result |= (self::chrToInt($string[2]) & 0xff) << 16;
-        $result |= (self::chrToInt($string[3]) & 0xff) << 24;
-        $result |= (self::chrToInt($string[4]) & 0xff) << 32;
-        $result |= (self::chrToInt($string[5]) & 0xff) << 40;
-        $result |= (self::chrToInt($string[6]) & 0xff) << 48;
-        $result |= (self::chrToInt($string[7]) & 0xff) << 56;
-        return (int) $result;
+        $result  = ( self::chrToInt( $string[ 0 ] ) & 0xff );
+        $result |= ( self::chrToInt( $string[ 1 ] ) & 0xff ) << 8;
+        $result |= ( self::chrToInt( $string[ 2 ] ) & 0xff ) << 16;
+        $result |= ( self::chrToInt( $string[ 3 ] ) & 0xff ) << 24;
+        $result |= ( self::chrToInt( $string[ 4 ] ) & 0xff ) << 32;
+        $result |= ( self::chrToInt( $string[ 5 ] ) & 0xff ) << 40;
+        $result |= ( self::chrToInt( $string[ 6 ] ) & 0xff ) << 48;
+        $result |= ( self::chrToInt( $string[ 7 ] ) & 0xff ) << 56;
+        return (int)$result;
     }
 
     /**
@@ -512,9 +512,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function memcmp($left, $right)
+    public static function memcmp( $left, $right )
     {
-        if (self::hashEquals($left, $right)) {
+        if ( self::hashEquals( $left, $right ) ) {
             return 0;
         }
         return -1;
@@ -537,19 +537,19 @@ 
      *                  constant operands)
      * @return int
      */
-    public static function mul($a, $b, $size = 0)
+    public static function mul( $a, $b, $size = 0 )
     {
-        if (ParagonIE_Sodium_Compat::$fastMult) {
-            return (int) ($a * $b);
+        if ( ParagonIE_Sodium_Compat::$fastMult ) {
+            return (int)( $a * $b );
         }
 
         static $defaultSize = null;
         /** @var int $defaultSize */
-        if (!$defaultSize) {
+        if ( ! $defaultSize ) {
             /** @var int $defaultSize */
-            $defaultSize = (PHP_INT_SIZE << 3) - 1;
+            $defaultSize = ( PHP_INT_SIZE << 3 ) - 1;
         }
-        if ($size < 1) {
+        if ( $size < 1 ) {
             /** @var int $size */
             $size = $defaultSize;
         }
@@ -565,7 +565,7 @@ 
          *
          * @var int
          */
-        $mask = -(($b >> ((int) $defaultSize)) & 1);
+        $mask = -( ( $b >> ( (int)$defaultSize ) ) & 1 );
 
         /**
          * Ensure $b is a positive integer, without creating
@@ -573,7 +573,7 @@ 
          *
          * @var int $b
          */
-        $b = ($b & ~$mask) | ($mask & -$b);
+        $b = ( $b & ~$mask ) | ( $mask & -$b );
 
         /**
          * Unless $size is provided:
@@ -581,12 +581,12 @@ 
          * This loop always runs 32 times when PHP_INT_SIZE is 4.
          * This loop always runs 64 times when PHP_INT_SIZE is 8.
          */
-        for ($i = $size; $i >= 0; --$i) {
-            $c += (int) ($a & -($b & 1));
+        for ( $i = $size; $i >= 0; --$i ) {
+            $c += (int)( $a & -( $b & 1 ) );
             $a <<= 1;
             $b >>= 1;
         }
-        $c = (int) @($c & -1);
+        $c = (int)@( $c & -1 );
 
         /**
          * If $b was negative, we then apply the same value to $c here.
@@ -597,7 +597,7 @@ 
          *
          * The end result is what we'd expect from integer multiplication.
          */
-        return (int) (($c & ~$mask) | ($mask & -$c));
+        return (int)( ( $c & ~$mask ) | ( $mask & -$c ) );
     }
 
     /**
@@ -609,22 +609,22 @@ 
      * @param int|float $num
      * @return array<int, int>
      */
-    public static function numericTo64BitInteger($num)
+    public static function numericTo64BitInteger( $num )
     {
         $high = 0;
         /** @var int $low */
         $low = $num & 0xffffffff;
 
-        if ((+(abs($num))) >= 1) {
-            if ($num > 0) {
+        if ( (+( abs( $num ) )) >= 1 ) {
+            if ( $num > 0 ) {
                 /** @var int $high */
-                $high = min((+(floor($num/4294967296))), 4294967295);
+                $high = min( (+( floor( $num / 4294967296 ) )), 4294967295 );
             } else {
                 /** @var int $high */
-                $high = ~~((+(ceil(($num - (+((~~($num)))))/4294967296))));
+                $high = ~~( (+( ceil( ( $num - (+( ( ~~( $num ) ) )) ) / 4294967296 ) )) );
             }
         }
-        return array((int) $high, (int) $low);
+        return array( (int)$high, (int)$low );
     }
 
     /**
@@ -636,19 +636,19 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store_3($int)
+    public static function store_3( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
         /** @var string $packed */
-        $packed = pack('N', $int);
-        return self::substr($packed, 1, 3);
+        $packed = pack( 'N', $int );
+        return self::substr( $packed, 1, 3 );
     }
 
     /**
@@ -660,19 +660,19 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store32_le($int)
+    public static function store32_le( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
 
         /** @var string $packed */
-        $packed = pack('V', $int);
+        $packed = pack( 'V', $int );
         return $packed;
     }
 
@@ -685,19 +685,19 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store_4($int)
+    public static function store_4( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
 
         /** @var string $packed */
-        $packed = pack('N', $int);
+        $packed = pack( 'N', $int );
         return $packed;
     }
 
@@ -710,46 +710,46 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function store64_le($int)
+    public static function store64_le( $int )
     {
         /* Type checks: */
-        if (!is_int($int)) {
-            if (is_numeric($int)) {
-                $int = (int) $int;
+        if ( ! is_int( $int ) ) {
+            if ( is_numeric( $int ) ) {
+                $int = (int)$int;
             } else {
-                throw new TypeError('Argument 1 must be an integer, ' . gettype($int) . ' given.');
+                throw new TypeError( 'Argument 1 must be an integer, ' . gettype( $int ) . ' given.' );
             }
         }
 
-        if (PHP_INT_SIZE === 8) {
-            if (PHP_VERSION_ID >= 50603) {
+        if ( PHP_INT_SIZE === 8 ) {
+            if ( PHP_VERSION_ID >= 50603 ) {
                 /** @var string $packed */
-                $packed = pack('P', $int);
+                $packed = pack( 'P', $int );
                 return $packed;
             }
-            return self::intToChr($int & 0xff) .
-                self::intToChr(($int >>  8) & 0xff) .
-                self::intToChr(($int >> 16) & 0xff) .
-                self::intToChr(($int >> 24) & 0xff) .
-                self::intToChr(($int >> 32) & 0xff) .
-                self::intToChr(($int >> 40) & 0xff) .
-                self::intToChr(($int >> 48) & 0xff) .
-                self::intToChr(($int >> 56) & 0xff);
-        }
-        if ($int > PHP_INT_MAX) {
-            list($hiB, $int) = self::numericTo64BitInteger($int);
+            return self::intToChr( $int & 0xff ) .
+                self::intToChr( ( $int >> 8 ) & 0xff ) .
+                self::intToChr( ( $int >> 16 ) & 0xff ) .
+                self::intToChr( ( $int >> 24 ) & 0xff ) .
+                self::intToChr( ( $int >> 32 ) & 0xff ) .
+                self::intToChr( ( $int >> 40 ) & 0xff ) .
+                self::intToChr( ( $int >> 48 ) & 0xff ) .
+                self::intToChr( ( $int >> 56 ) & 0xff );
+        }
+        if ( $int > PHP_INT_MAX ) {
+            list( $hiB, $int ) = self::numericTo64BitInteger( $int );
         } else {
             $hiB = 0;
         }
         return
-            self::intToChr(($int      ) & 0xff) .
-            self::intToChr(($int >>  8) & 0xff) .
-            self::intToChr(($int >> 16) & 0xff) .
-            self::intToChr(($int >> 24) & 0xff) .
-            self::intToChr($hiB & 0xff) .
-            self::intToChr(($hiB >>  8) & 0xff) .
-            self::intToChr(($hiB >> 16) & 0xff) .
-            self::intToChr(($hiB >> 24) & 0xff);
+            self::intToChr( ( $int ) & 0xff ) .
+            self::intToChr( ( $int >> 8 ) & 0xff ) .
+            self::intToChr( ( $int >> 16 ) & 0xff ) .
+            self::intToChr( ( $int >> 24 ) & 0xff ) .
+            self::intToChr( $hiB & 0xff ) .
+            self::intToChr( ( $hiB >> 8 ) & 0xff ) .
+            self::intToChr( ( $hiB >> 16 ) & 0xff ) .
+            self::intToChr( ( $hiB >> 24 ) & 0xff );
     }
 
     /**
@@ -763,17 +763,17 @@ 
      * @return int
      * @throws TypeError
      */
-    public static function strlen($str)
+    public static function strlen( $str )
     {
         /* Type checks: */
-        if (!is_string($str)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $str ) ) {
+            throw new TypeError( 'String expected' );
         }
 
-        return (int) (
+        return (int)(
         self::isMbStringOverride()
-            ? mb_strlen($str, '8bit')
-            : strlen($str)
+            ? mb_strlen( $str, '8bit' )
+            : strlen( $str )
         );
     }
 
@@ -786,16 +786,16 @@ 
      * @return array<int, int>
      * @throws TypeError
      */
-    public static function stringToIntArray($string)
+    public static function stringToIntArray( $string )
     {
-        if (!is_string($string)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $string ) ) {
+            throw new TypeError( 'String expected' );
         }
         /**
          * @var array<int, int>
          */
         $values = array_values(
-            unpack('C*', $string)
+            unpack( 'C*', $string )
         );
         return $values;
     }
@@ -813,28 +813,28 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function substr($str, $start = 0, $length = null)
+    public static function substr( $str, $start = 0, $length = null )
     {
         /* Type checks: */
-        if (!is_string($str)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $str ) ) {
+            throw new TypeError( 'String expected' );
         }
 
-        if ($length === 0) {
+        if ( $length === 0 ) {
             return '';
         }
 
-        if (self::isMbStringOverride()) {
-            if (PHP_VERSION_ID < 50400 && $length === null) {
-                $length = self::strlen($str);
+        if ( self::isMbStringOverride() ) {
+            if ( PHP_VERSION_ID < 50400 && $length === null ) {
+                $length = self::strlen( $str );
             }
-            $sub = (string) mb_substr($str, $start, $length, '8bit');
-        } elseif ($length === null) {
-            $sub = (string) substr($str, $start);
+            $sub = (string)mb_substr( $str, $start, $length, '8bit' );
+        } elseif ( $length === null ) {
+            $sub = (string)substr( $str, $start );
         } else {
-            $sub = (string) substr($str, $start, $length);
+            $sub = (string)substr( $str, $start, $length );
         }
-        if ($sub !== '') {
+        if ( $sub !== '' ) {
             return $sub;
         }
         return '';
@@ -851,18 +851,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_16($a, $b)
+    public static function verify_16( $a, $b )
     {
         /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $a ) ) {
+            throw new TypeError( 'String expected' );
         }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $b ) ) {
+            throw new TypeError( 'String expected' );
         }
         return self::hashEquals(
-            self::substr($a, 0, 16),
-            self::substr($b, 0, 16)
+            self::substr( $a, 0, 16 ),
+            self::substr( $b, 0, 16 )
         );
     }
 
@@ -877,18 +877,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function verify_32($a, $b)
+    public static function verify_32( $a, $b )
     {
         /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $a ) ) {
+            throw new TypeError( 'String expected' );
         }
-        if (!is_string($b)) {
-            throw new TypeError('String expected');
+        if ( ! is_string( $b ) ) {
+            throw new TypeError( 'String expected' );
         }
         return self::hashEquals(
-            self::substr($a, 0, 32),
-            self::substr($b, 0, 32)
+            self::substr( $a, 0, 32 ),
+            self::substr( $b, 0, 32 )
         );
     }
 
@@ -902,17 +902,17 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function xorStrings($a, $b)
+    public static function xorStrings( $a, $b )
     {
         /* Type checks: */
-        if (!is_string($a)) {
-            throw new TypeError('Argument 1 must be a string');
+        if ( ! is_string( $a ) ) {
+            throw new TypeError( 'Argument 1 must be a string' );
         }
-        if (!is_string($b)) {
-            throw new TypeError('Argument 2 must be a string');
+        if ( ! is_string( $b ) ) {
+            throw new TypeError( 'Argument 2 must be a string' );
         }
 
-        return (string) ($a ^ $b);
+        return (string)( $a ^ $b );
     }
 
     /**
@@ -929,15 +929,15 @@ 
     {
         static $mbstring = null;
 
-        if ($mbstring === null) {
-            if (!defined('MB_OVERLOAD_STRING')) {
+        if ( $mbstring === null ) {
+            if ( ! defined( 'MB_OVERLOAD_STRING' ) ) {
                 $mbstring = false;
                 return $mbstring;
             }
-            $mbstring = extension_loaded('mbstring')
-                && defined('MB_OVERLOAD_STRING')
+            $mbstring = extension_loaded( 'mbstring' )
+                && defined( 'MB_OVERLOAD_STRING' )
                 &&
-            ((int) (ini_get('mbstring.func_overload')) & 2);
+            ( (int)( ini_get( 'mbstring.func_overload' ) ) & 2 );
             // MB_OVERLOAD_STRING === 2
         }
         /** @var bool $mbstring */

vendor/paragonie/sodium_compat/src/Core/SipHash.php

Spacing +86 added lines, -86 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_SipHash', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_SipHash', false ) ) {
     return;
 }
 
@@ -18,65 +18,65 @@ 
      * @return int[]
      *
      */
-    public static function sipRound(array $v)
+    public static function sipRound( array $v )
     {
         # v0 += v1;
-        list($v[0], $v[1]) = self::add(
-            array($v[0], $v[1]),
-            array($v[2], $v[3])
+        list( $v[ 0 ], $v[ 1 ] ) = self::add(
+            array( $v[ 0 ], $v[ 1 ] ),
+            array( $v[ 2 ], $v[ 3 ] )
         );
 
         #  v1=ROTL(v1,13);
-        list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 13);
+        list( $v[ 2 ], $v[ 3 ] ) = self::rotl_64( (int)$v[ 2 ], (int)$v[ 3 ], 13 );
 
         #  v1 ^= v0;
-        $v[2] = (int) $v[2] ^ (int) $v[0];
-        $v[3] = (int) $v[3] ^ (int) $v[1];
+        $v[ 2 ] = (int)$v[ 2 ] ^ (int)$v[ 0 ];
+        $v[ 3 ] = (int)$v[ 3 ] ^ (int)$v[ 1 ];
 
         #  v0=ROTL(v0,32);
-        list($v[0], $v[1]) = self::rotl_64((int) $v[0], (int) $v[1], 32);
+        list( $v[ 0 ], $v[ 1 ] ) = self::rotl_64( (int)$v[ 0 ], (int)$v[ 1 ], 32 );
 
         # v2 += v3;
-        list($v[4], $v[5]) = self::add(
-            array((int) $v[4], (int) $v[5]),
-            array((int) $v[6], (int) $v[7])
+        list( $v[ 4 ], $v[ 5 ] ) = self::add(
+            array( (int)$v[ 4 ], (int)$v[ 5 ] ),
+            array( (int)$v[ 6 ], (int)$v[ 7 ] )
         );
 
         # v3=ROTL(v3,16);
-        list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 16);
+        list( $v[ 6 ], $v[ 7 ] ) = self::rotl_64( (int)$v[ 6 ], (int)$v[ 7 ], 16 );
 
         #  v3 ^= v2;
-        $v[6] = (int) $v[6] ^ (int) $v[4];
-        $v[7] = (int) $v[7] ^ (int) $v[5];
+        $v[ 6 ] = (int)$v[ 6 ] ^ (int)$v[ 4 ];
+        $v[ 7 ] = (int)$v[ 7 ] ^ (int)$v[ 5 ];
 
         # v0 += v3;
-        list($v[0], $v[1]) = self::add(
-            array((int) $v[0], (int) $v[1]),
-            array((int) $v[6], (int) $v[7])
+        list( $v[ 0 ], $v[ 1 ] ) = self::add(
+            array( (int)$v[ 0 ], (int)$v[ 1 ] ),
+            array( (int)$v[ 6 ], (int)$v[ 7 ] )
         );
 
         # v3=ROTL(v3,21);
-        list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 21);
+        list( $v[ 6 ], $v[ 7 ] ) = self::rotl_64( (int)$v[ 6 ], (int)$v[ 7 ], 21 );
 
         # v3 ^= v0;
-        $v[6] = (int) $v[6] ^ (int) $v[0];
-        $v[7] = (int) $v[7] ^ (int) $v[1];
+        $v[ 6 ] = (int)$v[ 6 ] ^ (int)$v[ 0 ];
+        $v[ 7 ] = (int)$v[ 7 ] ^ (int)$v[ 1 ];
 
         # v2 += v1;
-        list($v[4], $v[5]) = self::add(
-            array((int) $v[4], (int) $v[5]),
-            array((int) $v[2], (int) $v[3])
+        list( $v[ 4 ], $v[ 5 ] ) = self::add(
+            array( (int)$v[ 4 ], (int)$v[ 5 ] ),
+            array( (int)$v[ 2 ], (int)$v[ 3 ] )
         );
 
         # v1=ROTL(v1,17);
-        list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 17);
+        list( $v[ 2 ], $v[ 3 ] ) = self::rotl_64( (int)$v[ 2 ], (int)$v[ 3 ], 17 );
 
         #  v1 ^= v2;;
-        $v[2] = (int) $v[2] ^ (int) $v[4];
-        $v[3] = (int) $v[3] ^ (int) $v[5];
+        $v[ 2 ] = (int)$v[ 2 ] ^ (int)$v[ 4 ];
+        $v[ 3 ] = (int)$v[ 3 ] ^ (int)$v[ 5 ];
 
         # v2=ROTL(v2,32)
-        list($v[4], $v[5]) = self::rotl_64((int) $v[4], (int) $v[5], 32);
+        list( $v[ 4 ], $v[ 5 ] ) = self::rotl_64( (int)$v[ 4 ], (int)$v[ 5 ], 32 );
 
         return $v;
     }
@@ -90,14 +90,14 @@ 
      * @param int[] $b
      * @return array<int, mixed>
      */
-    public static function add(array $a, array $b)
+    public static function add( array $a, array $b )
     {
         /** @var int $x1 */
-        $x1 = $a[1] + $b[1];
+        $x1 = $a[ 1 ] + $b[ 1 ];
         /** @var int $c */
         $c = $x1 >> 32; // Carry if ($a + $b) > 0xffffffff
         /** @var int $x0 */
-        $x0 = $a[0] + $b[0] + $c;
+        $x0 = $a[ 0 ] + $b[ 0 ] + $c;
         return array(
             $x0 & 0xffffffff,
             $x1 & 0xffffffff
@@ -112,33 +112,33 @@ 
      * @param int $c
      * @return array<int, mixed>
      */
-    public static function rotl_64($int0, $int1, $c)
+    public static function rotl_64( $int0, $int1, $c )
     {
         $int0 &= 0xffffffff;
         $int1 &= 0xffffffff;
         $c &= 63;
-        if ($c === 32) {
-            return array($int1, $int0);
+        if ( $c === 32 ) {
+            return array( $int1, $int0 );
         }
-        if ($c > 31) {
+        if ( $c > 31 ) {
             $tmp = $int1;
             $int1 = $int0;
             $int0 = $tmp;
             $c &= 31;
         }
-        if ($c === 0) {
-            return array($int0, $int1);
+        if ( $c === 0 ) {
+            return array( $int0, $int1 );
         }
         return array(
             0xffffffff & (
-                ($int0 << $c)
+                ( $int0 << $c )
                     |
-                ($int1 >> (32 - $c))
+                ( $int1 >> ( 32 - $c ) )
             ),
             0xffffffff & (
-                ($int1 << $c)
+                ( $int1 << $c )
                     |
-                ($int0 >> (32 - $c))
+                ( $int0 >> ( 32 - $c ) )
             ),
         );
     }
@@ -160,9 +160,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sipHash24($in, $key)
+    public static function sipHash24( $in, $key )
     {
-        $inlen = self::strlen($in);
+        $inlen = self::strlen( $in );
 
         # /* "somepseudorandomlygeneratedbytes" */
         # u64 v0 = 0x736f6d6570736575ULL;
@@ -187,10 +187,10 @@ 
         # u64 k0 = LOAD64_LE( k );
         # u64 k1 = LOAD64_LE( k + 8 );
         $k = array(
-            self::load_4(self::substr($key, 4, 4)),
-            self::load_4(self::substr($key, 0, 4)),
-            self::load_4(self::substr($key, 12, 4)),
-            self::load_4(self::substr($key, 8, 4))
+            self::load_4( self::substr( $key, 4, 4 ) ),
+            self::load_4( self::substr( $key, 0, 4 ) ),
+            self::load_4( self::substr( $key, 12, 4 ) ),
+            self::load_4( self::substr( $key, 8, 4 ) )
         );
         // k0 => $k[0], $k[1]
         // k1 => $k[2], $k[3]
@@ -203,41 +203,41 @@ 
         // See docblock for why the 0th index gets the higher bits.
 
         # v3 ^= k1;
-        $v[6] ^= $k[2];
-        $v[7] ^= $k[3];
+        $v[ 6 ] ^= $k[ 2 ];
+        $v[ 7 ] ^= $k[ 3 ];
         # v2 ^= k0;
-        $v[4] ^= $k[0];
-        $v[5] ^= $k[1];
+        $v[ 4 ] ^= $k[ 0 ];
+        $v[ 5 ] ^= $k[ 1 ];
         # v1 ^= k1;
-        $v[2] ^= $k[2];
-        $v[3] ^= $k[3];
+        $v[ 2 ] ^= $k[ 2 ];
+        $v[ 3 ] ^= $k[ 3 ];
         # v0 ^= k0;
-        $v[0] ^= $k[0];
-        $v[1] ^= $k[1];
+        $v[ 0 ] ^= $k[ 0 ];
+        $v[ 1 ] ^= $k[ 1 ];
 
         $left = $inlen;
         # for ( ; in != end; in += 8 )
-        while ($left >= 8) {
+        while ( $left >= 8 ) {
             # m = LOAD64_LE( in );
             $m = array(
-                self::load_4(self::substr($in, 4, 4)),
-                self::load_4(self::substr($in, 0, 4))
+                self::load_4( self::substr( $in, 4, 4 ) ),
+                self::load_4( self::substr( $in, 0, 4 ) )
             );
 
             # v3 ^= m;
-            $v[6] ^= $m[0];
-            $v[7] ^= $m[1];
+            $v[ 6 ] ^= $m[ 0 ];
+            $v[ 7 ] ^= $m[ 1 ];
 
             # SIPROUND;
             # SIPROUND;
-            $v = self::sipRound($v);
-            $v = self::sipRound($v);
+            $v = self::sipRound( $v );
+            $v = self::sipRound( $v );
 
             # v0 ^= m;
-            $v[0] ^= $m[0];
-            $v[1] ^= $m[1];
+            $v[ 0 ] ^= $m[ 0 ];
+            $v[ 1 ] ^= $m[ 1 ];
 
-            $in = self::substr($in, 8);
+            $in = self::substr( $in, 8 );
             $left -= 8;
         }
 
@@ -252,55 +252,55 @@ 
         #     case 1: b |= ( ( u64 )in[ 0] ); break;
         #     case 0: break;
         # }
-        switch ($left) {
+        switch ( $left ) {
             case 7:
-                $b[0] |= self::chrToInt($in[6]) << 16;
+                $b[ 0 ] |= self::chrToInt( $in[ 6 ] ) << 16;
             case 6:
-                $b[0] |= self::chrToInt($in[5]) << 8;
+                $b[ 0 ] |= self::chrToInt( $in[ 5 ] ) << 8;
             case 5:
-                $b[0] |= self::chrToInt($in[4]);
+                $b[ 0 ] |= self::chrToInt( $in[ 4 ] );
             case 4:
-                $b[1] |= self::chrToInt($in[3]) << 24;
+                $b[ 1 ] |= self::chrToInt( $in[ 3 ] ) << 24;
             case 3:
-                $b[1] |= self::chrToInt($in[2]) << 16;
+                $b[ 1 ] |= self::chrToInt( $in[ 2 ] ) << 16;
             case 2:
-                $b[1] |= self::chrToInt($in[1]) << 8;
+                $b[ 1 ] |= self::chrToInt( $in[ 1 ] ) << 8;
             case 1:
-                $b[1] |= self::chrToInt($in[0]);
+                $b[ 1 ] |= self::chrToInt( $in[ 0 ] );
             case 0:
                 break;
         }
         // See docblock for why the 0th index gets the higher bits.
 
         # v3 ^= b;
-        $v[6] ^= $b[0];
-        $v[7] ^= $b[1];
+        $v[ 6 ] ^= $b[ 0 ];
+        $v[ 7 ] ^= $b[ 1 ];
 
         # SIPROUND;
         # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
+        $v = self::sipRound( $v );
+        $v = self::sipRound( $v );
 
         # v0 ^= b;
-        $v[0] ^= $b[0];
-        $v[1] ^= $b[1];
+        $v[ 0 ] ^= $b[ 0 ];
+        $v[ 1 ] ^= $b[ 1 ];
 
         // Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
         # v2 ^= 0xff;
-        $v[5] ^= 0xff;
+        $v[ 5 ] ^= 0xff;
 
         # SIPROUND;
         # SIPROUND;
         # SIPROUND;
         # SIPROUND;
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
-        $v = self::sipRound($v);
+        $v = self::sipRound( $v );
+        $v = self::sipRound( $v );
+        $v = self::sipRound( $v );
+        $v = self::sipRound( $v );
 
         # b = v0 ^ v1 ^ v2 ^ v3;
         # STORE64_LE( out, b );
-        return  self::store32_le($v[1] ^ $v[3] ^ $v[5] ^ $v[7]) .
-            self::store32_le($v[0] ^ $v[2] ^ $v[4] ^ $v[6]);
+        return  self::store32_le( $v[ 1 ] ^ $v[ 3 ] ^ $v[ 5 ] ^ $v[ 7 ] ) .
+            self::store32_le( $v[ 0 ] ^ $v[ 2 ] ^ $v[ 4 ] ^ $v[ 6 ] );
     }
 }

vendor/paragonie/sodium_compat/src/Core/XChaCha20.php

Spacing +23 added lines, -23 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_XChaCha20', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_XChaCha20', false ) ) {
     return;
 }
 
@@ -19,20 +19,20 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function stream($len = 64, $nonce = '', $key = '')
+    public static function stream( $len = 64, $nonce = '', $key = '' )
     {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
+        if ( self::strlen( $nonce ) !== 24 ) {
+            throw new SodiumException( 'Nonce must be 24 bytes long' );
         }
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_Ctx(
                 self::hChaCha20(
-                    self::substr($nonce, 0, 16),
+                    self::substr( $nonce, 0, 16 ),
                     $key
                 ),
-                self::substr($nonce, 16, 8)
+                self::substr( $nonce, 16, 8 )
             ),
-            str_repeat("\x00", $len)
+            str_repeat( "\x00", $len )
         );
     }
 
@@ -46,20 +46,20 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStream($len = 64, $nonce = '', $key = '')
+    public static function ietfStream( $len = 64, $nonce = '', $key = '' )
     {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
+        if ( self::strlen( $nonce ) !== 24 ) {
+            throw new SodiumException( 'Nonce must be 24 bytes long' );
         }
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_IetfCtx(
                 self::hChaCha20(
-                    self::substr($nonce, 0, 16),
+                    self::substr( $nonce, 0, 16 ),
                     $key
                 ),
-                "\x00\x00\x00\x00" . self::substr($nonce, 16, 8)
+                "\x00\x00\x00\x00" . self::substr( $nonce, 16, 8 )
             ),
-            str_repeat("\x00", $len)
+            str_repeat( "\x00", $len )
         );
     }
 
@@ -74,15 +74,15 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function streamXorIc($message, $nonce = '', $key = '', $ic = '')
+    public static function streamXorIc( $message, $nonce = '', $key = '', $ic = '' )
     {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
+        if ( self::strlen( $nonce ) !== 24 ) {
+            throw new SodiumException( 'Nonce must be 24 bytes long' );
         }
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_Ctx(
-                self::hChaCha20(self::substr($nonce, 0, 16), $key),
-                self::substr($nonce, 16, 8),
+                self::hChaCha20( self::substr( $nonce, 0, 16 ), $key ),
+                self::substr( $nonce, 16, 8 ),
                 $ic
             ),
             $message
@@ -100,15 +100,15 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function ietfStreamXorIc($message, $nonce = '', $key = '', $ic = '')
+    public static function ietfStreamXorIc( $message, $nonce = '', $key = '', $ic = '' )
     {
-        if (self::strlen($nonce) !== 24) {
-            throw new SodiumException('Nonce must be 24 bytes long');
+        if ( self::strlen( $nonce ) !== 24 ) {
+            throw new SodiumException( 'Nonce must be 24 bytes long' );
         }
         return self::encryptBytes(
             new ParagonIE_Sodium_Core_ChaCha20_IetfCtx(
-                self::hChaCha20(self::substr($nonce, 0, 16), $key),
-                "\x00\x00\x00\x00" . self::substr($nonce, 16, 8),
+                self::hChaCha20( self::substr( $nonce, 0, 16 ), $key ),
+                "\x00\x00\x00\x00" . self::substr( $nonce, 16, 8 ),
                 $ic
             ),
             $message

vendor/paragonie/sodium_compat/src/Core/X25519.php

Spacing +145 added lines, -145 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_X25519', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_X25519', false ) ) {
     return;
 }
 
@@ -25,57 +25,57 @@ 
         ParagonIE_Sodium_Core_Curve25519_Fe $g,
         $b = 0
     ) {
-        $f0 = (int) $f[0];
-        $f1 = (int) $f[1];
-        $f2 = (int) $f[2];
-        $f3 = (int) $f[3];
-        $f4 = (int) $f[4];
-        $f5 = (int) $f[5];
-        $f6 = (int) $f[6];
-        $f7 = (int) $f[7];
-        $f8 = (int) $f[8];
-        $f9 = (int) $f[9];
-        $g0 = (int) $g[0];
-        $g1 = (int) $g[1];
-        $g2 = (int) $g[2];
-        $g3 = (int) $g[3];
-        $g4 = (int) $g[4];
-        $g5 = (int) $g[5];
-        $g6 = (int) $g[6];
-        $g7 = (int) $g[7];
-        $g8 = (int) $g[8];
-        $g9 = (int) $g[9];
+        $f0 = (int)$f[ 0 ];
+        $f1 = (int)$f[ 1 ];
+        $f2 = (int)$f[ 2 ];
+        $f3 = (int)$f[ 3 ];
+        $f4 = (int)$f[ 4 ];
+        $f5 = (int)$f[ 5 ];
+        $f6 = (int)$f[ 6 ];
+        $f7 = (int)$f[ 7 ];
+        $f8 = (int)$f[ 8 ];
+        $f9 = (int)$f[ 9 ];
+        $g0 = (int)$g[ 0 ];
+        $g1 = (int)$g[ 1 ];
+        $g2 = (int)$g[ 2 ];
+        $g3 = (int)$g[ 3 ];
+        $g4 = (int)$g[ 4 ];
+        $g5 = (int)$g[ 5 ];
+        $g6 = (int)$g[ 6 ];
+        $g7 = (int)$g[ 7 ];
+        $g8 = (int)$g[ 8 ];
+        $g9 = (int)$g[ 9 ];
         $b = -$b;
-        $x0 = ($f0 ^ $g0) & $b;
-        $x1 = ($f1 ^ $g1) & $b;
-        $x2 = ($f2 ^ $g2) & $b;
-        $x3 = ($f3 ^ $g3) & $b;
-        $x4 = ($f4 ^ $g4) & $b;
-        $x5 = ($f5 ^ $g5) & $b;
-        $x6 = ($f6 ^ $g6) & $b;
-        $x7 = ($f7 ^ $g7) & $b;
-        $x8 = ($f8 ^ $g8) & $b;
-        $x9 = ($f9 ^ $g9) & $b;
-        $f[0] = $f0 ^ $x0;
-        $f[1] = $f1 ^ $x1;
-        $f[2] = $f2 ^ $x2;
-        $f[3] = $f3 ^ $x3;
-        $f[4] = $f4 ^ $x4;
-        $f[5] = $f5 ^ $x5;
-        $f[6] = $f6 ^ $x6;
-        $f[7] = $f7 ^ $x7;
-        $f[8] = $f8 ^ $x8;
-        $f[9] = $f9 ^ $x9;
-        $g[0] = $g0 ^ $x0;
-        $g[1] = $g1 ^ $x1;
-        $g[2] = $g2 ^ $x2;
-        $g[3] = $g3 ^ $x3;
-        $g[4] = $g4 ^ $x4;
-        $g[5] = $g5 ^ $x5;
-        $g[6] = $g6 ^ $x6;
-        $g[7] = $g7 ^ $x7;
-        $g[8] = $g8 ^ $x8;
-        $g[9] = $g9 ^ $x9;
+        $x0 = ( $f0 ^ $g0 ) & $b;
+        $x1 = ( $f1 ^ $g1 ) & $b;
+        $x2 = ( $f2 ^ $g2 ) & $b;
+        $x3 = ( $f3 ^ $g3 ) & $b;
+        $x4 = ( $f4 ^ $g4 ) & $b;
+        $x5 = ( $f5 ^ $g5 ) & $b;
+        $x6 = ( $f6 ^ $g6 ) & $b;
+        $x7 = ( $f7 ^ $g7 ) & $b;
+        $x8 = ( $f8 ^ $g8 ) & $b;
+        $x9 = ( $f9 ^ $g9 ) & $b;
+        $f[ 0 ] = $f0 ^ $x0;
+        $f[ 1 ] = $f1 ^ $x1;
+        $f[ 2 ] = $f2 ^ $x2;
+        $f[ 3 ] = $f3 ^ $x3;
+        $f[ 4 ] = $f4 ^ $x4;
+        $f[ 5 ] = $f5 ^ $x5;
+        $f[ 6 ] = $f6 ^ $x6;
+        $f[ 7 ] = $f7 ^ $x7;
+        $f[ 8 ] = $f8 ^ $x8;
+        $f[ 9 ] = $f9 ^ $x9;
+        $g[ 0 ] = $g0 ^ $x0;
+        $g[ 1 ] = $g1 ^ $x1;
+        $g[ 2 ] = $g2 ^ $x2;
+        $g[ 3 ] = $g3 ^ $x3;
+        $g[ 4 ] = $g4 ^ $x4;
+        $g[ 5 ] = $g5 ^ $x5;
+        $g[ 6 ] = $g6 ^ $x6;
+        $g[ 7 ] = $g7 ^ $x7;
+        $g[ 8 ] = $g8 ^ $x8;
+        $g[ 9 ] = $g9 ^ $x9;
     }
 
     /**
@@ -84,67 +84,67 @@ 
      * @param ParagonIE_Sodium_Core_Curve25519_Fe $f
      * @return ParagonIE_Sodium_Core_Curve25519_Fe
      */
-    public static function fe_mul121666(ParagonIE_Sodium_Core_Curve25519_Fe $f)
+    public static function fe_mul121666( ParagonIE_Sodium_Core_Curve25519_Fe $f )
     {
         $h = array(
-            self::mul((int) $f[0], 121666, 17),
-            self::mul((int) $f[1], 121666, 17),
-            self::mul((int) $f[2], 121666, 17),
-            self::mul((int) $f[3], 121666, 17),
-            self::mul((int) $f[4], 121666, 17),
-            self::mul((int) $f[5], 121666, 17),
-            self::mul((int) $f[6], 121666, 17),
-            self::mul((int) $f[7], 121666, 17),
-            self::mul((int) $f[8], 121666, 17),
-            self::mul((int) $f[9], 121666, 17)
+            self::mul( (int)$f[ 0 ], 121666, 17 ),
+            self::mul( (int)$f[ 1 ], 121666, 17 ),
+            self::mul( (int)$f[ 2 ], 121666, 17 ),
+            self::mul( (int)$f[ 3 ], 121666, 17 ),
+            self::mul( (int)$f[ 4 ], 121666, 17 ),
+            self::mul( (int)$f[ 5 ], 121666, 17 ),
+            self::mul( (int)$f[ 6 ], 121666, 17 ),
+            self::mul( (int)$f[ 7 ], 121666, 17 ),
+            self::mul( (int)$f[ 8 ], 121666, 17 ),
+            self::mul( (int)$f[ 9 ], 121666, 17 )
         );
 
         /** @var int $carry9 */
-        $carry9 = ($h[9] + (1 << 24)) >> 25;
-        $h[0] += self::mul($carry9, 19, 5);
-        $h[9] -= $carry9 << 25;
+        $carry9 = ( $h[ 9 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 0 ] += self::mul( $carry9, 19, 5 );
+        $h[ 9 ] -= $carry9 << 25;
         /** @var int $carry1 */
-        $carry1 = ($h[1] + (1 << 24)) >> 25;
-        $h[2] += $carry1;
-        $h[1] -= $carry1 << 25;
+        $carry1 = ( $h[ 1 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 2 ] += $carry1;
+        $h[ 1 ] -= $carry1 << 25;
         /** @var int $carry3 */
-        $carry3 = ($h[3] + (1 << 24)) >> 25;
-        $h[4] += $carry3;
-        $h[3] -= $carry3 << 25;
+        $carry3 = ( $h[ 3 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 4 ] += $carry3;
+        $h[ 3 ] -= $carry3 << 25;
         /** @var int $carry5 */
-        $carry5 = ($h[5] + (1 << 24)) >> 25;
-        $h[6] += $carry5;
-        $h[5] -= $carry5 << 25;
+        $carry5 = ( $h[ 5 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 6 ] += $carry5;
+        $h[ 5 ] -= $carry5 << 25;
         /** @var int $carry7 */
-        $carry7 = ($h[7] + (1 << 24)) >> 25;
-        $h[8] += $carry7;
-        $h[7] -= $carry7 << 25;
+        $carry7 = ( $h[ 7 ] + ( 1 << 24 ) ) >> 25;
+        $h[ 8 ] += $carry7;
+        $h[ 7 ] -= $carry7 << 25;
 
         /** @var int $carry0 */
-        $carry0 = ($h[0] + (1 << 25)) >> 26;
-        $h[1] += $carry0;
-        $h[0] -= $carry0 << 26;
+        $carry0 = ( $h[ 0 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 1 ] += $carry0;
+        $h[ 0 ] -= $carry0 << 26;
         /** @var int $carry2 */
-        $carry2 = ($h[2] + (1 << 25)) >> 26;
-        $h[3] += $carry2;
-        $h[2] -= $carry2 << 26;
+        $carry2 = ( $h[ 2 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 3 ] += $carry2;
+        $h[ 2 ] -= $carry2 << 26;
         /** @var int $carry4 */
-        $carry4 = ($h[4] + (1 << 25)) >> 26;
-        $h[5] += $carry4;
-        $h[4] -= $carry4 << 26;
+        $carry4 = ( $h[ 4 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 5 ] += $carry4;
+        $h[ 4 ] -= $carry4 << 26;
         /** @var int $carry6 */
-        $carry6 = ($h[6] + (1 << 25)) >> 26;
-        $h[7] += $carry6;
-        $h[6] -= $carry6 << 26;
+        $carry6 = ( $h[ 6 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 7 ] += $carry6;
+        $h[ 6 ] -= $carry6 << 26;
         /** @var int $carry8 */
-        $carry8 = ($h[8] + (1 << 25)) >> 26;
-        $h[9] += $carry8;
-        $h[8] -= $carry8 << 26;
+        $carry8 = ( $h[ 8 ] + ( 1 << 25 ) ) >> 26;
+        $h[ 9 ] += $carry8;
+        $h[ 8 ] -= $carry8 << 26;
 
-        foreach ($h as $i => $value) {
-            $h[$i] = (int) $value;
+        foreach ( $h as $i => $value ) {
+            $h[ $i ] = (int)$value;
         }
-        return ParagonIE_Sodium_Core_Curve25519_Fe::fromArray($h);
+        return ParagonIE_Sodium_Core_Curve25519_Fe::fromArray( $h );
     }
 
     /**
@@ -158,27 +158,27 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_scalarmult_curve25519_ref10($n, $p)
+    public static function crypto_scalarmult_curve25519_ref10( $n, $p )
     {
         # for (i = 0;i < 32;++i) e[i] = n[i];
         $e = '' . $n;
         # e[0] &= 248;
-        $e[0] = self::intToChr(
-            self::chrToInt($e[0]) & 248
+        $e[ 0 ] = self::intToChr(
+            self::chrToInt( $e[ 0 ] ) & 248
         );
         # e[31] &= 127;
         # e[31] |= 64;
-        $e[31] = self::intToChr(
-            (self::chrToInt($e[31]) & 127) | 64
+        $e[ 31 ] = self::intToChr(
+            ( self::chrToInt( $e[ 31 ] ) & 127 ) | 64
         );
         # fe_frombytes(x1,p);
-        $x1 = self::fe_frombytes($p);
+        $x1 = self::fe_frombytes( $p );
         # fe_1(x2);
         $x2 = self::fe_1();
         # fe_0(z2);
         $z2 = self::fe_0();
         # fe_copy(x3,x1);
-        $x3 = self::fe_copy($x1);
+        $x3 = self::fe_copy( $x1 );
         # fe_1(z3);
         $z3 = self::fe_1();
 
@@ -187,89 +187,89 @@ 
         $swap = 0;
 
         # for (pos = 254;pos >= 0;--pos) {
-        for ($pos = 254; $pos >= 0; --$pos) {
+        for ( $pos = 254; $pos >= 0; --$pos ) {
             # b = e[pos / 8] >> (pos & 7);
             /** @var int $b */
             $b = self::chrToInt(
-                    $e[(int) floor($pos / 8)]
-                ) >> ($pos & 7);
+                    $e[ (int)floor( $pos / 8 ) ]
+                ) >> ( $pos & 7 );
             # b &= 1;
             $b &= 1;
             # swap ^= b;
             $swap ^= $b;
             # fe_cswap(x2,x3,swap);
-            self::fe_cswap($x2, $x3, $swap);
+            self::fe_cswap( $x2, $x3, $swap );
             # fe_cswap(z2,z3,swap);
-            self::fe_cswap($z2, $z3, $swap);
+            self::fe_cswap( $z2, $z3, $swap );
             # swap = b;
             $swap = $b;
             # fe_sub(tmp0,x3,z3);
-            $tmp0 = self::fe_sub($x3, $z3);
+            $tmp0 = self::fe_sub( $x3, $z3 );
             # fe_sub(tmp1,x2,z2);
-            $tmp1 = self::fe_sub($x2, $z2);
+            $tmp1 = self::fe_sub( $x2, $z2 );
 
             # fe_add(x2,x2,z2);
-            $x2 = self::fe_add($x2, $z2);
+            $x2 = self::fe_add( $x2, $z2 );
 
             # fe_add(z2,x3,z3);
-            $z2 = self::fe_add($x3, $z3);
+            $z2 = self::fe_add( $x3, $z3 );
 
             # fe_mul(z3,tmp0,x2);
-            $z3 = self::fe_mul($tmp0, $x2);
+            $z3 = self::fe_mul( $tmp0, $x2 );
 
             # fe_mul(z2,z2,tmp1);
-            $z2 = self::fe_mul($z2, $tmp1);
+            $z2 = self::fe_mul( $z2, $tmp1 );
 
             # fe_sq(tmp0,tmp1);
-            $tmp0 = self::fe_sq($tmp1);
+            $tmp0 = self::fe_sq( $tmp1 );
 
             # fe_sq(tmp1,x2);
-            $tmp1 = self::fe_sq($x2);
+            $tmp1 = self::fe_sq( $x2 );
 
             # fe_add(x3,z3,z2);
-            $x3 = self::fe_add($z3, $z2);
+            $x3 = self::fe_add( $z3, $z2 );
 
             # fe_sub(z2,z3,z2);
-            $z2 = self::fe_sub($z3, $z2);
+            $z2 = self::fe_sub( $z3, $z2 );
 
             # fe_mul(x2,tmp1,tmp0);
-            $x2 = self::fe_mul($tmp1, $tmp0);
+            $x2 = self::fe_mul( $tmp1, $tmp0 );
 
             # fe_sub(tmp1,tmp1,tmp0);
-            $tmp1 = self::fe_sub($tmp1, $tmp0);
+            $tmp1 = self::fe_sub( $tmp1, $tmp0 );
 
             # fe_sq(z2,z2);
-            $z2 = self::fe_sq($z2);
+            $z2 = self::fe_sq( $z2 );
 
             # fe_mul121666(z3,tmp1);
-            $z3 = self::fe_mul121666($tmp1);
+            $z3 = self::fe_mul121666( $tmp1 );
 
             # fe_sq(x3,x3);
-            $x3 = self::fe_sq($x3);
+            $x3 = self::fe_sq( $x3 );
 
             # fe_add(tmp0,tmp0,z3);
-            $tmp0 = self::fe_add($tmp0, $z3);
+            $tmp0 = self::fe_add( $tmp0, $z3 );
 
             # fe_mul(z3,x1,z2);
-            $z3 = self::fe_mul($x1, $z2);
+            $z3 = self::fe_mul( $x1, $z2 );
 
             # fe_mul(z2,tmp1,tmp0);
-            $z2 = self::fe_mul($tmp1, $tmp0);
+            $z2 = self::fe_mul( $tmp1, $tmp0 );
         }
 
         # fe_cswap(x2,x3,swap);
-        self::fe_cswap($x2, $x3, $swap);
+        self::fe_cswap( $x2, $x3, $swap );
 
         # fe_cswap(z2,z3,swap);
-        self::fe_cswap($z2, $z3, $swap);
+        self::fe_cswap( $z2, $z3, $swap );
 
         # fe_invert(z2,z2);
-        $z2 = self::fe_invert($z2);
+        $z2 = self::fe_invert( $z2 );
 
         # fe_mul(x2,x2,z2);
-        $x2 = self::fe_mul($x2, $z2);
+        $x2 = self::fe_mul( $x2, $z2 );
         # fe_tobytes(q,x2);
-        return self::fe_tobytes($x2);
+        return self::fe_tobytes( $x2 );
     }
 
     /**
@@ -283,10 +283,10 @@ 
         ParagonIE_Sodium_Core_Curve25519_Fe $edwardsY,
         ParagonIE_Sodium_Core_Curve25519_Fe $edwardsZ
     ) {
-        $tempX = self::fe_add($edwardsZ, $edwardsY);
-        $tempZ = self::fe_sub($edwardsZ, $edwardsY);
-        $tempZ = self::fe_invert($tempZ);
-        return self::fe_mul($tempX, $tempZ);
+        $tempX = self::fe_add( $edwardsZ, $edwardsY );
+        $tempZ = self::fe_sub( $edwardsZ, $edwardsY );
+        $tempZ = self::fe_invert( $tempZ );
+        return self::fe_mul( $tempX, $tempZ );
     }
 
     /**
@@ -297,31 +297,31 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_scalarmult_curve25519_ref10_base($n)
+    public static function crypto_scalarmult_curve25519_ref10_base( $n )
     {
         # for (i = 0;i < 32;++i) e[i] = n[i];
         $e = '' . $n;
 
         # e[0] &= 248;
-        $e[0] = self::intToChr(
-            self::chrToInt($e[0]) & 248
+        $e[ 0 ] = self::intToChr(
+            self::chrToInt( $e[ 0 ] ) & 248
         );
 
         # e[31] &= 127;
         # e[31] |= 64;
-        $e[31] = self::intToChr(
-            (self::chrToInt($e[31]) & 127) | 64
+        $e[ 31 ] = self::intToChr(
+            ( self::chrToInt( $e[ 31 ] ) & 127 ) | 64
         );
 
-        $A = self::ge_scalarmult_base($e);
+        $A = self::ge_scalarmult_base( $e );
         if (
-            !($A->Y instanceof ParagonIE_Sodium_Core_Curve25519_Fe)
+            ! ( $A->Y instanceof ParagonIE_Sodium_Core_Curve25519_Fe )
                 ||
-            !($A->Z instanceof ParagonIE_Sodium_Core_Curve25519_Fe)
+            ! ( $A->Z instanceof ParagonIE_Sodium_Core_Curve25519_Fe )
         ) {
-            throw new TypeError('Null points encountered');
+            throw new TypeError( 'Null points encountered' );
         }
-        $pk = self::edwards_to_montgomery($A->Y, $A->Z);
-        return self::fe_tobytes($pk);
+        $pk = self::edwards_to_montgomery( $A->Y, $A->Z );
+        return self::fe_tobytes( $pk );
     }
 }

vendor/paragonie/sodium_compat/src/Core/Poly1305.php

Spacing +10 added lines, -10 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Core_Poly1305', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Core_Poly1305', false ) ) {
     return;
 }
 
@@ -20,18 +20,18 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function onetimeauth($m, $key)
+    public static function onetimeauth( $m, $key )
     {
-        if (self::strlen($key) < 32) {
+        if ( self::strlen( $key ) < 32 ) {
             throw new InvalidArgumentException(
                 'Key must be 32 bytes long.'
             );
         }
         $state = new ParagonIE_Sodium_Core_Poly1305_State(
-            self::substr($key, 0, 32)
+            self::substr( $key, 0, 32 )
         );
         return $state
-            ->update($m)
+            ->update( $m )
             ->finish();
     }
 
@@ -45,19 +45,19 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function onetimeauth_verify($mac, $m, $key)
+    public static function onetimeauth_verify( $mac, $m, $key )
     {
-        if (self::strlen($key) < 32) {
+        if ( self::strlen( $key ) < 32 ) {
             throw new InvalidArgumentException(
                 'Key must be 32 bytes long.'
             );
         }
         $state = new ParagonIE_Sodium_Core_Poly1305_State(
-            self::substr($key, 0, 32)
+            self::substr( $key, 0, 32 )
         );
         $calc = $state
-            ->update($m)
+            ->update( $m )
             ->finish();
-        return self::verify_16($calc, $mac);
+        return self::verify_16( $calc, $mac );
     }
 }