gravityview / GravityView

vendor/paragonie/sodium_compat/lib/php72compat.php

Indentation +1170 added lines, -1170 removed lines

@@ -10,1360 +10,1360 @@
  * ParagonIE_Sodium_Compat method or class constant, respectively.
  */
 foreach (array(
-    'BASE64_VARIANT_ORIGINAL',
-    'BASE64_VARIANT_ORIGINAL_NO_PADDING',
-    'BASE64_VARIANT_URLSAFE',
-    'BASE64_VARIANT_URLSAFE_NO_PADDING',
-    'CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES',
-    'CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES',
-    'CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES',
-    'CRYPTO_AEAD_CHACHA20POLY1305_ABYTES',
-    'CRYPTO_AEAD_AES256GCM_KEYBYTES',
-    'CRYPTO_AEAD_AES256GCM_NSECBYTES',
-    'CRYPTO_AEAD_AES256GCM_NPUBBYTES',
-    'CRYPTO_AEAD_AES256GCM_ABYTES',
-    'CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES',
-    'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES',
-    'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES',
-    'CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES',
-    'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES',
-    'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES',
-    'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES',
-    'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES',
-    'CRYPTO_AUTH_BYTES',
-    'CRYPTO_AUTH_KEYBYTES',
-    'CRYPTO_BOX_SEALBYTES',
-    'CRYPTO_BOX_SECRETKEYBYTES',
-    'CRYPTO_BOX_PUBLICKEYBYTES',
-    'CRYPTO_BOX_KEYPAIRBYTES',
-    'CRYPTO_BOX_MACBYTES',
-    'CRYPTO_BOX_NONCEBYTES',
-    'CRYPTO_BOX_SEEDBYTES',
-    'CRYPTO_KDF_BYTES_MIN',
-    'CRYPTO_KDF_BYTES_MAX',
-    'CRYPTO_KDF_CONTEXTBYTES',
-    'CRYPTO_KDF_KEYBYTES',
-    'CRYPTO_KX_BYTES',
-    'CRYPTO_KX_KEYPAIRBYTES',
-    'CRYPTO_KX_PRIMITIVE',
-    'CRYPTO_KX_SEEDBYTES',
-    'CRYPTO_KX_PUBLICKEYBYTES',
-    'CRYPTO_KX_SECRETKEYBYTES',
-    'CRYPTO_KX_SESSIONKEYBYTES',
-    'CRYPTO_GENERICHASH_BYTES',
-    'CRYPTO_GENERICHASH_BYTES_MIN',
-    'CRYPTO_GENERICHASH_BYTES_MAX',
-    'CRYPTO_GENERICHASH_KEYBYTES',
-    'CRYPTO_GENERICHASH_KEYBYTES_MIN',
-    'CRYPTO_GENERICHASH_KEYBYTES_MAX',
-    'CRYPTO_PWHASH_SALTBYTES',
-    'CRYPTO_PWHASH_STRPREFIX',
-    'CRYPTO_PWHASH_ALG_ARGON2I13',
-    'CRYPTO_PWHASH_ALG_ARGON2ID13',
-    'CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE',
-    'CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE',
-    'CRYPTO_PWHASH_MEMLIMIT_MODERATE',
-    'CRYPTO_PWHASH_OPSLIMIT_MODERATE',
-    'CRYPTO_PWHASH_MEMLIMIT_SENSITIVE',
-    'CRYPTO_PWHASH_OPSLIMIT_SENSITIVE',
-    'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES',
-    'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX',
-    'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE',
-    'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE',
-    'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE',
-    'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE',
-    'CRYPTO_SCALARMULT_BYTES',
-    'CRYPTO_SCALARMULT_SCALARBYTES',
-    'CRYPTO_SHORTHASH_BYTES',
-    'CRYPTO_SHORTHASH_KEYBYTES',
-    'CRYPTO_SECRETBOX_KEYBYTES',
-    'CRYPTO_SECRETBOX_MACBYTES',
-    'CRYPTO_SECRETBOX_NONCEBYTES',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL',
-    'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX',
-    'CRYPTO_SIGN_BYTES',
-    'CRYPTO_SIGN_SEEDBYTES',
-    'CRYPTO_SIGN_PUBLICKEYBYTES',
-    'CRYPTO_SIGN_SECRETKEYBYTES',
-    'CRYPTO_SIGN_KEYPAIRBYTES',
-    'CRYPTO_STREAM_KEYBYTES',
-    'CRYPTO_STREAM_NONCEBYTES',
-    'CRYPTO_STREAM_XCHACHA20_KEYBYTES',
-    'CRYPTO_STREAM_XCHACHA20_NONCEBYTES',
-    'LIBRARY_MAJOR_VERSION',
-    'LIBRARY_MINOR_VERSION',
-    'LIBRARY_VERSION_MAJOR',
-    'LIBRARY_VERSION_MINOR',
-    'VERSION_STRING'
-    ) as $constant
+	'BASE64_VARIANT_ORIGINAL',
+	'BASE64_VARIANT_ORIGINAL_NO_PADDING',
+	'BASE64_VARIANT_URLSAFE',
+	'BASE64_VARIANT_URLSAFE_NO_PADDING',
+	'CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES',
+	'CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES',
+	'CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES',
+	'CRYPTO_AEAD_CHACHA20POLY1305_ABYTES',
+	'CRYPTO_AEAD_AES256GCM_KEYBYTES',
+	'CRYPTO_AEAD_AES256GCM_NSECBYTES',
+	'CRYPTO_AEAD_AES256GCM_NPUBBYTES',
+	'CRYPTO_AEAD_AES256GCM_ABYTES',
+	'CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES',
+	'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES',
+	'CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES',
+	'CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES',
+	'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES',
+	'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES',
+	'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES',
+	'CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES',
+	'CRYPTO_AUTH_BYTES',
+	'CRYPTO_AUTH_KEYBYTES',
+	'CRYPTO_BOX_SEALBYTES',
+	'CRYPTO_BOX_SECRETKEYBYTES',
+	'CRYPTO_BOX_PUBLICKEYBYTES',
+	'CRYPTO_BOX_KEYPAIRBYTES',
+	'CRYPTO_BOX_MACBYTES',
+	'CRYPTO_BOX_NONCEBYTES',
+	'CRYPTO_BOX_SEEDBYTES',
+	'CRYPTO_KDF_BYTES_MIN',
+	'CRYPTO_KDF_BYTES_MAX',
+	'CRYPTO_KDF_CONTEXTBYTES',
+	'CRYPTO_KDF_KEYBYTES',
+	'CRYPTO_KX_BYTES',
+	'CRYPTO_KX_KEYPAIRBYTES',
+	'CRYPTO_KX_PRIMITIVE',
+	'CRYPTO_KX_SEEDBYTES',
+	'CRYPTO_KX_PUBLICKEYBYTES',
+	'CRYPTO_KX_SECRETKEYBYTES',
+	'CRYPTO_KX_SESSIONKEYBYTES',
+	'CRYPTO_GENERICHASH_BYTES',
+	'CRYPTO_GENERICHASH_BYTES_MIN',
+	'CRYPTO_GENERICHASH_BYTES_MAX',
+	'CRYPTO_GENERICHASH_KEYBYTES',
+	'CRYPTO_GENERICHASH_KEYBYTES_MIN',
+	'CRYPTO_GENERICHASH_KEYBYTES_MAX',
+	'CRYPTO_PWHASH_SALTBYTES',
+	'CRYPTO_PWHASH_STRPREFIX',
+	'CRYPTO_PWHASH_ALG_ARGON2I13',
+	'CRYPTO_PWHASH_ALG_ARGON2ID13',
+	'CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE',
+	'CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE',
+	'CRYPTO_PWHASH_MEMLIMIT_MODERATE',
+	'CRYPTO_PWHASH_OPSLIMIT_MODERATE',
+	'CRYPTO_PWHASH_MEMLIMIT_SENSITIVE',
+	'CRYPTO_PWHASH_OPSLIMIT_SENSITIVE',
+	'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES',
+	'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX',
+	'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE',
+	'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE',
+	'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE',
+	'CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE',
+	'CRYPTO_SCALARMULT_BYTES',
+	'CRYPTO_SCALARMULT_SCALARBYTES',
+	'CRYPTO_SHORTHASH_BYTES',
+	'CRYPTO_SHORTHASH_KEYBYTES',
+	'CRYPTO_SECRETBOX_KEYBYTES',
+	'CRYPTO_SECRETBOX_MACBYTES',
+	'CRYPTO_SECRETBOX_NONCEBYTES',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL',
+	'CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX',
+	'CRYPTO_SIGN_BYTES',
+	'CRYPTO_SIGN_SEEDBYTES',
+	'CRYPTO_SIGN_PUBLICKEYBYTES',
+	'CRYPTO_SIGN_SECRETKEYBYTES',
+	'CRYPTO_SIGN_KEYPAIRBYTES',
+	'CRYPTO_STREAM_KEYBYTES',
+	'CRYPTO_STREAM_NONCEBYTES',
+	'CRYPTO_STREAM_XCHACHA20_KEYBYTES',
+	'CRYPTO_STREAM_XCHACHA20_NONCEBYTES',
+	'LIBRARY_MAJOR_VERSION',
+	'LIBRARY_MINOR_VERSION',
+	'LIBRARY_VERSION_MAJOR',
+	'LIBRARY_VERSION_MINOR',
+	'VERSION_STRING'
+	) as $constant
 ) {
-    if (!defined("SODIUM_$constant") && defined("ParagonIE_Sodium_Compat::$constant")) {
-        define("SODIUM_$constant", constant("ParagonIE_Sodium_Compat::$constant"));
-    }
+	if (!defined("SODIUM_$constant") && defined("ParagonIE_Sodium_Compat::$constant")) {
+		define("SODIUM_$constant", constant("ParagonIE_Sodium_Compat::$constant"));
+	}
 }
 if (!is_callable('sodium_add')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::add()
-     * @param string $val
-     * @param string $addv
-     * @return void
-     * @throws SodiumException
-     */
-    function sodium_add(&$val, $addv)
-    {
-        ParagonIE_Sodium_Compat::add($val, $addv);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::add()
+	 * @param string $val
+	 * @param string $addv
+	 * @return void
+	 * @throws SodiumException
+	 */
+	function sodium_add(&$val, $addv)
+	{
+		ParagonIE_Sodium_Compat::add($val, $addv);
+	}
 }
 if (!is_callable('sodium_base642bin')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::bin2base64()
-     * @param string $string
-     * @param int $variant
-     * @param string $ignore
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_base642bin($string, $variant, $ignore ='')
-    {
-        return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::bin2base64()
+	 * @param string $string
+	 * @param int $variant
+	 * @param string $ignore
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_base642bin($string, $variant, $ignore ='')
+	{
+		return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
+	}
 }
 if (!is_callable('sodium_bin2base64')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::bin2base64()
-     * @param string $string
-     * @param int $variant
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_bin2base64($string, $variant)
-    {
-        return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::bin2base64()
+	 * @param string $string
+	 * @param int $variant
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_bin2base64($string, $variant)
+	{
+		return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
+	}
 }
 if (!is_callable('sodium_bin2hex')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::hex2bin()
-     * @param string $string
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_bin2hex($string)
-    {
-        return ParagonIE_Sodium_Compat::bin2hex($string);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::hex2bin()
+	 * @param string $string
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_bin2hex($string)
+	{
+		return ParagonIE_Sodium_Compat::bin2hex($string);
+	}
 }
 if (!is_callable('sodium_compare')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::compare()
-     * @param string $a
-     * @param string $b
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_compare($a, $b)
-    {
-        return ParagonIE_Sodium_Compat::compare($a, $b);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::compare()
+	 * @param string $a
+	 * @param string $b
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_compare($a, $b)
+	{
+		return ParagonIE_Sodium_Compat::compare($a, $b);
+	}
 }
 if (!is_callable('sodium_crypto_aead_aes256gcm_decrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string|bool
-     */
-    function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
-        } catch (Error $ex) {
-            return false;
-        } catch (Exception $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string|bool
+	 */
+	function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
+		} catch (Error $ex) {
+			return false;
+		} catch (Exception $ex) {
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
+	}
 }
 if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
-     * @return bool
-     */
-    function sodium_crypto_aead_aes256gcm_is_available()
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
+	 * @return bool
+	 */
+	function sodium_crypto_aead_aes256gcm_is_available()
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
+	}
 }
 if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string|bool
-     */
-    function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
-        } catch (Error $ex) {
-            return false;
-        } catch (Exception $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string|bool
+	 */
+	function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
+		} catch (Error $ex) {
+			return false;
+		} catch (Exception $ex) {
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
+	}
 }
 if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_aead_chacha20poly1305_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_aead_chacha20poly1305_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string|bool
-     */
-    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
-        } catch (Error $ex) {
-            return false;
-        } catch (Exception $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string|bool
+	 */
+	function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
+		} catch (Error $ex) {
+			return false;
+		} catch (Exception $ex) {
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
+	}
 }
 if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string|bool
-     */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
-        } catch (Error $ex) {
-            return false;
-        } catch (Exception $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string|bool
+	 */
+	function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
+		} catch (Error $ex) {
+			return false;
+		} catch (Exception $ex) {
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
-     * @param string $message
-     * @param string $assocData
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
+	 * @param string $message
+	 * @param string $assocData
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
+	}
 }
 if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_auth')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_auth()
-     * @param string $message
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_auth($message, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_auth()
+	 * @param string $message
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_auth($message, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
+	}
 }
 if (!is_callable('sodium_crypto_auth_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_auth_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_auth_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_auth_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_auth_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_auth_verify')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
-     * @param string $mac
-     * @param string $message
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_auth_verify($mac, $message, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
+	 * @param string $mac
+	 * @param string $message
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_auth_verify($mac, $message, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
+	}
 }
 if (!is_callable('sodium_crypto_box')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box()
-     * @param string $message
-     * @param string $nonce
-     * @param string $kp
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box($message, $nonce, $kp)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $kp
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box($message, $nonce, $kp)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
+	}
 }
 if (!is_callable('sodium_crypto_box_keypair')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box_keypair()
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_keypair();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box_keypair()
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_keypair();
+	}
 }
 if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
-     * @param string $sk
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
+	 * @param string $sk
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
+	}
 }
 if (!is_callable('sodium_crypto_box_open')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_open()
-     * @param string $message
-     * @param string $nonce
-     * @param string $kp
-     * @return string|bool
-     */
-    function sodium_crypto_box_open($message, $nonce, $kp)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
-        } catch (Error $ex) {
-            return false;
-        } catch (Exception $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_open()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $kp
+	 * @return string|bool
+	 */
+	function sodium_crypto_box_open($message, $nonce, $kp)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
+		} catch (Error $ex) {
+			return false;
+		} catch (Exception $ex) {
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_box_publickey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
-     * @param string $keypair
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box_publickey($keypair)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
+	 * @param string $keypair
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box_publickey($keypair)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
+	}
 }
 if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box_publickey_from_secretkey($sk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box_publickey_from_secretkey($sk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
+	}
 }
 if (!is_callable('sodium_crypto_box_seal')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_seal()
-     * @param string $message
-     * @param string $publicKey
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box_seal($message, $publicKey)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_seal()
+	 * @param string $message
+	 * @param string $publicKey
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box_seal($message, $publicKey)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
+	}
 }
 if (!is_callable('sodium_crypto_box_seal_open')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
-     * @param string $message
-     * @param string $kp
-     * @return string|bool
-     * @throws SodiumException
-     */
-    function sodium_crypto_box_seal_open($message, $kp)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
-        } catch (SodiumException $ex) {
-            if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') {
-                throw $ex;
-            }
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
+	 * @param string $message
+	 * @param string $kp
+	 * @return string|bool
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_box_seal_open($message, $kp)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
+		} catch (SodiumException $ex) {
+			if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') {
+				throw $ex;
+			}
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_box_secretkey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
-     * @param string $keypair
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box_secretkey($keypair)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
+	 * @param string $keypair
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box_secretkey($keypair)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
+	}
 }
 if (!is_callable('sodium_crypto_box_seed_keypair')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair()
-     * @param string $seed
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_box_seed_keypair($seed)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair()
+	 * @param string $seed
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_box_seed_keypair($seed)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
+	}
 }
 if (!is_callable('sodium_crypto_generichash')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_generichash()
-     * @param string $message
-     * @param string|null $key
-     * @param int $outLen
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_generichash($message, $key = null, $outLen = 32)
-    {
-        return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_generichash()
+	 * @param string $message
+	 * @param string|null $key
+	 * @param int $outLen
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_generichash($message, $key = null, $outLen = 32)
+	{
+		return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
+	}
 }
 if (!is_callable('sodium_crypto_generichash_final')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
-     * @param string|null $ctx
-     * @param int $outputLength
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_generichash_final(&$ctx, $outputLength = 32)
-    {
-        return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
+	 * @param string|null $ctx
+	 * @param int $outputLength
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_generichash_final(&$ctx, $outputLength = 32)
+	{
+		return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
+	}
 }
 if (!is_callable('sodium_crypto_generichash_init')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
-     * @param string|null $key
-     * @param int $outLen
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_generichash_init($key = null, $outLen = 32)
-    {
-        return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
+	 * @param string|null $key
+	 * @param int $outLen
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_generichash_init($key = null, $outLen = 32)
+	{
+		return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
+	}
 }
 if (!is_callable('sodium_crypto_generichash_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_generichash_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_generichash_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_generichash_update')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
-     * @param string|null $ctx
-     * @param string $message
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_generichash_update(&$ctx, $message = '')
-    {
-        ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
+	 * @param string|null $ctx
+	 * @param string $message
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_generichash_update(&$ctx, $message = '')
+	{
+		ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
+	}
 }
 if (!is_callable('sodium_crypto_kdf_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_kdf_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_kdf_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_kdf_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_kdf_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_kdf_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_kdf_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_kdf_derive_from_key')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key()
-     * @param int $subkey_len
-     * @param int $subkey_id
-     * @param string $context
-     * @param string $key
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
-            $subkey_len,
-            $subkey_id,
-            $context,
-            $key
-        );
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key()
+	 * @param int $subkey_len
+	 * @param int $subkey_id
+	 * @param string $context
+	 * @param string $key
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
+			$subkey_len,
+			$subkey_id,
+			$context,
+			$key
+		);
+	}
 }
 if (!is_callable('sodium_crypto_kx')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_kx()
-     * @param string $my_secret
-     * @param string $their_public
-     * @param string $client_public
-     * @param string $server_public
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx(
-            $my_secret,
-            $their_public,
-            $client_public,
-            $server_public
-        );
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_kx()
+	 * @param string $my_secret
+	 * @param string $their_public
+	 * @param string $client_public
+	 * @param string $server_public
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx(
+			$my_secret,
+			$their_public,
+			$client_public,
+			$server_public
+		);
+	}
 }
 if (!is_callable('sodium_crypto_kx_seed_keypair')) {
-    /**
-     * @param string $seed
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_kx_seed_keypair($seed)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
-    }
+	/**
+	 * @param string $seed
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_kx_seed_keypair($seed)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
+	}
 }
 if (!is_callable('sodium_crypto_kx_keypair')) {
-    /**
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_kx_keypair()
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx_keypair();
-    }
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_kx_keypair()
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx_keypair();
+	}
 }
 if (!is_callable('sodium_crypto_kx_client_session_keys')) {
-    /**
-     * @param string $keypair
-     * @param string $serverPublicKey
-     * @return array{0: string, 1: string}
-     * @throws SodiumException
-     */
-    function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($keypair, $serverPublicKey);
-    }
+	/**
+	 * @param string $keypair
+	 * @param string $serverPublicKey
+	 * @return array{0: string, 1: string}
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($keypair, $serverPublicKey);
+	}
 }
 if (!is_callable('sodium_crypto_kx_server_session_keys')) {
-    /**
-     * @param string $keypair
-     * @param string $clientPublicKey
-     * @return array{0: string, 1: string}
-     * @throws SodiumException
-     */
-    function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($keypair, $clientPublicKey);
-    }
+	/**
+	 * @param string $keypair
+	 * @param string $clientPublicKey
+	 * @return array{0: string, 1: string}
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($keypair, $clientPublicKey);
+	}
 }
 if (!is_callable('sodium_crypto_kx_secretkey')) {
-    /**
-     * @param string $keypair
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_kx_secretkey($keypair)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx_secretkey($keypair);
-    }
+	/**
+	 * @param string $keypair
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_kx_secretkey($keypair)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx_secretkey($keypair);
+	}
 }
 if (!is_callable('sodium_crypto_kx_publickey')) {
-    /**
-     * @param string $keypair
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_kx_publickey($keypair)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx_publickey($keypair);
-    }
+	/**
+	 * @param string $keypair
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_kx_publickey($keypair)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx_publickey($keypair);
+	}
 }
 if (!is_callable('sodium_crypto_pwhash')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_pwhash()
-     * @param int $outlen
-     * @param string $passwd
-     * @param string $salt
-     * @param int $opslimit
-     * @param int $memlimit
-     * @param int|null $algo
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash()
+	 * @param int $outlen
+	 * @param string $passwd
+	 * @param string $salt
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @param int|null $algo
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo);
+	}
 }
 if (!is_callable('sodium_crypto_pwhash_str')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
-     * @param string $passwd
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
+	 * @param string $passwd
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
+	}
 }
 if (!is_callable('sodium_crypto_pwhash_str_needs_rehash')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash()
-     * @param string $hash
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return bool
-     *
-     * @throws SodiumException
-     */
-    function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash()
+	 * @param string $hash
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return bool
+	 *
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
+	}
 }
 if (!is_callable('sodium_crypto_pwhash_str_verify')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
-     * @param string $passwd
-     * @param string $hash
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_pwhash_str_verify($passwd, $hash)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
+	 * @param string $passwd
+	 * @param string $hash
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_pwhash_str_verify($passwd, $hash)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
+	}
 }
 if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
-     * @param int $outlen
-     * @param string $passwd
-     * @param string $salt
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
+	 * @param int $outlen
+	 * @param string $passwd
+	 * @param string $salt
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
+	}
 }
 if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
-     * @param string $passwd
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
+	 * @param string $passwd
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
+	}
 }
 if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str_verify')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
-     * @param string $passwd
-     * @param string $hash
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
+	 * @param string $passwd
+	 * @param string $hash
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
+	}
 }
 if (!is_callable('sodium_crypto_scalarmult')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
-     * @param string $n
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_scalarmult($n, $p)
-    {
-        return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
+	 * @param string $n
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_scalarmult($n, $p)
+	{
+		return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
+	}
 }
 if (!is_callable('sodium_crypto_scalarmult_base')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
-     * @param string $n
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_scalarmult_base($n)
-    {
-        return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
+	 * @param string $n
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_scalarmult_base($n)
+	{
+		return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
+	}
 }
 if (!is_callable('sodium_crypto_secretbox')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_secretbox()
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_secretbox($message, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_secretbox()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_secretbox($message, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
+	}
 }
 if (!is_callable('sodium_crypto_secretbox_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_secretbox_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_secretbox_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_secretbox_open')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @return string|bool
-     */
-    function sodium_crypto_secretbox_open($message, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
-        } catch (Error $ex) {
-            return false;
-        } catch (Exception $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string|bool
+	 */
+	function sodium_crypto_secretbox_open($message, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
+		} catch (Error $ex) {
+			return false;
+		} catch (Exception $ex) {
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_push')) {
-    /**
-     * @param string $key
-     * @return array<int, string>
-     * @throws SodiumException
-     */
-    function sodium_crypto_secretstream_xchacha20poly1305_init_push($key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
-    }
+	/**
+	 * @param string $key
+	 * @return array<int, string>
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_secretstream_xchacha20poly1305_init_push($key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
+	}
 }
 if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_push')) {
-    /**
-     * @param string $state
-     * @param string $msg
-     * @param string $aad
-     * @param int $tag
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
-    {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push($state, $msg, $aad, $tag);
-    }
+	/**
+	 * @param string $state
+	 * @param string $msg
+	 * @param string $aad
+	 * @param int $tag
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push($state, $msg, $aad, $tag);
+	}
 }
 if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_pull')) {
-    /**
-     * @param string $header
-     * @param string $key
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
-    }
+	/**
+	 * @param string $header
+	 * @param string $key
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
+	}
 }
 if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_pull')) {
-    /**
-     * @param string $state
-     * @param string $cipher
-     * @param string $aad
-     * @return bool|array{0: string, 1: int}
-     * @throws SodiumException
-     */
-    function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
-    {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull($state, $cipher, $aad);
-    }
+	/**
+	 * @param string $state
+	 * @param string $cipher
+	 * @param string $aad
+	 * @return bool|array{0: string, 1: int}
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull($state, $cipher, $aad);
+	}
 }
 if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_rekey')) {
-    /**
-     * @param string $state
-     * @return void
-     * @throws SodiumException
-     */
-    function sodium_crypto_secretstream_xchacha20poly1305_rekey(&$state)
-    {
-        ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
-    }
+	/**
+	 * @param string $state
+	 * @return void
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_secretstream_xchacha20poly1305_rekey(&$state)
+	{
+		ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
+	}
 }
 if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_keygen')) {
-    /**
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_secretstream_xchacha20poly1305_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_keygen();
-    }
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_secretstream_xchacha20poly1305_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_shorthash')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_shorthash()
-     * @param string $message
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_shorthash($message, $key = '')
-    {
-        return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_shorthash()
+	 * @param string $message
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_shorthash($message, $key = '')
+	{
+		return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
+	}
 }
 if (!is_callable('sodium_crypto_shorthash_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_shorthash_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_shorthash_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_shorthash_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_shorthash_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_sign')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign()
-     * @param string $message
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign($message, $sk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign()
+	 * @param string $message
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign($message, $sk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
+	}
 }
 if (!is_callable('sodium_crypto_sign_detached')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
-     * @param string $message
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_detached($message, $sk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
+	 * @param string $message
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_detached($message, $sk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
+	}
 }
 if (!is_callable('sodium_crypto_sign_keypair_from_secretkey_and_publickey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey()
-     * @param string $sk
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey()
+	 * @param string $sk
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
+	}
 }
 if (!is_callable('sodium_crypto_sign_keypair')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_keypair()
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_keypair();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_keypair()
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_keypair();
+	}
 }
 if (!is_callable('sodium_crypto_sign_open')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_open()
-     * @param string $signedMessage
-     * @param string $pk
-     * @return string|bool
-     */
-    function sodium_crypto_sign_open($signedMessage, $pk)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
-        } catch (Error $ex) {
-            return false;
-        } catch (Exception $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_open()
+	 * @param string $signedMessage
+	 * @param string $pk
+	 * @return string|bool
+	 */
+	function sodium_crypto_sign_open($signedMessage, $pk)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
+		} catch (Error $ex) {
+			return false;
+		} catch (Exception $ex) {
+			return false;
+		}
+	}
 }
 if (!is_callable('sodium_crypto_sign_publickey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
-     * @param string $keypair
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_publickey($keypair)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
+	 * @param string $keypair
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_publickey($keypair)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
+	}
 }
 if (!is_callable('sodium_crypto_sign_publickey_from_secretkey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_publickey_from_secretkey($sk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_publickey_from_secretkey($sk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
+	}
 }
 if (!is_callable('sodium_crypto_sign_secretkey')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
-     * @param string $keypair
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_secretkey($keypair)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
+	 * @param string $keypair
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_secretkey($keypair)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
+	}
 }
 if (!is_callable('sodium_crypto_sign_seed_keypair')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
-     * @param string $seed
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_seed_keypair($seed)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
+	 * @param string $seed
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_seed_keypair($seed)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
+	}
 }
 if (!is_callable('sodium_crypto_sign_verify_detached')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
-     * @param string $signature
-     * @param string $message
-     * @param string $pk
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_verify_detached($signature, $message, $pk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
+	 * @param string $signature
+	 * @param string $message
+	 * @param string $pk
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_verify_detached($signature, $message, $pk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
+	}
 }
 if (!is_callable('sodium_crypto_sign_ed25519_pk_to_curve25519')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_ed25519_pk_to_curve25519($pk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_ed25519_pk_to_curve25519($pk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
+	}
 }
 if (!is_callable('sodium_crypto_sign_ed25519_sk_to_curve25519')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_sign_ed25519_sk_to_curve25519($sk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_sign_ed25519_sk_to_curve25519($sk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
+	}
 }
 if (!is_callable('sodium_crypto_stream')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_stream()
-     * @param int $len
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_stream($len, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_stream()
+	 * @param int $len
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_stream($len, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
+	}
 }
 if (!is_callable('sodium_crypto_stream_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_stream_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_stream_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_stream_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_stream_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_stream_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_stream_xor')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_stream_xor($message, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_stream_xor($message, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
+	}
 }
 require_once dirname(__FILE__) . '/stream-xchacha20.php';
 if (!is_callable('sodium_hex2bin')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::hex2bin()
-     * @param string $string
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_hex2bin($string)
-    {
-        return ParagonIE_Sodium_Compat::hex2bin($string);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::hex2bin()
+	 * @param string $string
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_hex2bin($string)
+	{
+		return ParagonIE_Sodium_Compat::hex2bin($string);
+	}
 }
 if (!is_callable('sodium_increment')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::increment()
-     * @param string $string
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_increment(&$string)
-    {
-        ParagonIE_Sodium_Compat::increment($string);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::increment()
+	 * @param string $string
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_increment(&$string)
+	{
+		ParagonIE_Sodium_Compat::increment($string);
+	}
 }
 if (!is_callable('sodium_library_version_major')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::library_version_major()
-     * @return int
-     */
-    function sodium_library_version_major()
-    {
-        return ParagonIE_Sodium_Compat::library_version_major();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::library_version_major()
+	 * @return int
+	 */
+	function sodium_library_version_major()
+	{
+		return ParagonIE_Sodium_Compat::library_version_major();
+	}
 }
 if (!is_callable('sodium_library_version_minor')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::library_version_minor()
-     * @return int
-     */
-    function sodium_library_version_minor()
-    {
-        return ParagonIE_Sodium_Compat::library_version_minor();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::library_version_minor()
+	 * @return int
+	 */
+	function sodium_library_version_minor()
+	{
+		return ParagonIE_Sodium_Compat::library_version_minor();
+	}
 }
 if (!is_callable('sodium_version_string')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::version_string()
-     * @return string
-     */
-    function sodium_version_string()
-    {
-        return ParagonIE_Sodium_Compat::version_string();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::version_string()
+	 * @return string
+	 */
+	function sodium_version_string()
+	{
+		return ParagonIE_Sodium_Compat::version_string();
+	}
 }
 if (!is_callable('sodium_memcmp')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::memcmp()
-     * @param string $a
-     * @param string $b
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_memcmp($a, $b)
-    {
-        return ParagonIE_Sodium_Compat::memcmp($a, $b);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::memcmp()
+	 * @param string $a
+	 * @param string $b
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_memcmp($a, $b)
+	{
+		return ParagonIE_Sodium_Compat::memcmp($a, $b);
+	}
 }
 if (!is_callable('sodium_memzero')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::memzero()
-     * @param string $str
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_memzero(&$str)
-    {
-        ParagonIE_Sodium_Compat::memzero($str);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::memzero()
+	 * @param string $str
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_memzero(&$str)
+	{
+		ParagonIE_Sodium_Compat::memzero($str);
+	}
 }
 if (!is_callable('sodium_pad')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::pad()
-     * @param string $unpadded
-     * @param int $blockSize
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_pad($unpadded, $blockSize)
-    {
-        return ParagonIE_Sodium_Compat::pad($unpadded, $blockSize, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::pad()
+	 * @param string $unpadded
+	 * @param int $blockSize
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_pad($unpadded, $blockSize)
+	{
+		return ParagonIE_Sodium_Compat::pad($unpadded, $blockSize, true);
+	}
 }
 if (!is_callable('sodium_unpad')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::pad()
-     * @param string $padded
-     * @param int $blockSize
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_unpad($padded, $blockSize)
-    {
-        return ParagonIE_Sodium_Compat::unpad($padded, $blockSize, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::pad()
+	 * @param string $padded
+	 * @param int $blockSize
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_unpad($padded, $blockSize)
+	{
+		return ParagonIE_Sodium_Compat::unpad($padded, $blockSize, true);
+	}
 }
 if (!is_callable('sodium_randombytes_buf')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::randombytes_buf()
-     * @param int $amount
-     * @return string
-     * @throws Exception
-     */
-    function sodium_randombytes_buf($amount)
-    {
-        return ParagonIE_Sodium_Compat::randombytes_buf($amount);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::randombytes_buf()
+	 * @param int $amount
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_randombytes_buf($amount)
+	{
+		return ParagonIE_Sodium_Compat::randombytes_buf($amount);
+	}
 }
 
 if (!is_callable('sodium_randombytes_uniform')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::randombytes_uniform()
-     * @param int $upperLimit
-     * @return int
-     * @throws Exception
-     */
-    function sodium_randombytes_uniform($upperLimit)
-    {
-        return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::randombytes_uniform()
+	 * @param int $upperLimit
+	 * @return int
+	 * @throws Exception
+	 */
+	function sodium_randombytes_uniform($upperLimit)
+	{
+		return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
+	}
 }
 
 if (!is_callable('sodium_randombytes_random16')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::randombytes_random16()
-     * @return int
-     * @throws Exception
-     */
-    function sodium_randombytes_random16()
-    {
-        return ParagonIE_Sodium_Compat::randombytes_random16();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::randombytes_random16()
+	 * @return int
+	 * @throws Exception
+	 */
+	function sodium_randombytes_random16()
+	{
+		return ParagonIE_Sodium_Compat::randombytes_random16();
+	}
 }

Spacing +256 added lines, -256 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-require_once dirname(dirname(__FILE__)) . '/autoload.php';
+require_once dirname( dirname( __FILE__ ) ) . '/autoload.php';
 
 /**
  * This file will monkey patch the pure-PHP implementation in place of the
@@ -9,7 +9,7 @@ 
  * Thus, the functions or constants just proxy to the appropriate
  * ParagonIE_Sodium_Compat method or class constant, respectively.
  */
-foreach (array(
+foreach ( array(
     'BASE64_VARIANT_ORIGINAL',
     'BASE64_VARIANT_ORIGINAL_NO_PADDING',
     'BASE64_VARIANT_URLSAFE',
@@ -103,11 +103,11 @@ 
     'VERSION_STRING'
     ) as $constant
 ) {
-    if (!defined("SODIUM_$constant") && defined("ParagonIE_Sodium_Compat::$constant")) {
-        define("SODIUM_$constant", constant("ParagonIE_Sodium_Compat::$constant"));
+    if ( ! defined( "SODIUM_$constant" ) && defined( "ParagonIE_Sodium_Compat::$constant" ) ) {
+        define( "SODIUM_$constant", constant( "ParagonIE_Sodium_Compat::$constant" ) );
     }
 }
-if (!is_callable('sodium_add')) {
+if ( ! is_callable( 'sodium_add' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::add()
      * @param string $val
@@ -115,12 +115,12 @@ 
      * @return void
      * @throws SodiumException
      */
-    function sodium_add(&$val, $addv)
+    function sodium_add( &$val, $addv )
     {
-        ParagonIE_Sodium_Compat::add($val, $addv);
+        ParagonIE_Sodium_Compat::add( $val, $addv );
     }
 }
-if (!is_callable('sodium_base642bin')) {
+if ( ! is_callable( 'sodium_base642bin' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::bin2base64()
      * @param string $string
@@ -130,12 +130,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_base642bin($string, $variant, $ignore ='')
+    function sodium_base642bin( $string, $variant, $ignore = '' )
     {
-        return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
+        return ParagonIE_Sodium_Compat::base642bin( $string, $variant, $ignore );
     }
 }
-if (!is_callable('sodium_bin2base64')) {
+if ( ! is_callable( 'sodium_bin2base64' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::bin2base64()
      * @param string $string
@@ -144,12 +144,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_bin2base64($string, $variant)
+    function sodium_bin2base64( $string, $variant )
     {
-        return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
+        return ParagonIE_Sodium_Compat::bin2base64( $string, $variant );
     }
 }
-if (!is_callable('sodium_bin2hex')) {
+if ( ! is_callable( 'sodium_bin2hex' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::hex2bin()
      * @param string $string
@@ -157,12 +157,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_bin2hex($string)
+    function sodium_bin2hex( $string )
     {
-        return ParagonIE_Sodium_Compat::bin2hex($string);
+        return ParagonIE_Sodium_Compat::bin2hex( $string );
     }
 }
-if (!is_callable('sodium_compare')) {
+if ( ! is_callable( 'sodium_compare' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::compare()
      * @param string $a
@@ -171,12 +171,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_compare($a, $b)
+    function sodium_compare( $a, $b )
     {
-        return ParagonIE_Sodium_Compat::compare($a, $b);
+        return ParagonIE_Sodium_Compat::compare( $a, $b );
     }
 }
-if (!is_callable('sodium_crypto_aead_aes256gcm_decrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_aes256gcm_decrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt()
      * @param string $message
@@ -185,18 +185,18 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_aes256gcm_decrypt( $message, $assocData, $nonce, $key )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
-        } catch (Error $ex) {
+            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt( $message, $assocData, $nonce, $key );
+        } catch ( Error $ex ) {
             return false;
-        } catch (Exception $ex) {
+        } catch ( Exception $ex ) {
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_aead_aes256gcm_encrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_aes256gcm_encrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt()
      * @param string $message
@@ -207,12 +207,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_aes256gcm_encrypt( $message, $assocData, $nonce, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
+        return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt( $message, $assocData, $nonce, $key );
     }
 }
-if (!is_callable('sodium_crypto_aead_aes256gcm_is_available')) {
+if ( ! is_callable( 'sodium_crypto_aead_aes256gcm_is_available' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
      * @return bool
@@ -222,7 +222,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
     }
 }
-if (!is_callable('sodium_crypto_aead_chacha20poly1305_decrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_chacha20poly1305_decrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt()
      * @param string $message
@@ -231,18 +231,18 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_chacha20poly1305_decrypt( $message, $assocData, $nonce, $key )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
-        } catch (Error $ex) {
+            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt( $message, $assocData, $nonce, $key );
+        } catch ( Error $ex ) {
             return false;
-        } catch (Exception $ex) {
+        } catch ( Exception $ex ) {
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_aead_chacha20poly1305_encrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_chacha20poly1305_encrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt()
      * @param string $message
@@ -253,12 +253,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_chacha20poly1305_encrypt( $message, $assocData, $nonce, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
+        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt( $message, $assocData, $nonce, $key );
     }
 }
-if (!is_callable('sodium_crypto_aead_chacha20poly1305_keygen')) {
+if ( ! is_callable( 'sodium_crypto_aead_chacha20poly1305_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen()
      * @return string
@@ -269,7 +269,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
     }
 }
-if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_decrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_chacha20poly1305_ietf_decrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt()
      * @param string $message
@@ -278,18 +278,18 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt( $message, $assocData, $nonce, $key )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
-        } catch (Error $ex) {
+            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt( $message, $assocData, $nonce, $key );
+        } catch ( Error $ex ) {
             return false;
-        } catch (Exception $ex) {
+        } catch ( Exception $ex ) {
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_encrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_chacha20poly1305_ietf_encrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt()
      * @param string $message
@@ -300,12 +300,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt( $message, $assocData, $nonce, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
+        return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt( $message, $assocData, $nonce, $key );
     }
 }
-if (!is_callable('sodium_crypto_aead_chacha20poly1305_ietf_keygen')) {
+if ( ! is_callable( 'sodium_crypto_aead_chacha20poly1305_ietf_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen()
      * @return string
@@ -316,7 +316,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
     }
 }
-if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt()
      * @param string $message
@@ -325,18 +325,18 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt( $message, $assocData, $nonce, $key )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
-        } catch (Error $ex) {
+            return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt( $message, $assocData, $nonce, $key, true );
+        } catch ( Error $ex ) {
             return false;
-        } catch (Exception $ex) {
+        } catch ( Exception $ex ) {
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_encrypt')) {
+if ( ! is_callable( 'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt()
      * @param string $message
@@ -347,12 +347,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
+    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt( $message, $assocData, $nonce, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
+        return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt( $message, $assocData, $nonce, $key, true );
     }
 }
-if (!is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_keygen')) {
+if ( ! is_callable( 'sodium_crypto_aead_xchacha20poly1305_ietf_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen()
      * @return string
@@ -363,7 +363,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
     }
 }
-if (!is_callable('sodium_crypto_auth')) {
+if ( ! is_callable( 'sodium_crypto_auth' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_auth()
      * @param string $message
@@ -372,12 +372,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_auth($message, $key)
+    function sodium_crypto_auth( $message, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
+        return ParagonIE_Sodium_Compat::crypto_auth( $message, $key );
     }
 }
-if (!is_callable('sodium_crypto_auth_keygen')) {
+if ( ! is_callable( 'sodium_crypto_auth_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_auth_keygen()
      * @return string
@@ -388,7 +388,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_auth_keygen();
     }
 }
-if (!is_callable('sodium_crypto_auth_verify')) {
+if ( ! is_callable( 'sodium_crypto_auth_verify' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_auth_verify()
      * @param string $mac
@@ -398,12 +398,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_auth_verify($mac, $message, $key)
+    function sodium_crypto_auth_verify( $mac, $message, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
+        return ParagonIE_Sodium_Compat::crypto_auth_verify( $mac, $message, $key );
     }
 }
-if (!is_callable('sodium_crypto_box')) {
+if ( ! is_callable( 'sodium_crypto_box' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box()
      * @param string $message
@@ -413,12 +413,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box($message, $nonce, $kp)
+    function sodium_crypto_box( $message, $nonce, $kp )
     {
-        return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
+        return ParagonIE_Sodium_Compat::crypto_box( $message, $nonce, $kp );
     }
 }
-if (!is_callable('sodium_crypto_box_keypair')) {
+if ( ! is_callable( 'sodium_crypto_box_keypair' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
      * @return string
@@ -430,7 +430,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_box_keypair();
     }
 }
-if (!is_callable('sodium_crypto_box_keypair_from_secretkey_and_publickey')) {
+if ( ! is_callable( 'sodium_crypto_box_keypair_from_secretkey_and_publickey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey()
      * @param string $sk
@@ -439,12 +439,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
+    function sodium_crypto_box_keypair_from_secretkey_and_publickey( $sk, $pk )
     {
-        return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
+        return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey( $sk, $pk );
     }
 }
-if (!is_callable('sodium_crypto_box_open')) {
+if ( ! is_callable( 'sodium_crypto_box_open' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_open()
      * @param string $message
@@ -452,18 +452,18 @@ 
      * @param string $kp
      * @return string|bool
      */
-    function sodium_crypto_box_open($message, $nonce, $kp)
+    function sodium_crypto_box_open( $message, $nonce, $kp )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
-        } catch (Error $ex) {
+            return ParagonIE_Sodium_Compat::crypto_box_open( $message, $nonce, $kp );
+        } catch ( Error $ex ) {
             return false;
-        } catch (Exception $ex) {
+        } catch ( Exception $ex ) {
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_box_publickey')) {
+if ( ! is_callable( 'sodium_crypto_box_publickey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_publickey()
      * @param string $keypair
@@ -471,12 +471,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_publickey($keypair)
+    function sodium_crypto_box_publickey( $keypair )
     {
-        return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
+        return ParagonIE_Sodium_Compat::crypto_box_publickey( $keypair );
     }
 }
-if (!is_callable('sodium_crypto_box_publickey_from_secretkey')) {
+if ( ! is_callable( 'sodium_crypto_box_publickey_from_secretkey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey()
      * @param string $sk
@@ -484,12 +484,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_publickey_from_secretkey($sk)
+    function sodium_crypto_box_publickey_from_secretkey( $sk )
     {
-        return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
+        return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey( $sk );
     }
 }
-if (!is_callable('sodium_crypto_box_seal')) {
+if ( ! is_callable( 'sodium_crypto_box_seal' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_seal()
      * @param string $message
@@ -498,12 +498,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_seal($message, $publicKey)
+    function sodium_crypto_box_seal( $message, $publicKey )
     {
-        return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
+        return ParagonIE_Sodium_Compat::crypto_box_seal( $message, $publicKey );
     }
 }
-if (!is_callable('sodium_crypto_box_seal_open')) {
+if ( ! is_callable( 'sodium_crypto_box_seal_open' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
      * @param string $message
@@ -511,19 +511,19 @@ 
      * @return string|bool
      * @throws SodiumException
      */
-    function sodium_crypto_box_seal_open($message, $kp)
+    function sodium_crypto_box_seal_open( $message, $kp )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
-        } catch (SodiumException $ex) {
-            if ($ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.') {
+            return ParagonIE_Sodium_Compat::crypto_box_seal_open( $message, $kp );
+        } catch ( SodiumException $ex ) {
+            if ( $ex->getMessage() === 'Argument 2 must be CRYPTO_BOX_KEYPAIRBYTES long.' ) {
                 throw $ex;
             }
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_box_secretkey')) {
+if ( ! is_callable( 'sodium_crypto_box_secretkey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_secretkey()
      * @param string $keypair
@@ -531,12 +531,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_secretkey($keypair)
+    function sodium_crypto_box_secretkey( $keypair )
     {
-        return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
+        return ParagonIE_Sodium_Compat::crypto_box_secretkey( $keypair );
     }
 }
-if (!is_callable('sodium_crypto_box_seed_keypair')) {
+if ( ! is_callable( 'sodium_crypto_box_seed_keypair' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_box_seed_keypair()
      * @param string $seed
@@ -544,12 +544,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_seed_keypair($seed)
+    function sodium_crypto_box_seed_keypair( $seed )
     {
-        return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
+        return ParagonIE_Sodium_Compat::crypto_box_seed_keypair( $seed );
     }
 }
-if (!is_callable('sodium_crypto_generichash')) {
+if ( ! is_callable( 'sodium_crypto_generichash' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_generichash()
      * @param string $message
@@ -559,12 +559,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash($message, $key = null, $outLen = 32)
+    function sodium_crypto_generichash( $message, $key = null, $outLen = 32 )
     {
-        return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
+        return ParagonIE_Sodium_Compat::crypto_generichash( $message, $key, $outLen );
     }
 }
-if (!is_callable('sodium_crypto_generichash_final')) {
+if ( ! is_callable( 'sodium_crypto_generichash_final' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_generichash_final()
      * @param string|null $ctx
@@ -573,12 +573,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash_final(&$ctx, $outputLength = 32)
+    function sodium_crypto_generichash_final( &$ctx, $outputLength = 32 )
     {
-        return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
+        return ParagonIE_Sodium_Compat::crypto_generichash_final( $ctx, $outputLength );
     }
 }
-if (!is_callable('sodium_crypto_generichash_init')) {
+if ( ! is_callable( 'sodium_crypto_generichash_init' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_generichash_init()
      * @param string|null $key
@@ -587,12 +587,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash_init($key = null, $outLen = 32)
+    function sodium_crypto_generichash_init( $key = null, $outLen = 32 )
     {
-        return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
+        return ParagonIE_Sodium_Compat::crypto_generichash_init( $key, $outLen );
     }
 }
-if (!is_callable('sodium_crypto_generichash_keygen')) {
+if ( ! is_callable( 'sodium_crypto_generichash_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_generichash_keygen()
      * @return string
@@ -603,7 +603,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
     }
 }
-if (!is_callable('sodium_crypto_generichash_update')) {
+if ( ! is_callable( 'sodium_crypto_generichash_update' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_generichash_update()
      * @param string|null $ctx
@@ -612,12 +612,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash_update(&$ctx, $message = '')
+    function sodium_crypto_generichash_update( &$ctx, $message = '' )
     {
-        ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
+        ParagonIE_Sodium_Compat::crypto_generichash_update( $ctx, $message );
     }
 }
-if (!is_callable('sodium_crypto_kdf_keygen')) {
+if ( ! is_callable( 'sodium_crypto_kdf_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_kdf_keygen()
      * @return string
@@ -628,7 +628,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_kdf_keygen();
     }
 }
-if (!is_callable('sodium_crypto_kdf_derive_from_key')) {
+if ( ! is_callable( 'sodium_crypto_kdf_derive_from_key' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key()
      * @param int $subkey_len
@@ -638,7 +638,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key)
+    function sodium_crypto_kdf_derive_from_key( $subkey_len, $subkey_id, $context, $key )
     {
         return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
             $subkey_len,
@@ -648,7 +648,7 @@ 
         );
     }
 }
-if (!is_callable('sodium_crypto_kx')) {
+if ( ! is_callable( 'sodium_crypto_kx' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_kx()
      * @param string $my_secret
@@ -659,7 +659,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
+    function sodium_crypto_kx( $my_secret, $their_public, $client_public, $server_public )
     {
         return ParagonIE_Sodium_Compat::crypto_kx(
             $my_secret,
@@ -669,18 +669,18 @@ 
         );
     }
 }
-if (!is_callable('sodium_crypto_kx_seed_keypair')) {
+if ( ! is_callable( 'sodium_crypto_kx_seed_keypair' ) ) {
     /**
      * @param string $seed
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kx_seed_keypair($seed)
+    function sodium_crypto_kx_seed_keypair( $seed )
     {
-        return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
+        return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair( $seed );
     }
 }
-if (!is_callable('sodium_crypto_kx_keypair')) {
+if ( ! is_callable( 'sodium_crypto_kx_keypair' ) ) {
     /**
      * @return string
      * @throws Exception
@@ -690,53 +690,53 @@ 
         return ParagonIE_Sodium_Compat::crypto_kx_keypair();
     }
 }
-if (!is_callable('sodium_crypto_kx_client_session_keys')) {
+if ( ! is_callable( 'sodium_crypto_kx_client_session_keys' ) ) {
     /**
      * @param string $keypair
      * @param string $serverPublicKey
      * @return array{0: string, 1: string}
      * @throws SodiumException
      */
-    function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey)
+    function sodium_crypto_kx_client_session_keys( $keypair, $serverPublicKey )
     {
-        return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($keypair, $serverPublicKey);
+        return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys( $keypair, $serverPublicKey );
     }
 }
-if (!is_callable('sodium_crypto_kx_server_session_keys')) {
+if ( ! is_callable( 'sodium_crypto_kx_server_session_keys' ) ) {
     /**
      * @param string $keypair
      * @param string $clientPublicKey
      * @return array{0: string, 1: string}
      * @throws SodiumException
      */
-    function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey)
+    function sodium_crypto_kx_server_session_keys( $keypair, $clientPublicKey )
     {
-        return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($keypair, $clientPublicKey);
+        return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys( $keypair, $clientPublicKey );
     }
 }
-if (!is_callable('sodium_crypto_kx_secretkey')) {
+if ( ! is_callable( 'sodium_crypto_kx_secretkey' ) ) {
     /**
      * @param string $keypair
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kx_secretkey($keypair)
+    function sodium_crypto_kx_secretkey( $keypair )
     {
-        return ParagonIE_Sodium_Compat::crypto_kx_secretkey($keypair);
+        return ParagonIE_Sodium_Compat::crypto_kx_secretkey( $keypair );
     }
 }
-if (!is_callable('sodium_crypto_kx_publickey')) {
+if ( ! is_callable( 'sodium_crypto_kx_publickey' ) ) {
     /**
      * @param string $keypair
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kx_publickey($keypair)
+    function sodium_crypto_kx_publickey( $keypair )
     {
-        return ParagonIE_Sodium_Compat::crypto_kx_publickey($keypair);
+        return ParagonIE_Sodium_Compat::crypto_kx_publickey( $keypair );
     }
 }
-if (!is_callable('sodium_crypto_pwhash')) {
+if ( ! is_callable( 'sodium_crypto_pwhash' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_pwhash()
      * @param int $outlen
@@ -749,12 +749,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null)
+    function sodium_crypto_pwhash( $outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null )
     {
-        return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo);
+        return ParagonIE_Sodium_Compat::crypto_pwhash( $outlen, $passwd, $salt, $opslimit, $memlimit, $algo );
     }
 }
-if (!is_callable('sodium_crypto_pwhash_str')) {
+if ( ! is_callable( 'sodium_crypto_pwhash_str' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_pwhash_str()
      * @param string $passwd
@@ -764,12 +764,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
+    function sodium_crypto_pwhash_str( $passwd, $opslimit, $memlimit )
     {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
+        return ParagonIE_Sodium_Compat::crypto_pwhash_str( $passwd, $opslimit, $memlimit );
     }
 }
-if (!is_callable('sodium_crypto_pwhash_str_needs_rehash')) {
+if ( ! is_callable( 'sodium_crypto_pwhash_str_needs_rehash' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash()
      * @param string $hash
@@ -779,12 +779,12 @@ 
      *
      * @throws SodiumException
      */
-    function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
+    function sodium_crypto_pwhash_str_needs_rehash( $hash, $opslimit, $memlimit )
     {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
+        return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash( $hash, $opslimit, $memlimit );
     }
 }
-if (!is_callable('sodium_crypto_pwhash_str_verify')) {
+if ( ! is_callable( 'sodium_crypto_pwhash_str_verify' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_pwhash_str_verify()
      * @param string $passwd
@@ -793,12 +793,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_str_verify($passwd, $hash)
+    function sodium_crypto_pwhash_str_verify( $passwd, $hash )
     {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
+        return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify( $passwd, $hash );
     }
 }
-if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256')) {
+if ( ! is_callable( 'sodium_crypto_pwhash_scryptsalsa208sha256' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256()
      * @param int $outlen
@@ -810,12 +810,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
+    function sodium_crypto_pwhash_scryptsalsa208sha256( $outlen, $passwd, $salt, $opslimit, $memlimit )
     {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
+        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256( $outlen, $passwd, $salt, $opslimit, $memlimit );
     }
 }
-if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str')) {
+if ( ! is_callable( 'sodium_crypto_pwhash_scryptsalsa208sha256_str' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str()
      * @param string $passwd
@@ -825,12 +825,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
+    function sodium_crypto_pwhash_scryptsalsa208sha256_str( $passwd, $opslimit, $memlimit )
     {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
+        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str( $passwd, $opslimit, $memlimit );
     }
 }
-if (!is_callable('sodium_crypto_pwhash_scryptsalsa208sha256_str_verify')) {
+if ( ! is_callable( 'sodium_crypto_pwhash_scryptsalsa208sha256_str_verify' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify()
      * @param string $passwd
@@ -839,12 +839,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
+    function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify( $passwd, $hash )
     {
-        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
+        return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify( $passwd, $hash );
     }
 }
-if (!is_callable('sodium_crypto_scalarmult')) {
+if ( ! is_callable( 'sodium_crypto_scalarmult' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_scalarmult()
      * @param string $n
@@ -853,12 +853,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_scalarmult($n, $p)
+    function sodium_crypto_scalarmult( $n, $p )
     {
-        return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
+        return ParagonIE_Sodium_Compat::crypto_scalarmult( $n, $p );
     }
 }
-if (!is_callable('sodium_crypto_scalarmult_base')) {
+if ( ! is_callable( 'sodium_crypto_scalarmult_base' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_scalarmult_base()
      * @param string $n
@@ -866,12 +866,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_scalarmult_base($n)
+    function sodium_crypto_scalarmult_base( $n )
     {
-        return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
+        return ParagonIE_Sodium_Compat::crypto_scalarmult_base( $n );
     }
 }
-if (!is_callable('sodium_crypto_secretbox')) {
+if ( ! is_callable( 'sodium_crypto_secretbox' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_secretbox()
      * @param string $message
@@ -881,12 +881,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_secretbox($message, $nonce, $key)
+    function sodium_crypto_secretbox( $message, $nonce, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
+        return ParagonIE_Sodium_Compat::crypto_secretbox( $message, $nonce, $key );
     }
 }
-if (!is_callable('sodium_crypto_secretbox_keygen')) {
+if ( ! is_callable( 'sodium_crypto_secretbox_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_secretbox_keygen()
      * @return string
@@ -897,7 +897,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
     }
 }
-if (!is_callable('sodium_crypto_secretbox_open')) {
+if ( ! is_callable( 'sodium_crypto_secretbox_open' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
      * @param string $message
@@ -905,29 +905,29 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_secretbox_open($message, $nonce, $key)
+    function sodium_crypto_secretbox_open( $message, $nonce, $key )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
-        } catch (Error $ex) {
+            return ParagonIE_Sodium_Compat::crypto_secretbox_open( $message, $nonce, $key );
+        } catch ( Error $ex ) {
             return false;
-        } catch (Exception $ex) {
+        } catch ( Exception $ex ) {
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_push')) {
+if ( ! is_callable( 'sodium_crypto_secretstream_xchacha20poly1305_init_push' ) ) {
     /**
      * @param string $key
      * @return array<int, string>
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_init_push($key)
+    function sodium_crypto_secretstream_xchacha20poly1305_init_push( $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
+        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push( $key );
     }
 }
-if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_push')) {
+if ( ! is_callable( 'sodium_crypto_secretstream_xchacha20poly1305_push' ) ) {
     /**
      * @param string $state
      * @param string $msg
@@ -936,24 +936,24 @@ 
      * @return string
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
+    function sodium_crypto_secretstream_xchacha20poly1305_push( &$state, $msg, $aad = '', $tag = 0 )
     {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push($state, $msg, $aad, $tag);
+        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push( $state, $msg, $aad, $tag );
     }
 }
-if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_init_pull')) {
+if ( ! is_callable( 'sodium_crypto_secretstream_xchacha20poly1305_init_pull' ) ) {
     /**
      * @param string $header
      * @param string $key
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
+    function sodium_crypto_secretstream_xchacha20poly1305_init_pull( $header, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
+        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull( $header, $key );
     }
 }
-if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_pull')) {
+if ( ! is_callable( 'sodium_crypto_secretstream_xchacha20poly1305_pull' ) ) {
     /**
      * @param string $state
      * @param string $cipher
@@ -961,23 +961,23 @@ 
      * @return bool|array{0: string, 1: int}
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
+    function sodium_crypto_secretstream_xchacha20poly1305_pull( &$state, $cipher, $aad = '' )
     {
-        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull($state, $cipher, $aad);
+        return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull( $state, $cipher, $aad );
     }
 }
-if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_rekey')) {
+if ( ! is_callable( 'sodium_crypto_secretstream_xchacha20poly1305_rekey' ) ) {
     /**
      * @param string $state
      * @return void
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_rekey(&$state)
+    function sodium_crypto_secretstream_xchacha20poly1305_rekey( &$state )
     {
-        ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
+        ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey( $state );
     }
 }
-if (!is_callable('sodium_crypto_secretstream_xchacha20poly1305_keygen')) {
+if ( ! is_callable( 'sodium_crypto_secretstream_xchacha20poly1305_keygen' ) ) {
     /**
      * @return string
      * @throws Exception
@@ -987,7 +987,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_keygen();
     }
 }
-if (!is_callable('sodium_crypto_shorthash')) {
+if ( ! is_callable( 'sodium_crypto_shorthash' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_shorthash()
      * @param string $message
@@ -996,12 +996,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_shorthash($message, $key = '')
+    function sodium_crypto_shorthash( $message, $key = '' )
     {
-        return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
+        return ParagonIE_Sodium_Compat::crypto_shorthash( $message, $key );
     }
 }
-if (!is_callable('sodium_crypto_shorthash_keygen')) {
+if ( ! is_callable( 'sodium_crypto_shorthash_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_shorthash_keygen()
      * @return string
@@ -1012,7 +1012,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
     }
 }
-if (!is_callable('sodium_crypto_sign')) {
+if ( ! is_callable( 'sodium_crypto_sign' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign()
      * @param string $message
@@ -1021,12 +1021,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign($message, $sk)
+    function sodium_crypto_sign( $message, $sk )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
+        return ParagonIE_Sodium_Compat::crypto_sign( $message, $sk );
     }
 }
-if (!is_callable('sodium_crypto_sign_detached')) {
+if ( ! is_callable( 'sodium_crypto_sign_detached' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_detached()
      * @param string $message
@@ -1035,12 +1035,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_detached($message, $sk)
+    function sodium_crypto_sign_detached( $message, $sk )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
+        return ParagonIE_Sodium_Compat::crypto_sign_detached( $message, $sk );
     }
 }
-if (!is_callable('sodium_crypto_sign_keypair_from_secretkey_and_publickey')) {
+if ( ! is_callable( 'sodium_crypto_sign_keypair_from_secretkey_and_publickey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey()
      * @param string $sk
@@ -1049,12 +1049,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
+    function sodium_crypto_sign_keypair_from_secretkey_and_publickey( $sk, $pk )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
+        return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey( $sk, $pk );
     }
 }
-if (!is_callable('sodium_crypto_sign_keypair')) {
+if ( ! is_callable( 'sodium_crypto_sign_keypair' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
      * @return string
@@ -1066,25 +1066,25 @@ 
         return ParagonIE_Sodium_Compat::crypto_sign_keypair();
     }
 }
-if (!is_callable('sodium_crypto_sign_open')) {
+if ( ! is_callable( 'sodium_crypto_sign_open' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_open()
      * @param string $signedMessage
      * @param string $pk
      * @return string|bool
      */
-    function sodium_crypto_sign_open($signedMessage, $pk)
+    function sodium_crypto_sign_open( $signedMessage, $pk )
     {
         try {
-            return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
-        } catch (Error $ex) {
+            return ParagonIE_Sodium_Compat::crypto_sign_open( $signedMessage, $pk );
+        } catch ( Error $ex ) {
             return false;
-        } catch (Exception $ex) {
+        } catch ( Exception $ex ) {
             return false;
         }
     }
 }
-if (!is_callable('sodium_crypto_sign_publickey')) {
+if ( ! is_callable( 'sodium_crypto_sign_publickey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_publickey()
      * @param string $keypair
@@ -1092,12 +1092,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_publickey($keypair)
+    function sodium_crypto_sign_publickey( $keypair )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
+        return ParagonIE_Sodium_Compat::crypto_sign_publickey( $keypair );
     }
 }
-if (!is_callable('sodium_crypto_sign_publickey_from_secretkey')) {
+if ( ! is_callable( 'sodium_crypto_sign_publickey_from_secretkey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey()
      * @param string $sk
@@ -1105,12 +1105,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_publickey_from_secretkey($sk)
+    function sodium_crypto_sign_publickey_from_secretkey( $sk )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
+        return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey( $sk );
     }
 }
-if (!is_callable('sodium_crypto_sign_secretkey')) {
+if ( ! is_callable( 'sodium_crypto_sign_secretkey' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_secretkey()
      * @param string $keypair
@@ -1118,12 +1118,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_secretkey($keypair)
+    function sodium_crypto_sign_secretkey( $keypair )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
+        return ParagonIE_Sodium_Compat::crypto_sign_secretkey( $keypair );
     }
 }
-if (!is_callable('sodium_crypto_sign_seed_keypair')) {
+if ( ! is_callable( 'sodium_crypto_sign_seed_keypair' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_seed_keypair()
      * @param string $seed
@@ -1131,12 +1131,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_seed_keypair($seed)
+    function sodium_crypto_sign_seed_keypair( $seed )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
+        return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair( $seed );
     }
 }
-if (!is_callable('sodium_crypto_sign_verify_detached')) {
+if ( ! is_callable( 'sodium_crypto_sign_verify_detached' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_verify_detached()
      * @param string $signature
@@ -1146,12 +1146,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_verify_detached($signature, $message, $pk)
+    function sodium_crypto_sign_verify_detached( $signature, $message, $pk )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
+        return ParagonIE_Sodium_Compat::crypto_sign_verify_detached( $signature, $message, $pk );
     }
 }
-if (!is_callable('sodium_crypto_sign_ed25519_pk_to_curve25519')) {
+if ( ! is_callable( 'sodium_crypto_sign_ed25519_pk_to_curve25519' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519()
      * @param string $pk
@@ -1159,12 +1159,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_ed25519_pk_to_curve25519($pk)
+    function sodium_crypto_sign_ed25519_pk_to_curve25519( $pk )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
+        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519( $pk );
     }
 }
-if (!is_callable('sodium_crypto_sign_ed25519_sk_to_curve25519')) {
+if ( ! is_callable( 'sodium_crypto_sign_ed25519_sk_to_curve25519' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519()
      * @param string $sk
@@ -1172,12 +1172,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_ed25519_sk_to_curve25519($sk)
+    function sodium_crypto_sign_ed25519_sk_to_curve25519( $sk )
     {
-        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
+        return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519( $sk );
     }
 }
-if (!is_callable('sodium_crypto_stream')) {
+if ( ! is_callable( 'sodium_crypto_stream' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_stream()
      * @param int $len
@@ -1187,12 +1187,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_stream($len, $nonce, $key)
+    function sodium_crypto_stream( $len, $nonce, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
+        return ParagonIE_Sodium_Compat::crypto_stream( $len, $nonce, $key );
     }
 }
-if (!is_callable('sodium_crypto_stream_keygen')) {
+if ( ! is_callable( 'sodium_crypto_stream_keygen' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_stream_keygen()
      * @return string
@@ -1203,7 +1203,7 @@ 
         return ParagonIE_Sodium_Compat::crypto_stream_keygen();
     }
 }
-if (!is_callable('sodium_crypto_stream_xor')) {
+if ( ! is_callable( 'sodium_crypto_stream_xor' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::crypto_stream_xor()
      * @param string $message
@@ -1213,13 +1213,13 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_stream_xor($message, $nonce, $key)
+    function sodium_crypto_stream_xor( $message, $nonce, $key )
     {
-        return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
+        return ParagonIE_Sodium_Compat::crypto_stream_xor( $message, $nonce, $key );
     }
 }
-require_once dirname(__FILE__) . '/stream-xchacha20.php';
-if (!is_callable('sodium_hex2bin')) {
+require_once dirname( __FILE__ ) . '/stream-xchacha20.php';
+if ( ! is_callable( 'sodium_hex2bin' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::hex2bin()
      * @param string $string
@@ -1227,12 +1227,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_hex2bin($string)
+    function sodium_hex2bin( $string )
     {
-        return ParagonIE_Sodium_Compat::hex2bin($string);
+        return ParagonIE_Sodium_Compat::hex2bin( $string );
     }
 }
-if (!is_callable('sodium_increment')) {
+if ( ! is_callable( 'sodium_increment' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::increment()
      * @param string $string
@@ -1240,12 +1240,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_increment(&$string)
+    function sodium_increment( &$string )
     {
-        ParagonIE_Sodium_Compat::increment($string);
+        ParagonIE_Sodium_Compat::increment( $string );
     }
 }
-if (!is_callable('sodium_library_version_major')) {
+if ( ! is_callable( 'sodium_library_version_major' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::library_version_major()
      * @return int
@@ -1255,7 +1255,7 @@ 
         return ParagonIE_Sodium_Compat::library_version_major();
     }
 }
-if (!is_callable('sodium_library_version_minor')) {
+if ( ! is_callable( 'sodium_library_version_minor' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::library_version_minor()
      * @return int
@@ -1265,7 +1265,7 @@ 
         return ParagonIE_Sodium_Compat::library_version_minor();
     }
 }
-if (!is_callable('sodium_version_string')) {
+if ( ! is_callable( 'sodium_version_string' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::version_string()
      * @return string
@@ -1275,7 +1275,7 @@ 
         return ParagonIE_Sodium_Compat::version_string();
     }
 }
-if (!is_callable('sodium_memcmp')) {
+if ( ! is_callable( 'sodium_memcmp' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::memcmp()
      * @param string $a
@@ -1284,12 +1284,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_memcmp($a, $b)
+    function sodium_memcmp( $a, $b )
     {
-        return ParagonIE_Sodium_Compat::memcmp($a, $b);
+        return ParagonIE_Sodium_Compat::memcmp( $a, $b );
     }
 }
-if (!is_callable('sodium_memzero')) {
+if ( ! is_callable( 'sodium_memzero' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::memzero()
      * @param string $str
@@ -1297,12 +1297,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_memzero(&$str)
+    function sodium_memzero( &$str )
     {
-        ParagonIE_Sodium_Compat::memzero($str);
+        ParagonIE_Sodium_Compat::memzero( $str );
     }
 }
-if (!is_callable('sodium_pad')) {
+if ( ! is_callable( 'sodium_pad' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::pad()
      * @param string $unpadded
@@ -1311,12 +1311,12 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_pad($unpadded, $blockSize)
+    function sodium_pad( $unpadded, $blockSize )
     {
-        return ParagonIE_Sodium_Compat::pad($unpadded, $blockSize, true);
+        return ParagonIE_Sodium_Compat::pad( $unpadded, $blockSize, true );
     }
 }
-if (!is_callable('sodium_unpad')) {
+if ( ! is_callable( 'sodium_unpad' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::pad()
      * @param string $padded
@@ -1325,38 +1325,38 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_unpad($padded, $blockSize)
+    function sodium_unpad( $padded, $blockSize )
     {
-        return ParagonIE_Sodium_Compat::unpad($padded, $blockSize, true);
+        return ParagonIE_Sodium_Compat::unpad( $padded, $blockSize, true );
     }
 }
-if (!is_callable('sodium_randombytes_buf')) {
+if ( ! is_callable( 'sodium_randombytes_buf' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::randombytes_buf()
      * @param int $amount
      * @return string
      * @throws Exception
      */
-    function sodium_randombytes_buf($amount)
+    function sodium_randombytes_buf( $amount )
     {
-        return ParagonIE_Sodium_Compat::randombytes_buf($amount);
+        return ParagonIE_Sodium_Compat::randombytes_buf( $amount );
     }
 }
 
-if (!is_callable('sodium_randombytes_uniform')) {
+if ( ! is_callable( 'sodium_randombytes_uniform' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::randombytes_uniform()
      * @param int $upperLimit
      * @return int
      * @throws Exception
      */
-    function sodium_randombytes_uniform($upperLimit)
+    function sodium_randombytes_uniform( $upperLimit )
     {
-        return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
+        return ParagonIE_Sodium_Compat::randombytes_uniform( $upperLimit );
     }
 }
 
-if (!is_callable('sodium_randombytes_random16')) {
+if ( ! is_callable( 'sodium_randombytes_random16' ) ) {
     /**
      * @see ParagonIE_Sodium_Compat::randombytes_random16()
      * @return int

Braces +91 added lines, -182 removed lines

@@ -115,8 +115,7 @@ 
      * @return void
      * @throws SodiumException
      */
-    function sodium_add(&$val, $addv)
-    {
+    function sodium_add(&$val, $addv) {
         ParagonIE_Sodium_Compat::add($val, $addv);
     }
 }
@@ -130,8 +129,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_base642bin($string, $variant, $ignore ='')
-    {
+    function sodium_base642bin($string, $variant, $ignore ='') {
         return ParagonIE_Sodium_Compat::base642bin($string, $variant, $ignore);
     }
 }
@@ -144,8 +142,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_bin2base64($string, $variant)
-    {
+    function sodium_bin2base64($string, $variant) {
         return ParagonIE_Sodium_Compat::bin2base64($string, $variant);
     }
 }
@@ -157,8 +154,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_bin2hex($string)
-    {
+    function sodium_bin2hex($string) {
         return ParagonIE_Sodium_Compat::bin2hex($string);
     }
 }
@@ -171,8 +167,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_compare($a, $b)
-    {
+    function sodium_compare($a, $b) {
         return ParagonIE_Sodium_Compat::compare($a, $b);
     }
 }
@@ -185,8 +180,7 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key) {
         try {
             return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
         } catch (Error $ex) {
@@ -207,8 +201,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key) {
         return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_encrypt($message, $assocData, $nonce, $key);
     }
 }
@@ -217,8 +210,7 @@ 
      * @see ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available()
      * @return bool
      */
-    function sodium_crypto_aead_aes256gcm_is_available()
-    {
+    function sodium_crypto_aead_aes256gcm_is_available() {
         return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_is_available();
     }
 }
@@ -231,8 +223,7 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key) {
         try {
             return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
         } catch (Error $ex) {
@@ -253,8 +244,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key) {
         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_encrypt($message, $assocData, $nonce, $key);
     }
 }
@@ -264,8 +254,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_aead_chacha20poly1305_keygen()
-    {
+    function sodium_crypto_aead_chacha20poly1305_keygen() {
         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_keygen();
     }
 }
@@ -278,8 +267,7 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key) {
         try {
             return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
         } catch (Error $ex) {
@@ -300,8 +288,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key) {
         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key);
     }
 }
@@ -311,8 +298,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_aead_chacha20poly1305_ietf_keygen()
-    {
+    function sodium_crypto_aead_chacha20poly1305_ietf_keygen() {
         return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_keygen();
     }
 }
@@ -325,8 +311,7 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key) {
         try {
             return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key, true);
         } catch (Error $ex) {
@@ -347,8 +332,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key)
-    {
+    function sodium_crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key) {
         return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_encrypt($message, $assocData, $nonce, $key, true);
     }
 }
@@ -358,8 +342,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_aead_xchacha20poly1305_ietf_keygen()
-    {
+    function sodium_crypto_aead_xchacha20poly1305_ietf_keygen() {
         return ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_ietf_keygen();
     }
 }
@@ -372,8 +355,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_auth($message, $key)
-    {
+    function sodium_crypto_auth($message, $key) {
         return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
     }
 }
@@ -383,8 +365,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_auth_keygen()
-    {
+    function sodium_crypto_auth_keygen() {
         return ParagonIE_Sodium_Compat::crypto_auth_keygen();
     }
 }
@@ -398,8 +379,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_auth_verify($mac, $message, $key)
-    {
+    function sodium_crypto_auth_verify($mac, $message, $key) {
         return ParagonIE_Sodium_Compat::crypto_auth_verify($mac, $message, $key);
     }
 }
@@ -413,8 +393,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box($message, $nonce, $kp)
-    {
+    function sodium_crypto_box($message, $nonce, $kp) {
         return ParagonIE_Sodium_Compat::crypto_box($message, $nonce, $kp);
     }
 }
@@ -425,8 +404,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_keypair()
-    {
+    function sodium_crypto_box_keypair() {
         return ParagonIE_Sodium_Compat::crypto_box_keypair();
     }
 }
@@ -439,8 +417,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk)
-    {
+    function sodium_crypto_box_keypair_from_secretkey_and_publickey($sk, $pk) {
         return ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey($sk, $pk);
     }
 }
@@ -452,8 +429,7 @@ 
      * @param string $kp
      * @return string|bool
      */
-    function sodium_crypto_box_open($message, $nonce, $kp)
-    {
+    function sodium_crypto_box_open($message, $nonce, $kp) {
         try {
             return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
         } catch (Error $ex) {
@@ -471,8 +447,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_publickey($keypair)
-    {
+    function sodium_crypto_box_publickey($keypair) {
         return ParagonIE_Sodium_Compat::crypto_box_publickey($keypair);
     }
 }
@@ -484,8 +459,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_publickey_from_secretkey($sk)
-    {
+    function sodium_crypto_box_publickey_from_secretkey($sk) {
         return ParagonIE_Sodium_Compat::crypto_box_publickey_from_secretkey($sk);
     }
 }
@@ -498,8 +472,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_seal($message, $publicKey)
-    {
+    function sodium_crypto_box_seal($message, $publicKey) {
         return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
     }
 }
@@ -511,8 +484,7 @@ 
      * @return string|bool
      * @throws SodiumException
      */
-    function sodium_crypto_box_seal_open($message, $kp)
-    {
+    function sodium_crypto_box_seal_open($message, $kp) {
         try {
             return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
         } catch (SodiumException $ex) {
@@ -531,8 +503,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_secretkey($keypair)
-    {
+    function sodium_crypto_box_secretkey($keypair) {
         return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
     }
 }
@@ -544,8 +515,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_box_seed_keypair($seed)
-    {
+    function sodium_crypto_box_seed_keypair($seed) {
         return ParagonIE_Sodium_Compat::crypto_box_seed_keypair($seed);
     }
 }
@@ -559,8 +529,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash($message, $key = null, $outLen = 32)
-    {
+    function sodium_crypto_generichash($message, $key = null, $outLen = 32) {
         return ParagonIE_Sodium_Compat::crypto_generichash($message, $key, $outLen);
     }
 }
@@ -573,8 +542,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash_final(&$ctx, $outputLength = 32)
-    {
+    function sodium_crypto_generichash_final(&$ctx, $outputLength = 32) {
         return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
     }
 }
@@ -587,8 +555,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash_init($key = null, $outLen = 32)
-    {
+    function sodium_crypto_generichash_init($key = null, $outLen = 32) {
         return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
     }
 }
@@ -598,8 +565,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_generichash_keygen()
-    {
+    function sodium_crypto_generichash_keygen() {
         return ParagonIE_Sodium_Compat::crypto_generichash_keygen();
     }
 }
@@ -612,8 +578,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_generichash_update(&$ctx, $message = '')
-    {
+    function sodium_crypto_generichash_update(&$ctx, $message = '') {
         ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
     }
 }
@@ -623,8 +588,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kdf_keygen()
-    {
+    function sodium_crypto_kdf_keygen() {
         return ParagonIE_Sodium_Compat::crypto_kdf_keygen();
     }
 }
@@ -638,8 +602,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key)
-    {
+    function sodium_crypto_kdf_derive_from_key($subkey_len, $subkey_id, $context, $key) {
         return ParagonIE_Sodium_Compat::crypto_kdf_derive_from_key(
             $subkey_len,
             $subkey_id,
@@ -659,8 +622,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public)
-    {
+    function sodium_crypto_kx($my_secret, $their_public, $client_public, $server_public) {
         return ParagonIE_Sodium_Compat::crypto_kx(
             $my_secret,
             $their_public,
@@ -675,8 +637,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kx_seed_keypair($seed)
-    {
+    function sodium_crypto_kx_seed_keypair($seed) {
         return ParagonIE_Sodium_Compat::crypto_kx_seed_keypair($seed);
     }
 }
@@ -685,8 +646,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kx_keypair()
-    {
+    function sodium_crypto_kx_keypair() {
         return ParagonIE_Sodium_Compat::crypto_kx_keypair();
     }
 }
@@ -697,8 +657,7 @@ 
      * @return array{0: string, 1: string}
      * @throws SodiumException
      */
-    function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey)
-    {
+    function sodium_crypto_kx_client_session_keys($keypair, $serverPublicKey) {
         return ParagonIE_Sodium_Compat::crypto_kx_client_session_keys($keypair, $serverPublicKey);
     }
 }
@@ -709,8 +668,7 @@ 
      * @return array{0: string, 1: string}
      * @throws SodiumException
      */
-    function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey)
-    {
+    function sodium_crypto_kx_server_session_keys($keypair, $clientPublicKey) {
         return ParagonIE_Sodium_Compat::crypto_kx_server_session_keys($keypair, $clientPublicKey);
     }
 }
@@ -720,8 +678,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kx_secretkey($keypair)
-    {
+    function sodium_crypto_kx_secretkey($keypair) {
         return ParagonIE_Sodium_Compat::crypto_kx_secretkey($keypair);
     }
 }
@@ -731,8 +688,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_kx_publickey($keypair)
-    {
+    function sodium_crypto_kx_publickey($keypair) {
         return ParagonIE_Sodium_Compat::crypto_kx_publickey($keypair);
     }
 }
@@ -749,8 +705,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null)
-    {
+    function sodium_crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo = null) {
         return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit, $algo);
     }
 }
@@ -764,8 +719,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit)
-    {
+    function sodium_crypto_pwhash_str($passwd, $opslimit, $memlimit) {
         return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $opslimit, $memlimit);
     }
 }
@@ -779,8 +733,7 @@ 
      *
      * @throws SodiumException
      */
-    function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit)
-    {
+    function sodium_crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit) {
         return ParagonIE_Sodium_Compat::crypto_pwhash_str_needs_rehash($hash, $opslimit, $memlimit);
     }
 }
@@ -793,8 +746,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_str_verify($passwd, $hash)
-    {
+    function sodium_crypto_pwhash_str_verify($passwd, $hash) {
         return ParagonIE_Sodium_Compat::crypto_pwhash_str_verify($passwd, $hash);
     }
 }
@@ -810,8 +762,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit)
-    {
+    function sodium_crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit) {
         return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $memlimit);
     }
 }
@@ -825,8 +776,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit)
-    {
+    function sodium_crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit) {
         return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str($passwd, $opslimit, $memlimit);
     }
 }
@@ -839,8 +789,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash)
-    {
+    function sodium_crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash) {
         return ParagonIE_Sodium_Compat::crypto_pwhash_scryptsalsa208sha256_str_verify($passwd, $hash);
     }
 }
@@ -853,8 +802,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_scalarmult($n, $p)
-    {
+    function sodium_crypto_scalarmult($n, $p) {
         return ParagonIE_Sodium_Compat::crypto_scalarmult($n, $p);
     }
 }
@@ -866,8 +814,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_scalarmult_base($n)
-    {
+    function sodium_crypto_scalarmult_base($n) {
         return ParagonIE_Sodium_Compat::crypto_scalarmult_base($n);
     }
 }
@@ -881,8 +828,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_secretbox($message, $nonce, $key)
-    {
+    function sodium_crypto_secretbox($message, $nonce, $key) {
         return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
     }
 }
@@ -892,8 +838,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_secretbox_keygen()
-    {
+    function sodium_crypto_secretbox_keygen() {
         return ParagonIE_Sodium_Compat::crypto_secretbox_keygen();
     }
 }
@@ -905,8 +850,7 @@ 
      * @param string $key
      * @return string|bool
      */
-    function sodium_crypto_secretbox_open($message, $nonce, $key)
-    {
+    function sodium_crypto_secretbox_open($message, $nonce, $key) {
         try {
             return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
         } catch (Error $ex) {
@@ -922,8 +866,7 @@ 
      * @return array<int, string>
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_init_push($key)
-    {
+    function sodium_crypto_secretstream_xchacha20poly1305_init_push($key) {
         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_push($key);
     }
 }
@@ -936,8 +879,7 @@ 
      * @return string
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
-    {
+    function sodium_crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0) {
         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_push($state, $msg, $aad, $tag);
     }
 }
@@ -948,8 +890,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
-    {
+    function sodium_crypto_secretstream_xchacha20poly1305_init_pull($header, $key) {
         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_init_pull($header, $key);
     }
 }
@@ -961,8 +902,7 @@ 
      * @return bool|array{0: string, 1: int}
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
-    {
+    function sodium_crypto_secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '') {
         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_pull($state, $cipher, $aad);
     }
 }
@@ -972,8 +912,7 @@ 
      * @return void
      * @throws SodiumException
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_rekey(&$state)
-    {
+    function sodium_crypto_secretstream_xchacha20poly1305_rekey(&$state) {
         ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_rekey($state);
     }
 }
@@ -982,8 +921,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_secretstream_xchacha20poly1305_keygen()
-    {
+    function sodium_crypto_secretstream_xchacha20poly1305_keygen() {
         return ParagonIE_Sodium_Compat::crypto_secretstream_xchacha20poly1305_keygen();
     }
 }
@@ -996,8 +934,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_shorthash($message, $key = '')
-    {
+    function sodium_crypto_shorthash($message, $key = '') {
         return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
     }
 }
@@ -1007,8 +944,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_shorthash_keygen()
-    {
+    function sodium_crypto_shorthash_keygen() {
         return ParagonIE_Sodium_Compat::crypto_shorthash_keygen();
     }
 }
@@ -1021,8 +957,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign($message, $sk)
-    {
+    function sodium_crypto_sign($message, $sk) {
         return ParagonIE_Sodium_Compat::crypto_sign($message, $sk);
     }
 }
@@ -1035,8 +970,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_detached($message, $sk)
-    {
+    function sodium_crypto_sign_detached($message, $sk) {
         return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
     }
 }
@@ -1049,8 +983,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk)
-    {
+    function sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk) {
         return ParagonIE_Sodium_Compat::crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
     }
 }
@@ -1061,8 +994,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_keypair()
-    {
+    function sodium_crypto_sign_keypair() {
         return ParagonIE_Sodium_Compat::crypto_sign_keypair();
     }
 }
@@ -1073,8 +1005,7 @@ 
      * @param string $pk
      * @return string|bool
      */
-    function sodium_crypto_sign_open($signedMessage, $pk)
-    {
+    function sodium_crypto_sign_open($signedMessage, $pk) {
         try {
             return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
         } catch (Error $ex) {
@@ -1092,8 +1023,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_publickey($keypair)
-    {
+    function sodium_crypto_sign_publickey($keypair) {
         return ParagonIE_Sodium_Compat::crypto_sign_publickey($keypair);
     }
 }
@@ -1105,8 +1035,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_publickey_from_secretkey($sk)
-    {
+    function sodium_crypto_sign_publickey_from_secretkey($sk) {
         return ParagonIE_Sodium_Compat::crypto_sign_publickey_from_secretkey($sk);
     }
 }
@@ -1118,8 +1047,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_secretkey($keypair)
-    {
+    function sodium_crypto_sign_secretkey($keypair) {
         return ParagonIE_Sodium_Compat::crypto_sign_secretkey($keypair);
     }
 }
@@ -1131,8 +1059,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_seed_keypair($seed)
-    {
+    function sodium_crypto_sign_seed_keypair($seed) {
         return ParagonIE_Sodium_Compat::crypto_sign_seed_keypair($seed);
     }
 }
@@ -1146,8 +1073,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_verify_detached($signature, $message, $pk)
-    {
+    function sodium_crypto_sign_verify_detached($signature, $message, $pk) {
         return ParagonIE_Sodium_Compat::crypto_sign_verify_detached($signature, $message, $pk);
     }
 }
@@ -1159,8 +1085,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_ed25519_pk_to_curve25519($pk)
-    {
+    function sodium_crypto_sign_ed25519_pk_to_curve25519($pk) {
         return ParagonIE_Sodium_Compat::crypto_sign_ed25519_pk_to_curve25519($pk);
     }
 }
@@ -1172,8 +1097,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_sign_ed25519_sk_to_curve25519($sk)
-    {
+    function sodium_crypto_sign_ed25519_sk_to_curve25519($sk) {
         return ParagonIE_Sodium_Compat::crypto_sign_ed25519_sk_to_curve25519($sk);
     }
 }
@@ -1187,8 +1111,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_stream($len, $nonce, $key)
-    {
+    function sodium_crypto_stream($len, $nonce, $key) {
         return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
     }
 }
@@ -1198,8 +1121,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_crypto_stream_keygen()
-    {
+    function sodium_crypto_stream_keygen() {
         return ParagonIE_Sodium_Compat::crypto_stream_keygen();
     }
 }
@@ -1213,8 +1135,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_crypto_stream_xor($message, $nonce, $key)
-    {
+    function sodium_crypto_stream_xor($message, $nonce, $key) {
         return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
     }
 }
@@ -1227,8 +1148,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_hex2bin($string)
-    {
+    function sodium_hex2bin($string) {
         return ParagonIE_Sodium_Compat::hex2bin($string);
     }
 }
@@ -1240,8 +1160,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_increment(&$string)
-    {
+    function sodium_increment(&$string) {
         ParagonIE_Sodium_Compat::increment($string);
     }
 }
@@ -1250,8 +1169,7 @@ 
      * @see ParagonIE_Sodium_Compat::library_version_major()
      * @return int
      */
-    function sodium_library_version_major()
-    {
+    function sodium_library_version_major() {
         return ParagonIE_Sodium_Compat::library_version_major();
     }
 }
@@ -1260,8 +1178,7 @@ 
      * @see ParagonIE_Sodium_Compat::library_version_minor()
      * @return int
      */
-    function sodium_library_version_minor()
-    {
+    function sodium_library_version_minor() {
         return ParagonIE_Sodium_Compat::library_version_minor();
     }
 }
@@ -1270,8 +1187,7 @@ 
      * @see ParagonIE_Sodium_Compat::version_string()
      * @return string
      */
-    function sodium_version_string()
-    {
+    function sodium_version_string() {
         return ParagonIE_Sodium_Compat::version_string();
     }
 }
@@ -1284,8 +1200,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_memcmp($a, $b)
-    {
+    function sodium_memcmp($a, $b) {
         return ParagonIE_Sodium_Compat::memcmp($a, $b);
     }
 }
@@ -1297,8 +1212,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_memzero(&$str)
-    {
+    function sodium_memzero(&$str) {
         ParagonIE_Sodium_Compat::memzero($str);
     }
 }
@@ -1311,8 +1225,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_pad($unpadded, $blockSize)
-    {
+    function sodium_pad($unpadded, $blockSize) {
         return ParagonIE_Sodium_Compat::pad($unpadded, $blockSize, true);
     }
 }
@@ -1325,8 +1238,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    function sodium_unpad($padded, $blockSize)
-    {
+    function sodium_unpad($padded, $blockSize) {
         return ParagonIE_Sodium_Compat::unpad($padded, $blockSize, true);
     }
 }
@@ -1337,8 +1249,7 @@ 
      * @return string
      * @throws Exception
      */
-    function sodium_randombytes_buf($amount)
-    {
+    function sodium_randombytes_buf($amount) {
         return ParagonIE_Sodium_Compat::randombytes_buf($amount);
     }
 }
@@ -1350,8 +1261,7 @@ 
      * @return int
      * @throws Exception
      */
-    function sodium_randombytes_uniform($upperLimit)
-    {
+    function sodium_randombytes_uniform($upperLimit) {
         return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
     }
 }
@@ -1362,8 +1272,7 @@ 
      * @return int
      * @throws Exception
      */
-    function sodium_randombytes_random16()
-    {
+    function sodium_randombytes_random16() {
         return ParagonIE_Sodium_Compat::randombytes_random16();
     }
 }

vendor/paragonie/sodium_compat/autoload-pedantic.php

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
 require_once 'autoload.php';
-define('DO_PEDANTIC_TEST', true);
+define( 'DO_PEDANTIC_TEST', true );
 
 ParagonIE_Sodium_Compat::$fastMult = true;

vendor/paragonie/sodium_compat/autoload.php

Indentation +51 added lines, -51 removed lines

@@ -1,72 +1,72 @@
 <?php
 
 if (PHP_VERSION_ID < 70000) {
-    if (!is_callable('sodiumCompatAutoloader')) {
-        /**
-         * Sodium_Compat autoloader.
-         *
-         * @param string $class Class name to be autoloaded.
-         *
-         * @return bool         Stop autoloading?
-         */
-        function sodiumCompatAutoloader($class)
-        {
-            $namespace = 'ParagonIE_Sodium_';
-            // Does the class use the namespace prefix?
-            $len = strlen($namespace);
-            if (strncmp($namespace, $class, $len) !== 0) {
-                // no, move to the next registered autoloader
-                return false;
-            }
+	if (!is_callable('sodiumCompatAutoloader')) {
+		/**
+		 * Sodium_Compat autoloader.
+		 *
+		 * @param string $class Class name to be autoloaded.
+		 *
+		 * @return bool         Stop autoloading?
+		 */
+		function sodiumCompatAutoloader($class)
+		{
+			$namespace = 'ParagonIE_Sodium_';
+			// Does the class use the namespace prefix?
+			$len = strlen($namespace);
+			if (strncmp($namespace, $class, $len) !== 0) {
+				// no, move to the next registered autoloader
+				return false;
+			}
 
-            // Get the relative class name
-            $relative_class = substr($class, $len);
+			// Get the relative class name
+			$relative_class = substr($class, $len);
 
-            // Replace the namespace prefix with the base directory, replace namespace
-            // separators with directory separators in the relative class name, append
-            // with .php
-            $file = dirname(__FILE__) . '/src/' . str_replace('_', '/', $relative_class) . '.php';
-            // if the file exists, require it
-            if (file_exists($file)) {
-                require_once $file;
-                return true;
-            }
-            return false;
-        }
+			// Replace the namespace prefix with the base directory, replace namespace
+			// separators with directory separators in the relative class name, append
+			// with .php
+			$file = dirname(__FILE__) . '/src/' . str_replace('_', '/', $relative_class) . '.php';
+			// if the file exists, require it
+			if (file_exists($file)) {
+				require_once $file;
+				return true;
+			}
+			return false;
+		}
 
-        // Now that we have an autoloader, let's register it!
-        spl_autoload_register('sodiumCompatAutoloader');
-    }
+		// Now that we have an autoloader, let's register it!
+		spl_autoload_register('sodiumCompatAutoloader');
+	}
 } else {
-    require_once dirname(__FILE__) . '/autoload-php7.php';
+	require_once dirname(__FILE__) . '/autoload-php7.php';
 }
 
 /* Explicitly, always load the Compat class: */
 require_once dirname(__FILE__) . '/src/Compat.php';
 
 if (!class_exists('SodiumException', false)) {
-    require_once dirname(__FILE__) . '/src/SodiumException.php';
+	require_once dirname(__FILE__) . '/src/SodiumException.php';
 }
 if (PHP_VERSION_ID >= 50300) {
-    // Namespaces didn't exist before 5.3.0, so don't even try to use this
-    // unless PHP >= 5.3.0
-    require_once dirname(__FILE__) . '/lib/namespaced.php';
-    require_once dirname(__FILE__) . '/lib/sodium_compat.php';
+	// Namespaces didn't exist before 5.3.0, so don't even try to use this
+	// unless PHP >= 5.3.0
+	require_once dirname(__FILE__) . '/lib/namespaced.php';
+	require_once dirname(__FILE__) . '/lib/sodium_compat.php';
 } else {
-    require_once dirname(__FILE__) . '/src/PHP52/SplFixedArray.php';
+	require_once dirname(__FILE__) . '/src/PHP52/SplFixedArray.php';
 }
 if (PHP_VERSION_ID < 70200 || !extension_loaded('sodium')) {
-    if (PHP_VERSION_ID >= 50300 && !defined('SODIUM_CRYPTO_SCALARMULT_BYTES')) {
-        require_once dirname(__FILE__) . '/lib/php72compat_const.php';
-    }
-    if (PHP_VERSION_ID >= 70000) {
-        assert(class_exists('ParagonIE_Sodium_Compat'), 'Possible filesystem/autoloader bug?');
-    } else {
-        assert(class_exists('ParagonIE_Sodium_Compat'));
-    }
-    require_once(dirname(__FILE__) . '/lib/php72compat.php');
+	if (PHP_VERSION_ID >= 50300 && !defined('SODIUM_CRYPTO_SCALARMULT_BYTES')) {
+		require_once dirname(__FILE__) . '/lib/php72compat_const.php';
+	}
+	if (PHP_VERSION_ID >= 70000) {
+		assert(class_exists('ParagonIE_Sodium_Compat'), 'Possible filesystem/autoloader bug?');
+	} else {
+		assert(class_exists('ParagonIE_Sodium_Compat'));
+	}
+	require_once(dirname(__FILE__) . '/lib/php72compat.php');
 } elseif (!function_exists('sodium_crypto_stream_xchacha20_xor')) {
-    // Older versions of {PHP, ext/sodium} will not define these
-    require_once(dirname(__FILE__) . '/lib/php72compat.php');
+	// Older versions of {PHP, ext/sodium} will not define these
+	require_once(dirname(__FILE__) . '/lib/php72compat.php');
 }
 require_once(dirname(__FILE__) . '/lib/ristretto255.php');

Spacing +27 added lines, -27 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
-if (PHP_VERSION_ID < 70000) {
-    if (!is_callable('sodiumCompatAutoloader')) {
+if ( PHP_VERSION_ID < 70000 ) {
+    if ( ! is_callable( 'sodiumCompatAutoloader' ) ) {
         /**
          * Sodium_Compat autoloader.
          *
@@ -9,25 +9,25 @@ 
          *
          * @return bool         Stop autoloading?
          */
-        function sodiumCompatAutoloader($class)
+        function sodiumCompatAutoloader( $class )
         {
             $namespace = 'ParagonIE_Sodium_';
             // Does the class use the namespace prefix?
-            $len = strlen($namespace);
-            if (strncmp($namespace, $class, $len) !== 0) {
+            $len = strlen( $namespace );
+            if ( strncmp( $namespace, $class, $len ) !== 0 ) {
                 // no, move to the next registered autoloader
                 return false;
             }
 
             // Get the relative class name
-            $relative_class = substr($class, $len);
+            $relative_class = substr( $class, $len );
 
             // Replace the namespace prefix with the base directory, replace namespace
             // separators with directory separators in the relative class name, append
             // with .php
-            $file = dirname(__FILE__) . '/src/' . str_replace('_', '/', $relative_class) . '.php';
+            $file = dirname( __FILE__ ) . '/src/' . str_replace( '_', '/', $relative_class ) . '.php';
             // if the file exists, require it
-            if (file_exists($file)) {
+            if ( file_exists( $file ) ) {
                 require_once $file;
                 return true;
             }
@@ -35,38 +35,38 @@ 
         }
 
         // Now that we have an autoloader, let's register it!
-        spl_autoload_register('sodiumCompatAutoloader');
+        spl_autoload_register( 'sodiumCompatAutoloader' );
     }
 } else {
-    require_once dirname(__FILE__) . '/autoload-php7.php';
+    require_once dirname( __FILE__ ) . '/autoload-php7.php';
 }
 
 /* Explicitly, always load the Compat class: */
-require_once dirname(__FILE__) . '/src/Compat.php';
+require_once dirname( __FILE__ ) . '/src/Compat.php';
 
-if (!class_exists('SodiumException', false)) {
-    require_once dirname(__FILE__) . '/src/SodiumException.php';
+if ( ! class_exists( 'SodiumException', false ) ) {
+    require_once dirname( __FILE__ ) . '/src/SodiumException.php';
 }
-if (PHP_VERSION_ID >= 50300) {
+if ( PHP_VERSION_ID >= 50300 ) {
     // Namespaces didn't exist before 5.3.0, so don't even try to use this
     // unless PHP >= 5.3.0
-    require_once dirname(__FILE__) . '/lib/namespaced.php';
-    require_once dirname(__FILE__) . '/lib/sodium_compat.php';
+    require_once dirname( __FILE__ ) . '/lib/namespaced.php';
+    require_once dirname( __FILE__ ) . '/lib/sodium_compat.php';
 } else {
-    require_once dirname(__FILE__) . '/src/PHP52/SplFixedArray.php';
+    require_once dirname( __FILE__ ) . '/src/PHP52/SplFixedArray.php';
 }
-if (PHP_VERSION_ID < 70200 || !extension_loaded('sodium')) {
-    if (PHP_VERSION_ID >= 50300 && !defined('SODIUM_CRYPTO_SCALARMULT_BYTES')) {
-        require_once dirname(__FILE__) . '/lib/php72compat_const.php';
+if ( PHP_VERSION_ID < 70200 || ! extension_loaded( 'sodium' ) ) {
+    if ( PHP_VERSION_ID >= 50300 && ! defined( 'SODIUM_CRYPTO_SCALARMULT_BYTES' ) ) {
+        require_once dirname( __FILE__ ) . '/lib/php72compat_const.php';
     }
-    if (PHP_VERSION_ID >= 70000) {
-        assert(class_exists('ParagonIE_Sodium_Compat'), 'Possible filesystem/autoloader bug?');
+    if ( PHP_VERSION_ID >= 70000 ) {
+        assert( class_exists( 'ParagonIE_Sodium_Compat' ), 'Possible filesystem/autoloader bug?' );
     } else {
-        assert(class_exists('ParagonIE_Sodium_Compat'));
+        assert( class_exists( 'ParagonIE_Sodium_Compat' ) );
     }
-    require_once(dirname(__FILE__) . '/lib/php72compat.php');
-} elseif (!function_exists('sodium_crypto_stream_xchacha20_xor')) {
+    require_once( dirname( __FILE__ ) . '/lib/php72compat.php' );
+} elseif ( ! function_exists( 'sodium_crypto_stream_xchacha20_xor' ) ) {
     // Older versions of {PHP, ext/sodium} will not define these
-    require_once(dirname(__FILE__) . '/lib/php72compat.php');
+    require_once( dirname( __FILE__ ) . '/lib/php72compat.php' );
 }
-require_once(dirname(__FILE__) . '/lib/ristretto255.php');
+require_once( dirname( __FILE__ ) . '/lib/ristretto255.php' );

Braces +1 added lines, -2 removed lines

@@ -9,8 +9,7 @@
          *
          * @return bool         Stop autoloading?
          */
-        function sodiumCompatAutoloader($class)
-        {
+        function sodiumCompatAutoloader($class) {
             $namespace = 'ParagonIE_Sodium_';
             // Does the class use the namespace prefix?
             $len = strlen($namespace);

vendor/paragonie/sodium_compat/autoload-php7.php

Indentation +20 added lines, -20 removed lines

@@ -3,29 +3,29 @@
  This file should only ever be loaded on PHP 7+
  */
 if (PHP_VERSION_ID < 70000) {
-    return;
+	return;
 }
 
 spl_autoload_register(function ($class) {
-    $namespace = 'ParagonIE_Sodium_';
-    // Does the class use the namespace prefix?
-    $len = strlen($namespace);
-    if (strncmp($namespace, $class, $len) !== 0) {
-        // no, move to the next registered autoloader
-        return false;
-    }
+	$namespace = 'ParagonIE_Sodium_';
+	// Does the class use the namespace prefix?
+	$len = strlen($namespace);
+	if (strncmp($namespace, $class, $len) !== 0) {
+		// no, move to the next registered autoloader
+		return false;
+	}
 
-    // Get the relative class name
-    $relative_class = substr($class, $len);
+	// Get the relative class name
+	$relative_class = substr($class, $len);
 
-    // Replace the namespace prefix with the base directory, replace namespace
-    // separators with directory separators in the relative class name, append
-    // with .php
-    $file = dirname(__FILE__) . '/src/' . str_replace('_', '/', $relative_class) . '.php';
-    // if the file exists, require it
-    if (file_exists($file)) {
-        require_once $file;
-        return true;
-    }
-    return false;
+	// Replace the namespace prefix with the base directory, replace namespace
+	// separators with directory separators in the relative class name, append
+	// with .php
+	$file = dirname(__FILE__) . '/src/' . str_replace('_', '/', $relative_class) . '.php';
+	// if the file exists, require it
+	if (file_exists($file)) {
+		require_once $file;
+		return true;
+	}
+	return false;
 });

Spacing +7 added lines, -7 removed lines

@@ -2,28 +2,28 @@
 /*
  This file should only ever be loaded on PHP 7+
  */
-if (PHP_VERSION_ID < 70000) {
+if ( PHP_VERSION_ID < 70000 ) {
     return;
 }
 
-spl_autoload_register(function ($class) {
+spl_autoload_register( function( $class ) {
     $namespace = 'ParagonIE_Sodium_';
     // Does the class use the namespace prefix?
-    $len = strlen($namespace);
-    if (strncmp($namespace, $class, $len) !== 0) {
+    $len = strlen( $namespace );
+    if ( strncmp( $namespace, $class, $len ) !== 0 ) {
         // no, move to the next registered autoloader
         return false;
     }
 
     // Get the relative class name
-    $relative_class = substr($class, $len);
+    $relative_class = substr( $class, $len );
 
     // Replace the namespace prefix with the base directory, replace namespace
     // separators with directory separators in the relative class name, append
     // with .php
-    $file = dirname(__FILE__) . '/src/' . str_replace('_', '/', $relative_class) . '.php';
+    $file = dirname( __FILE__ ) . '/src/' . str_replace( '_', '/', $relative_class ) . '.php';
     // if the file exists, require it
-    if (file_exists($file)) {
+    if ( file_exists( $file ) ) {
         require_once $file;
         return true;
     }

vendor/paragonie/sodium_compat/autoload-phpunit.php

Indentation +1 added lines, -1 removed lines

@@ -3,6 +3,6 @@
 require_once (dirname(__FILE__) . '/vendor/autoload.php');
 
 if (PHP_VERSION_ID >= 50300) {
-    require_once (dirname(__FILE__) . '/tests/phpunit-shim.php');
+	require_once (dirname(__FILE__) . '/tests/phpunit-shim.php');
 }
 require_once (dirname(__FILE__) . '/autoload.php');

Spacing +4 added lines, -4 removed lines

@@ -1,8 +1,8 @@
 <?php
 
-require_once (dirname(__FILE__) . '/vendor/autoload.php');
+require_once ( dirname( __FILE__ ) . '/vendor/autoload.php' );
 
-if (PHP_VERSION_ID >= 50300) {
-    require_once (dirname(__FILE__) . '/tests/phpunit-shim.php');
+if ( PHP_VERSION_ID >= 50300 ) {
+    require_once ( dirname( __FILE__ ) . '/tests/phpunit-shim.php' );
 }
-require_once (dirname(__FILE__) . '/autoload.php');
+require_once ( dirname( __FILE__ ) . '/autoload.php' );

vendor/paragonie/sodium_compat/src/Crypto.php

Indentation +1639 added lines, -1639 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('ParagonIE_Sodium_Crypto', false)) {
-    return;
+	return;
 }
 
 /**
@@ -14,1642 +14,1642 @@ 
  */
 abstract class ParagonIE_Sodium_Crypto
 {
-    const aead_chacha20poly1305_KEYBYTES = 32;
-    const aead_chacha20poly1305_NSECBYTES = 0;
-    const aead_chacha20poly1305_NPUBBYTES = 8;
-    const aead_chacha20poly1305_ABYTES = 16;
-
-    const aead_chacha20poly1305_IETF_KEYBYTES = 32;
-    const aead_chacha20poly1305_IETF_NSECBYTES = 0;
-    const aead_chacha20poly1305_IETF_NPUBBYTES = 12;
-    const aead_chacha20poly1305_IETF_ABYTES = 16;
-
-    const aead_xchacha20poly1305_IETF_KEYBYTES = 32;
-    const aead_xchacha20poly1305_IETF_NSECBYTES = 0;
-    const aead_xchacha20poly1305_IETF_NPUBBYTES = 24;
-    const aead_xchacha20poly1305_IETF_ABYTES = 16;
-
-    const box_curve25519xsalsa20poly1305_SEEDBYTES = 32;
-    const box_curve25519xsalsa20poly1305_PUBLICKEYBYTES = 32;
-    const box_curve25519xsalsa20poly1305_SECRETKEYBYTES = 32;
-    const box_curve25519xsalsa20poly1305_BEFORENMBYTES = 32;
-    const box_curve25519xsalsa20poly1305_NONCEBYTES = 24;
-    const box_curve25519xsalsa20poly1305_MACBYTES = 16;
-    const box_curve25519xsalsa20poly1305_BOXZEROBYTES = 16;
-    const box_curve25519xsalsa20poly1305_ZEROBYTES = 32;
-
-    const onetimeauth_poly1305_BYTES = 16;
-    const onetimeauth_poly1305_KEYBYTES = 32;
-
-    const secretbox_xsalsa20poly1305_KEYBYTES = 32;
-    const secretbox_xsalsa20poly1305_NONCEBYTES = 24;
-    const secretbox_xsalsa20poly1305_MACBYTES = 16;
-    const secretbox_xsalsa20poly1305_BOXZEROBYTES = 16;
-    const secretbox_xsalsa20poly1305_ZEROBYTES = 32;
-
-    const secretbox_xchacha20poly1305_KEYBYTES = 32;
-    const secretbox_xchacha20poly1305_NONCEBYTES = 24;
-    const secretbox_xchacha20poly1305_MACBYTES = 16;
-    const secretbox_xchacha20poly1305_BOXZEROBYTES = 16;
-    const secretbox_xchacha20poly1305_ZEROBYTES = 32;
-
-    const stream_salsa20_KEYBYTES = 32;
-
-    /**
-     * AEAD Decryption with ChaCha20-Poly1305
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $ad
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function aead_chacha20poly1305_decrypt(
-        $message = '',
-        $ad = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        /** @var int $len - Length of message (ciphertext + MAC) */
-        $len = ParagonIE_Sodium_Core_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_Core_Util::strlen($ad);
-
-        /** @var string $mac - Message authentication code */
-        $mac = ParagonIE_Sodium_Core_Util::substr(
-            $message,
-            $clen,
-            self::aead_chacha20poly1305_ABYTES
-        );
-
-        /** @var string $ciphertext - The encrypted message (sans MAC) */
-        $ciphertext = ParagonIE_Sodium_Core_Util::substr($message, 0, $clen);
-
-        /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
-        $block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
-            32,
-            $nonce,
-            $key
-        );
-
-        /* Recalculate the Poly1305 authentication tag (MAC): */
-        $state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
-        try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-        } catch (SodiumException $ex) {
-            $block0 = null;
-        }
-        $state->update($ad);
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($adlen));
-        $state->update($ciphertext);
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($clen));
-        $computed_mac = $state->finish();
-
-        /* Compare the given MAC with the recalculated MAC: */
-        if (!ParagonIE_Sodium_Core_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
-        return ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
-            $ciphertext,
-            $nonce,
-            $key,
-            ParagonIE_Sodium_Core_Util::store64_le(1)
-        );
-    }
-
-    /**
-     * AEAD Encryption with ChaCha20-Poly1305
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $ad
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function aead_chacha20poly1305_encrypt(
-        $message = '',
-        $ad = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        /** @var int $len - Length of the plaintext message */
-        $len = ParagonIE_Sodium_Core_Util::strlen($message);
-
-        /** @var int $adlen - Length of the associated data */
-        $adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
-
-        /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
-        $block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
-            32,
-            $nonce,
-            $key
-        );
-        $state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
-        try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-        } catch (SodiumException $ex) {
-            $block0 = null;
-        }
-
-        /** @var string $ciphertext - Raw encrypted data */
-        $ciphertext = ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
-            $message,
-            $nonce,
-            $key,
-            ParagonIE_Sodium_Core_Util::store64_le(1)
-        );
-
-        $state->update($ad);
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($adlen));
-        $state->update($ciphertext);
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($len));
-        return $ciphertext . $state->finish();
-    }
-
-    /**
-     * AEAD Decryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $ad
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function aead_chacha20poly1305_ietf_decrypt(
-        $message = '',
-        $ad = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        /** @var int $adlen - Length of associated data */
-        $adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
-
-        /** @var int $len - Length of message (ciphertext + MAC) */
-        $len = ParagonIE_Sodium_Core_Util::strlen($message);
-
-        /** @var int  $clen - Length of ciphertext */
-        $clen = $len - self::aead_chacha20poly1305_IETF_ABYTES;
-
-        /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
-        $block0 = ParagonIE_Sodium_Core_ChaCha20::ietfStream(
-            32,
-            $nonce,
-            $key
-        );
-
-        /** @var string $mac - Message authentication code */
-        $mac = ParagonIE_Sodium_Core_Util::substr(
-            $message,
-            $len - self::aead_chacha20poly1305_IETF_ABYTES,
-            self::aead_chacha20poly1305_IETF_ABYTES
-        );
-
-        /** @var string $ciphertext - The encrypted message (sans MAC) */
-        $ciphertext = ParagonIE_Sodium_Core_Util::substr(
-            $message,
-            0,
-            $len - self::aead_chacha20poly1305_IETF_ABYTES
-        );
-
-        /* Recalculate the Poly1305 authentication tag (MAC): */
-        $state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
-        try {
-            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_Core_Util::store64_le($adlen));
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($clen));
-        $computed_mac = $state->finish();
-
-        /* Compare the given MAC with the recalculated MAC: */
-        if (!ParagonIE_Sodium_Core_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
-        return ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
-            $ciphertext,
-            $nonce,
-            $key,
-            ParagonIE_Sodium_Core_Util::store64_le(1)
-        );
-    }
-
-    /**
-     * AEAD Encryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $ad
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function aead_chacha20poly1305_ietf_encrypt(
-        $message = '',
-        $ad = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        /** @var int $len - Length of the plaintext message */
-        $len = ParagonIE_Sodium_Core_Util::strlen($message);
-
-        /** @var int $adlen - Length of the associated data */
-        $adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
-
-        /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
-        $block0 = ParagonIE_Sodium_Core_ChaCha20::ietfStream(
-            32,
-            $nonce,
-            $key
-        );
-        $state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
-        try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-        } catch (SodiumException $ex) {
-            $block0 = null;
-        }
-
-        /** @var string $ciphertext - Raw encrypted data */
-        $ciphertext = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
-            $message,
-            $nonce,
-            $key,
-            ParagonIE_Sodium_Core_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_Core_Util::store64_le($adlen));
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($len));
-        return $ciphertext . $state->finish();
-    }
-
-    /**
-     * AEAD Decryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $ad
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function aead_xchacha20poly1305_ietf_decrypt(
-        $message = '',
-        $ad = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        $subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
-            $key
-        );
-        $nonceLast = "\x00\x00\x00\x00" .
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
-
-        return self::aead_chacha20poly1305_ietf_decrypt($message, $ad, $nonceLast, $subkey);
-    }
-
-    /**
-     * AEAD Encryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $ad
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function aead_xchacha20poly1305_ietf_encrypt(
-        $message = '',
-        $ad = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        $subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
-            $key
-        );
-        $nonceLast = "\x00\x00\x00\x00" .
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
-
-        return self::aead_chacha20poly1305_ietf_encrypt($message, $ad, $nonceLast, $subkey);
-    }
-
-    /**
-     * HMAC-SHA-512-256 (a.k.a. the leftmost 256 bits of HMAC-SHA-512)
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $key
-     * @return string
-     * @throws TypeError
-     */
-    public static function auth($message, $key)
-    {
-        return ParagonIE_Sodium_Core_Util::substr(
-            hash_hmac('sha512', $message, $key, true),
-            0,
-            32
-        );
-    }
-
-    /**
-     * HMAC-SHA-512-256 validation. Constant-time via hash_equals().
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $mac
-     * @param string $message
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function auth_verify($mac, $message, $key)
-    {
-        return ParagonIE_Sodium_Core_Util::hashEquals(
-            $mac,
-            self::auth($message, $key)
-        );
-    }
-
-    /**
-     * X25519 key exchange followed by XSalsa20Poly1305 symmetric encryption
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $plaintext
-     * @param string $nonce
-     * @param string $keypair
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box($plaintext, $nonce, $keypair)
-    {
-        $c = self::secretbox(
-            $plaintext,
-            $nonce,
-            self::box_beforenm(
-                self::box_secretkey($keypair),
-                self::box_publickey($keypair)
-            )
-        );
-        return $c;
-    }
-
-    /**
-     * X25519-XSalsa20-Poly1305 with one ephemeral X25519 keypair.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $publicKey
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_seal($message, $publicKey)
-    {
-        /** @var string $ephemeralKeypair */
-        $ephemeralKeypair = self::box_keypair();
-
-        /** @var string $ephemeralSK */
-        $ephemeralSK = self::box_secretkey($ephemeralKeypair);
-
-        /** @var string $ephemeralPK */
-        $ephemeralPK = self::box_publickey($ephemeralKeypair);
-
-        /** @var string $nonce */
-        $nonce = self::generichash(
-            $ephemeralPK . $publicKey,
-            '',
-            24
-        );
-
-        /** @var string $keypair - The combined keypair used in crypto_box() */
-        $keypair = self::box_keypair_from_secretkey_and_publickey($ephemeralSK, $publicKey);
-
-        /** @var string $ciphertext Ciphertext + MAC from crypto_box */
-        $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) {
-            $ephemeralKeypair = null;
-            $ephemeralSK = null;
-            $nonce = null;
-        }
-        return $ephemeralPK . $ciphertext;
-    }
-
-    /**
-     * Opens a message encrypted via box_seal().
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $keypair
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_seal_open($message, $keypair)
-    {
-        /** @var string $ephemeralPK */
-        $ephemeralPK = ParagonIE_Sodium_Core_Util::substr($message, 0, 32);
-
-        /** @var string $ciphertext (ciphertext + MAC) */
-        $ciphertext = ParagonIE_Sodium_Core_Util::substr($message, 32);
-
-        /** @var string $secretKey */
-        $secretKey = self::box_secretkey($keypair);
-
-        /** @var string $publicKey */
-        $publicKey = self::box_publickey($keypair);
-
-        /** @var string $nonce */
-        $nonce = self::generichash(
-            $ephemeralPK . $publicKey,
-            '',
-            24
-        );
-
-        /** @var string $keypair */
-        $keypair = self::box_keypair_from_secretkey_and_publickey($secretKey, $ephemeralPK);
-
-        /** @var string $m */
-        $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) {
-            $secretKey = null;
-            $ephemeralPK = null;
-            $nonce = null;
-        }
-        return $m;
-    }
-
-    /**
-     * Used by crypto_box() to get the crypto_secretbox() key.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $sk
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_beforenm($sk, $pk)
-    {
-        return ParagonIE_Sodium_Core_HSalsa20::hsalsa20(
-            str_repeat("\x00", 16),
-            self::scalarmult($sk, $pk)
-        );
-    }
-
-    /**
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @return string
-     * @throws Exception
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_keypair()
-    {
-        $sKey = random_bytes(32);
-        $pKey = self::scalarmult_base($sKey);
-        return $sKey . $pKey;
-    }
-
-    /**
-     * @param string $seed
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_seed_keypair($seed)
-    {
-        $sKey = ParagonIE_Sodium_Core_Util::substr(
-            hash('sha512', $seed, true),
-            0,
-            32
-        );
-        $pKey = self::scalarmult_base($sKey);
-        return $sKey . $pKey;
-    }
-
-    /**
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $sKey
-     * @param string $pKey
-     * @return string
-     * @throws TypeError
-     */
-    public static function box_keypair_from_secretkey_and_publickey($sKey, $pKey)
-    {
-        return ParagonIE_Sodium_Core_Util::substr($sKey, 0, 32) .
-            ParagonIE_Sodium_Core_Util::substr($pKey, 0, 32);
-    }
-
-    /**
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $keypair
-     * @return string
-     * @throws RangeException
-     * @throws TypeError
-     */
-    public static function box_secretkey($keypair)
-    {
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== 64) {
-            throw new RangeException(
-                'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES bytes long.'
-            );
-        }
-        return ParagonIE_Sodium_Core_Util::substr($keypair, 0, 32);
-    }
-
-    /**
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $keypair
-     * @return string
-     * @throws RangeException
-     * @throws TypeError
-     */
-    public static function box_publickey($keypair)
-    {
-        if (ParagonIE_Sodium_Core_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_Core_Util::substr($keypair, 32, 32);
-    }
-
-    /**
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $sKey
-     * @return string
-     * @throws RangeException
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_publickey_from_secretkey($sKey)
-    {
-        if (ParagonIE_Sodium_Core_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);
-    }
-
-    /**
-     * Decrypt a message encrypted with box().
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $ciphertext
-     * @param string $nonce
-     * @param string $keypair
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    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)
-            )
-        );
-    }
-
-    /**
-     * Calculate a BLAKE2b hash.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string|null $key
-     * @param int $outlen
-     * @return string
-     * @throws RangeException
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function generichash($message, $key = '', $outlen = 32)
-    {
-        // This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
-        ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
-
-        $k = null;
-        if (!empty($key)) {
-            /** @var SplFixedArray $k */
-            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
-            }
-        }
-
-        /** @var SplFixedArray $in */
-        $in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($message);
-
-        /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outlen);
-        ParagonIE_Sodium_Core_BLAKE2b::update($ctx, $in, $in->count());
-
-        /** @var SplFixedArray $out */
-        $out = new SplFixedArray($outlen);
-        $out = ParagonIE_Sodium_Core_BLAKE2b::finish($ctx, $out);
-
-        /** @var array<int, int> */
-        $outArray = $out->toArray();
-        return ParagonIE_Sodium_Core_Util::intArrayToString($outArray);
-    }
-
-    /**
-     * Finalize a BLAKE2b hashing context, returning the hash.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $ctx
-     * @param int $outlen
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function generichash_final($ctx, $outlen = 32)
-    {
-        if (!is_string($ctx)) {
-            throw new TypeError('Context must be a string');
-        }
-        $out = new SplFixedArray($outlen);
-
-        /** @var SplFixedArray $context */
-        $context = ParagonIE_Sodium_Core_BLAKE2b::stringToContext($ctx);
-
-        /** @var SplFixedArray $out */
-        $out = ParagonIE_Sodium_Core_BLAKE2b::finish($context, $out);
-
-        /** @var array<int, int> */
-        $outArray = $out->toArray();
-        return ParagonIE_Sodium_Core_Util::intArrayToString($outArray);
-    }
-
-    /**
-     * Initialize a hashing context for BLAKE2b.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $key
-     * @param int $outputLength
-     * @return string
-     * @throws RangeException
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function generichash_init($key = '', $outputLength = 32)
-    {
-        // This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
-        ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
-
-        $k = null;
-        if (!empty($key)) {
-            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
-            }
-        }
-
-        /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outputLength);
-
-        return ParagonIE_Sodium_Core_BLAKE2b::contextToString($ctx);
-    }
-
-    /**
-     * Initialize a hashing context for BLAKE2b.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $key
-     * @param int $outputLength
-     * @param string $salt
-     * @param string $personal
-     * @return string
-     * @throws RangeException
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function generichash_init_salt_personal(
-        $key = '',
-        $outputLength = 32,
-        $salt = '',
-        $personal = ''
-    ) {
-        // This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
-        ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
-
-        $k = null;
-        if (!empty($key)) {
-            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
-            }
-        }
-        if (!empty($salt)) {
-            $s = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($salt);
-        } else {
-            $s = null;
-        }
-        if (!empty($salt)) {
-            $p = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($personal);
-        } else {
-            $p = null;
-        }
-
-        /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outputLength, $s, $p);
-
-        return ParagonIE_Sodium_Core_BLAKE2b::contextToString($ctx);
-    }
-
-    /**
-     * Update a hashing context for BLAKE2b with $message
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $ctx
-     * @param string $message
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function generichash_update($ctx, $message)
-    {
-        // This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
-        ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
-
-        /** @var SplFixedArray $context */
-        $context = ParagonIE_Sodium_Core_BLAKE2b::stringToContext($ctx);
-
-        /** @var SplFixedArray $in */
-        $in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($message);
-
-        ParagonIE_Sodium_Core_BLAKE2b::update($context, $in, $in->count());
-
-        return ParagonIE_Sodium_Core_BLAKE2b::contextToString($context);
-    }
-
-    /**
-     * Libsodium's crypto_kx().
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $my_sk
-     * @param string $their_pk
-     * @param string $client_pk
-     * @param string $server_pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function keyExchange($my_sk, $their_pk, $client_pk, $server_pk)
-    {
-        return ParagonIE_Sodium_Compat::crypto_generichash(
-            ParagonIE_Sodium_Compat::crypto_scalarmult($my_sk, $their_pk) .
-            $client_pk .
-            $server_pk
-        );
-    }
-
-    /**
-     * ECDH over Curve25519
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $sKey
-     * @param string $pKey
-     * @return string
-     *
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function scalarmult($sKey, $pKey)
-    {
-        $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10($sKey, $pKey);
-        self::scalarmult_throw_if_zero($q);
-        return $q;
-    }
-
-    /**
-     * ECDH over Curve25519, using the basepoint.
-     * Used to get a secret key from a public key.
-     *
-     * @param string $secret
-     * @return string
-     *
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function scalarmult_base($secret)
-    {
-        $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10_base($secret);
-        self::scalarmult_throw_if_zero($q);
-        return $q;
-    }
-
-    /**
-     * This throws an Error if a zero public key was passed to the function.
-     *
-     * @param string $q
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function scalarmult_throw_if_zero($q)
-    {
-        $d = 0;
-        for ($i = 0; $i < self::box_curve25519xsalsa20poly1305_SECRETKEYBYTES; ++$i) {
-            $d |= ParagonIE_Sodium_Core_Util::chrToInt($q[$i]);
-        }
-
-        /* branch-free variant of === 0 */
-        if (-(1 & (($d - 1) >> 8))) {
-            throw new SodiumException('Zero public key is not allowed');
-        }
-    }
-
-    /**
-     * XSalsa20-Poly1305 authenticated symmetric-key encryption.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $plaintext
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function secretbox($plaintext, $nonce, $key)
-    {
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
-
-        /** @var string $block0 */
-        $block0 = str_repeat("\x00", 32);
-
-        /** @var int $mlen - Length of the plaintext message */
-        $mlen = ParagonIE_Sodium_Core_Util::strlen($plaintext);
-        $mlen0 = $mlen;
-        if ($mlen0 > 64 - self::secretbox_xsalsa20poly1305_ZEROBYTES) {
-            $mlen0 = 64 - self::secretbox_xsalsa20poly1305_ZEROBYTES;
-        }
-        $block0 .= ParagonIE_Sodium_Core_Util::substr($plaintext, 0, $mlen0);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20_xor(
-            $block0,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-            $subkey
-        );
-
-        /** @var string $c */
-        $c = ParagonIE_Sodium_Core_Util::substr(
-            $block0,
-            self::secretbox_xsalsa20poly1305_ZEROBYTES
-        );
-        if ($mlen > $mlen0) {
-            $c .= ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
-                ParagonIE_Sodium_Core_Util::substr(
-                    $plaintext,
-                    self::secretbox_xsalsa20poly1305_ZEROBYTES
-                ),
-                ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-                1,
-                $subkey
-            );
-        }
-        $state = new ParagonIE_Sodium_Core_Poly1305_State(
-            ParagonIE_Sodium_Core_Util::substr(
-                $block0,
-                0,
-                self::onetimeauth_poly1305_KEYBYTES
-            )
-        );
-        try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-            ParagonIE_Sodium_Compat::memzero($subkey);
-        } catch (SodiumException $ex) {
-            $block0 = null;
-            $subkey = null;
-        }
-
-        $state->update($c);
-
-        /** @var string $c - MAC || ciphertext */
-        $c = $state->finish() . $c;
-        unset($state);
-
-        return $c;
-    }
-
-    /**
-     * Decrypt a ciphertext generated via secretbox().
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $ciphertext
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function secretbox_open($ciphertext, $nonce, $key)
-    {
-        /** @var string $mac */
-        $mac = ParagonIE_Sodium_Core_Util::substr(
-            $ciphertext,
-            0,
-            self::secretbox_xsalsa20poly1305_MACBYTES
-        );
-
-        /** @var string $c */
-        $c = ParagonIE_Sodium_Core_Util::substr(
-            $ciphertext,
-            self::secretbox_xsalsa20poly1305_MACBYTES
-        );
-
-        /** @var int $clen */
-        $clen = ParagonIE_Sodium_Core_Util::strlen($c);
-
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20(
-            64,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-            $subkey
-        );
-        $verified = ParagonIE_Sodium_Core_Poly1305::onetimeauth_verify(
-            $mac,
-            $c,
-            ParagonIE_Sodium_Core_Util::substr($block0, 0, 32)
-        );
-        if (!$verified) {
-            try {
-                ParagonIE_Sodium_Compat::memzero($subkey);
-            } catch (SodiumException $ex) {
-                $subkey = null;
-            }
-            throw new SodiumException('Invalid MAC');
-        }
-
-        /** @var string $m - Decrypted message */
-        $m = ParagonIE_Sodium_Core_Util::xorStrings(
-            ParagonIE_Sodium_Core_Util::substr($block0, self::secretbox_xsalsa20poly1305_ZEROBYTES),
-            ParagonIE_Sodium_Core_Util::substr($c, 0, 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_Core_Salsa20::salsa20_xor_ic(
-                ParagonIE_Sodium_Core_Util::substr(
-                    $c,
-                    self::secretbox_xsalsa20poly1305_ZEROBYTES
-                ),
-                ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-                1,
-                (string) $subkey
-            );
-        }
-        return $m;
-    }
-
-    /**
-     * XChaCha20-Poly1305 authenticated symmetric-key encryption.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $plaintext
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function secretbox_xchacha20poly1305($plaintext, $nonce, $key)
-    {
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
-            $key
-        );
-        $nonceLast = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
-
-        /** @var string $block0 */
-        $block0 = str_repeat("\x00", 32);
-
-        /** @var int $mlen - Length of the plaintext message */
-        $mlen = ParagonIE_Sodium_Core_Util::strlen($plaintext);
-        $mlen0 = $mlen;
-        if ($mlen0 > 64 - self::secretbox_xchacha20poly1305_ZEROBYTES) {
-            $mlen0 = 64 - self::secretbox_xchacha20poly1305_ZEROBYTES;
-        }
-        $block0 .= ParagonIE_Sodium_Core_Util::substr($plaintext, 0, $mlen0);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
-            $block0,
-            $nonceLast,
-            $subkey
-        );
-
-        /** @var string $c */
-        $c = ParagonIE_Sodium_Core_Util::substr(
-            $block0,
-            self::secretbox_xchacha20poly1305_ZEROBYTES
-        );
-        if ($mlen > $mlen0) {
-            $c .= ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
-                ParagonIE_Sodium_Core_Util::substr(
-                    $plaintext,
-                    self::secretbox_xchacha20poly1305_ZEROBYTES
-                ),
-                $nonceLast,
-                $subkey,
-                ParagonIE_Sodium_Core_Util::store64_le(1)
-            );
-        }
-        $state = new ParagonIE_Sodium_Core_Poly1305_State(
-            ParagonIE_Sodium_Core_Util::substr(
-                $block0,
-                0,
-                self::onetimeauth_poly1305_KEYBYTES
-            )
-        );
-        try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-            ParagonIE_Sodium_Compat::memzero($subkey);
-        } catch (SodiumException $ex) {
-            $block0 = null;
-            $subkey = null;
-        }
-
-        $state->update($c);
-
-        /** @var string $c - MAC || ciphertext */
-        $c = $state->finish() . $c;
-        unset($state);
-
-        return $c;
-    }
-
-    /**
-     * Decrypt a ciphertext generated via secretbox_xchacha20poly1305().
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $ciphertext
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key)
-    {
-        /** @var string $mac */
-        $mac = ParagonIE_Sodium_Core_Util::substr(
-            $ciphertext,
-            0,
-            self::secretbox_xchacha20poly1305_MACBYTES
-        );
-
-        /** @var string $c */
-        $c = ParagonIE_Sodium_Core_Util::substr(
-            $ciphertext,
-            self::secretbox_xchacha20poly1305_MACBYTES
-        );
-
-        /** @var int $clen */
-        $clen = ParagonIE_Sodium_Core_Util::strlen($c);
-
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HChaCha20::hchacha20($nonce, $key);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
-            64,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-            $subkey
-        );
-        $verified = ParagonIE_Sodium_Core_Poly1305::onetimeauth_verify(
-            $mac,
-            $c,
-            ParagonIE_Sodium_Core_Util::substr($block0, 0, 32)
-        );
-
-        if (!$verified) {
-            try {
-                ParagonIE_Sodium_Compat::memzero($subkey);
-            } catch (SodiumException $ex) {
-                $subkey = null;
-            }
-            throw new SodiumException('Invalid MAC');
-        }
-
-        /** @var string $m - Decrypted message */
-        $m = ParagonIE_Sodium_Core_Util::xorStrings(
-            ParagonIE_Sodium_Core_Util::substr($block0, self::secretbox_xchacha20poly1305_ZEROBYTES),
-            ParagonIE_Sodium_Core_Util::substr($c, 0, 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_Core_ChaCha20::streamXorIc(
-                ParagonIE_Sodium_Core_Util::substr(
-                    $c,
-                    self::secretbox_xchacha20poly1305_ZEROBYTES
-                ),
-                ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-                (string) $subkey,
-                ParagonIE_Sodium_Core_Util::store64_le(1)
-            );
-        }
-        return $m;
-    }
-
-    /**
-     * @param string $key
-     * @return array<int, string> Returns a state and a header.
-     * @throws Exception
-     * @throws SodiumException
-     */
-    public static function secretstream_xchacha20poly1305_init_push($key)
-    {
-        # randombytes_buf(out, crypto_secretstream_xchacha20poly1305_HEADERBYTES);
-        $out = random_bytes(24);
-
-        # crypto_core_hchacha20(state->k, out, k, NULL);
-        $subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20($out, $key);
-        $state = new ParagonIE_Sodium_Core_SecretStream_State(
-            $subkey,
-            ParagonIE_Sodium_Core_Util::substr($out, 16, 8) . str_repeat("\0", 4)
-        );
-
-        # _crypto_secretstream_xchacha20poly1305_counter_reset(state);
-        $state->counterReset();
-
-        # memcpy(STATE_INONCE(state), out + crypto_core_hchacha20_INPUTBYTES,
-        #        crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-        # memset(state->_pad, 0, sizeof state->_pad);
-        return array(
-            $state->toString(),
-            $out
-        );
-    }
-
-    /**
-     * @param string $key
-     * @param string $header
-     * @return string Returns a state.
-     * @throws Exception
-     */
-    public static function secretstream_xchacha20poly1305_init_pull($key, $header)
-    {
-        # crypto_core_hchacha20(state->k, in, k, NULL);
-        $subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($header, 0, 16),
-            $key
-        );
-        $state = new ParagonIE_Sodium_Core_SecretStream_State(
-            $subkey,
-            ParagonIE_Sodium_Core_Util::substr($header, 16)
-        );
-        $state->counterReset();
-        # memcpy(STATE_INONCE(state), in + crypto_core_hchacha20_INPUTBYTES,
-        #     crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-        # memset(state->_pad, 0, sizeof state->_pad);
-        # return 0;
-        return $state->toString();
-    }
-
-    /**
-     * @param string $state
-     * @param string $msg
-     * @param string $aad
-     * @param int $tag
-     * @return string
-     * @throws SodiumException
-     */
-    public static function secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
-    {
-        $st = ParagonIE_Sodium_Core_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_Core_Util::strlen($msg);
-        $aadlen = ParagonIE_Sodium_Core_Util::strlen($aad);
-
-        if ((($msglen + 63) >> 6) > 0xfffffffe) {
-            throw new SodiumException(
-                'message cannot be larger than SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX bytes'
-            );
-        }
-
-        # if (outlen_p != NULL) {
-        #     *outlen_p = 0U;
-        # }
-        # if (mlen > crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX) {
-        #     sodium_misuse();
-        # }
-
-        # crypto_stream_chacha20_ietf(block, sizeof block, state->nonce, state->k);
-        # crypto_onetimeauth_poly1305_init(&poly1305_state, block);
-        # sodium_memzero(block, sizeof block);
-        $auth = new ParagonIE_Sodium_Core_Poly1305_State(
-            ParagonIE_Sodium_Core_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
-        );
-
-        # crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
-        $auth->update($aad);
-
-        # crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
-        #     (0x10 - adlen) & 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_Core_ChaCha20::ietfStreamXorIc(
-            ParagonIE_Sodium_Core_Util::intToChr($tag) . str_repeat("\0", 63),
-            $st->getCombinedNonce(),
-            $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(1)
-        );
-
-        # crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
-        $auth->update($block);
-
-        # out[0] = 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_Core_ChaCha20::ietfStreamXorIc(
-            $msg,
-            $st->getCombinedNonce(),
-            $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(2)
-        );
-
-        # crypto_onetimeauth_poly1305_update(&poly1305_state, c, mlen);
-        $auth->update($cipher);
-
-        $out .= $cipher;
-        unset($cipher);
-
-        # crypto_onetimeauth_poly1305_update
-        # (&poly1305_state, _pad0, (0x10 - (sizeof block) + mlen) & 0xf);
-        $auth->update(str_repeat("\0", ((0x10 - 64 + $msglen) & 0xf)));
-
-        # STORE64_LE(slen, (uint64_t) adlen);
-        $slen = ParagonIE_Sodium_Core_Util::store64_le($aadlen);
-
-        # crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-        $auth->update($slen);
-
-        # STORE64_LE(slen, (sizeof block) + mlen);
-        $slen = ParagonIE_Sodium_Core_Util::store64_le(64 + $msglen);
-
-        # crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-        $auth->update($slen);
-
-        # mac = c + mlen;
-        # crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
-        $mac = $auth->finish();
-        $out .= $mac;
-
-        # sodium_memzero(&poly1305_state, sizeof poly1305_state);
-        unset($auth);
-
-
-        # XOR_BUF(STATE_INONCE(state), mac,
-        #     crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-        $st->xorNonce($mac);
-
-        # sodium_increment(STATE_COUNTER(state),
-        #     crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
-        $st->incrementCounter();
-        // Overwrite by reference:
-        $state = $st->toString();
-
-        /** @var bool $rekey */
-        $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()) {
-            // DO REKEY
-            self::secretstream_xchacha20poly1305_rekey($state);
-        }
-        # if (outlen_p != NULL) {
-        #     *outlen_p = crypto_secretstream_xchacha20poly1305_ABYTES + mlen;
-        # }
-        return $out;
-    }
-
-    /**
-     * @param string $state
-     * @param string $cipher
-     * @param string $aad
-     * @return bool|array{0: string, 1: int}
-     * @throws SodiumException
-     */
-    public static function secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
-    {
-        $st = ParagonIE_Sodium_Core_SecretStream_State::fromString($state);
-
-        $cipherlen = ParagonIE_Sodium_Core_Util::strlen($cipher);
-        #     mlen = inlen - crypto_secretstream_xchacha20poly1305_ABYTES;
-        $msglen = $cipherlen - ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES;
-        $aadlen = ParagonIE_Sodium_Core_Util::strlen($aad);
-
-        #     if (mlen > crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX) {
-        #         sodium_misuse();
-        #     }
-        if ((($msglen + 63) >> 6) > 0xfffffffe) {
-            throw new SodiumException(
-                'message cannot be larger than SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX bytes'
-            );
-        }
-
-        #     crypto_stream_chacha20_ietf(block, sizeof block, state->nonce, state->k);
-        #     crypto_onetimeauth_poly1305_init(&poly1305_state, block);
-        #     sodium_memzero(block, sizeof block);
-        $auth = new ParagonIE_Sodium_Core_Poly1305_State(
-            ParagonIE_Sodium_Core_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
-        );
-
-        #     crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
-        $auth->update($aad);
-
-        #     crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
-        #         (0x10 - adlen) & 0xf);
-        $auth->update(str_repeat("\0", ((0x10 - $aadlen) & 0xf)));
-
-
-        #     memset(block, 0, sizeof block);
-        #     block[0] = in[0];
-        #     crypto_stream_chacha20_ietf_xor_ic(block, block, sizeof block,
-        #                                        state->nonce, 1U, state->k);
-        $block = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
-            $cipher[0] . str_repeat("\0", 63),
-            $st->getCombinedNonce(),
-            $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(1)
-        );
-        #     tag = block[0];
-        #     block[0] = in[0];
-        #     crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
-        $tag = ParagonIE_Sodium_Core_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_Core_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)));
-
-        #     STORE64_LE(slen, (uint64_t) adlen);
-        #     crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
-        $slen = ParagonIE_Sodium_Core_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_Core_Util::store64_le(64 + $msglen);
-        $auth->update($slen);
-
-        #     crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
-        #     sodium_memzero(&poly1305_state, sizeof poly1305_state);
-        $mac = $auth->finish();
-
-        #     stored_mac = c + mlen;
-        #     if (sodium_memcmp(mac, stored_mac, sizeof mac) != 0) {
-        #     sodium_memzero(mac, sizeof mac);
-        #         return -1;
-        #     }
-
-        $stored = ParagonIE_Sodium_Core_Util::substr($cipher, $msglen + 1, 16);
-        if (!ParagonIE_Sodium_Core_Util::hashEquals($mac, $stored)) {
-            return false;
-        }
-
-        #     crypto_stream_chacha20_ietf_xor_ic(m, c, mlen, state->nonce, 2U, state->k);
-        $out = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
-            ParagonIE_Sodium_Core_Util::substr($cipher, 1, $msglen),
-            $st->getCombinedNonce(),
-            $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(2)
-        );
-
-        #     XOR_BUF(STATE_INONCE(state), mac,
-        #         crypto_secretstream_xchacha20poly1305_INONCEBYTES);
-        $st->xorNonce($mac);
-
-        #     sodium_increment(STATE_COUNTER(state),
-        #         crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
-        $st->incrementCounter();
-
-        #     if ((tag & crypto_secretstream_xchacha20poly1305_TAG_REKEY) != 0 ||
-        #         sodium_is_zero(STATE_COUNTER(state),
-        #             crypto_secretstream_xchacha20poly1305_COUNTERBYTES)) {
-        #         crypto_secretstream_xchacha20poly1305_rekey(state);
-        #     }
-
-        // Overwrite by reference:
-        $state = $st->toString();
-
-        /** @var bool $rekey */
-        $rekey = ($tag & ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY) !== 0;
-        if ($rekey || $st->needsRekey()) {
-            // DO REKEY
-            self::secretstream_xchacha20poly1305_rekey($state);
-        }
-        return array($out, $tag);
-    }
-
-    /**
-     * @param string $state
-     * @return void
-     * @throws SodiumException
-     */
-    public static function secretstream_xchacha20poly1305_rekey(&$state)
-    {
-        $st = ParagonIE_Sodium_Core_SecretStream_State::fromString($state);
-        # unsigned char new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES +
-        # crypto_secretstream_xchacha20poly1305_INONCEBYTES];
-        # size_t        i;
-        # for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
-        #     new_key_and_inonce[i] = state->k[i];
-        # }
-        $new_key_and_inonce = $st->getKey();
-
-        # for (i = 0U; i < crypto_secretstream_xchacha20poly1305_INONCEBYTES; i++) {
-        #     new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i] =
-        #         STATE_INONCE(state)[i];
-        # }
-        $new_key_and_inonce .= ParagonIE_Sodium_Core_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_Core_ChaCha20::ietfStreamXorIc(
-            $new_key_and_inonce,
-            $st->getCombinedNonce(),
-            $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(0)
-        ));
-
-        # for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
-        #     state->k[i] = new_key_and_inonce[i];
-        # }
-        # for (i = 0U; i < crypto_secretstream_xchacha20poly1305_INONCEBYTES; i++) {
-        #     STATE_INONCE(state)[i] =
-        #          new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i];
-        # }
-        # _crypto_secretstream_xchacha20poly1305_counter_reset(state);
-        $st->counterReset();
-
-        $state = $st->toString();
-    }
-
-    /**
-     * Detached Ed25519 signature.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sign_detached($message, $sk)
-    {
-        return ParagonIE_Sodium_Core_Ed25519::sign_detached($message, $sk);
-    }
-
-    /**
-     * Attached Ed25519 signature. (Returns a signed message.)
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $message
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sign($message, $sk)
-    {
-        return ParagonIE_Sodium_Core_Ed25519::sign($message, $sk);
-    }
-
-    /**
-     * Opens a signed message. If valid, returns the message.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $signedMessage
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sign_open($signedMessage, $pk)
-    {
-        return ParagonIE_Sodium_Core_Ed25519::sign_open($signedMessage, $pk);
-    }
-
-    /**
-     * Verify a detached signature of a given message and public key.
-     *
-     * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
-     *
-     * @param string $signature
-     * @param string $message
-     * @param string $pk
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sign_verify_detached($signature, $message, $pk)
-    {
-        return ParagonIE_Sodium_Core_Ed25519::verify_detached($signature, $message, $pk);
-    }
+	const aead_chacha20poly1305_KEYBYTES = 32;
+	const aead_chacha20poly1305_NSECBYTES = 0;
+	const aead_chacha20poly1305_NPUBBYTES = 8;
+	const aead_chacha20poly1305_ABYTES = 16;
+
+	const aead_chacha20poly1305_IETF_KEYBYTES = 32;
+	const aead_chacha20poly1305_IETF_NSECBYTES = 0;
+	const aead_chacha20poly1305_IETF_NPUBBYTES = 12;
+	const aead_chacha20poly1305_IETF_ABYTES = 16;
+
+	const aead_xchacha20poly1305_IETF_KEYBYTES = 32;
+	const aead_xchacha20poly1305_IETF_NSECBYTES = 0;
+	const aead_xchacha20poly1305_IETF_NPUBBYTES = 24;
+	const aead_xchacha20poly1305_IETF_ABYTES = 16;
+
+	const box_curve25519xsalsa20poly1305_SEEDBYTES = 32;
+	const box_curve25519xsalsa20poly1305_PUBLICKEYBYTES = 32;
+	const box_curve25519xsalsa20poly1305_SECRETKEYBYTES = 32;
+	const box_curve25519xsalsa20poly1305_BEFORENMBYTES = 32;
+	const box_curve25519xsalsa20poly1305_NONCEBYTES = 24;
+	const box_curve25519xsalsa20poly1305_MACBYTES = 16;
+	const box_curve25519xsalsa20poly1305_BOXZEROBYTES = 16;
+	const box_curve25519xsalsa20poly1305_ZEROBYTES = 32;
+
+	const onetimeauth_poly1305_BYTES = 16;
+	const onetimeauth_poly1305_KEYBYTES = 32;
+
+	const secretbox_xsalsa20poly1305_KEYBYTES = 32;
+	const secretbox_xsalsa20poly1305_NONCEBYTES = 24;
+	const secretbox_xsalsa20poly1305_MACBYTES = 16;
+	const secretbox_xsalsa20poly1305_BOXZEROBYTES = 16;
+	const secretbox_xsalsa20poly1305_ZEROBYTES = 32;
+
+	const secretbox_xchacha20poly1305_KEYBYTES = 32;
+	const secretbox_xchacha20poly1305_NONCEBYTES = 24;
+	const secretbox_xchacha20poly1305_MACBYTES = 16;
+	const secretbox_xchacha20poly1305_BOXZEROBYTES = 16;
+	const secretbox_xchacha20poly1305_ZEROBYTES = 32;
+
+	const stream_salsa20_KEYBYTES = 32;
+
+	/**
+	 * AEAD Decryption with ChaCha20-Poly1305
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $ad
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function aead_chacha20poly1305_decrypt(
+		$message = '',
+		$ad = '',
+		$nonce = '',
+		$key = ''
+	) {
+		/** @var int $len - Length of message (ciphertext + MAC) */
+		$len = ParagonIE_Sodium_Core_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_Core_Util::strlen($ad);
+
+		/** @var string $mac - Message authentication code */
+		$mac = ParagonIE_Sodium_Core_Util::substr(
+			$message,
+			$clen,
+			self::aead_chacha20poly1305_ABYTES
+		);
+
+		/** @var string $ciphertext - The encrypted message (sans MAC) */
+		$ciphertext = ParagonIE_Sodium_Core_Util::substr($message, 0, $clen);
+
+		/** @var string The first block of the chacha20 keystream, used as a poly1305 key */
+		$block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
+			32,
+			$nonce,
+			$key
+		);
+
+		/* Recalculate the Poly1305 authentication tag (MAC): */
+		$state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
+		try {
+			ParagonIE_Sodium_Compat::memzero($block0);
+		} catch (SodiumException $ex) {
+			$block0 = null;
+		}
+		$state->update($ad);
+		$state->update(ParagonIE_Sodium_Core_Util::store64_le($adlen));
+		$state->update($ciphertext);
+		$state->update(ParagonIE_Sodium_Core_Util::store64_le($clen));
+		$computed_mac = $state->finish();
+
+		/* Compare the given MAC with the recalculated MAC: */
+		if (!ParagonIE_Sodium_Core_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
+		return ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
+			$ciphertext,
+			$nonce,
+			$key,
+			ParagonIE_Sodium_Core_Util::store64_le(1)
+		);
+	}
+
+	/**
+	 * AEAD Encryption with ChaCha20-Poly1305
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $ad
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function aead_chacha20poly1305_encrypt(
+		$message = '',
+		$ad = '',
+		$nonce = '',
+		$key = ''
+	) {
+		/** @var int $len - Length of the plaintext message */
+		$len = ParagonIE_Sodium_Core_Util::strlen($message);
+
+		/** @var int $adlen - Length of the associated data */
+		$adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
+
+		/** @var string The first block of the chacha20 keystream, used as a poly1305 key */
+		$block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
+			32,
+			$nonce,
+			$key
+		);
+		$state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
+		try {
+			ParagonIE_Sodium_Compat::memzero($block0);
+		} catch (SodiumException $ex) {
+			$block0 = null;
+		}
+
+		/** @var string $ciphertext - Raw encrypted data */
+		$ciphertext = ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
+			$message,
+			$nonce,
+			$key,
+			ParagonIE_Sodium_Core_Util::store64_le(1)
+		);
+
+		$state->update($ad);
+		$state->update(ParagonIE_Sodium_Core_Util::store64_le($adlen));
+		$state->update($ciphertext);
+		$state->update(ParagonIE_Sodium_Core_Util::store64_le($len));
+		return $ciphertext . $state->finish();
+	}
+
+	/**
+	 * AEAD Decryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $ad
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function aead_chacha20poly1305_ietf_decrypt(
+		$message = '',
+		$ad = '',
+		$nonce = '',
+		$key = ''
+	) {
+		/** @var int $adlen - Length of associated data */
+		$adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
+
+		/** @var int $len - Length of message (ciphertext + MAC) */
+		$len = ParagonIE_Sodium_Core_Util::strlen($message);
+
+		/** @var int  $clen - Length of ciphertext */
+		$clen = $len - self::aead_chacha20poly1305_IETF_ABYTES;
+
+		/** @var string The first block of the chacha20 keystream, used as a poly1305 key */
+		$block0 = ParagonIE_Sodium_Core_ChaCha20::ietfStream(
+			32,
+			$nonce,
+			$key
+		);
+
+		/** @var string $mac - Message authentication code */
+		$mac = ParagonIE_Sodium_Core_Util::substr(
+			$message,
+			$len - self::aead_chacha20poly1305_IETF_ABYTES,
+			self::aead_chacha20poly1305_IETF_ABYTES
+		);
+
+		/** @var string $ciphertext - The encrypted message (sans MAC) */
+		$ciphertext = ParagonIE_Sodium_Core_Util::substr(
+			$message,
+			0,
+			$len - self::aead_chacha20poly1305_IETF_ABYTES
+		);
+
+		/* Recalculate the Poly1305 authentication tag (MAC): */
+		$state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
+		try {
+			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_Core_Util::store64_le($adlen));
+		$state->update(ParagonIE_Sodium_Core_Util::store64_le($clen));
+		$computed_mac = $state->finish();
+
+		/* Compare the given MAC with the recalculated MAC: */
+		if (!ParagonIE_Sodium_Core_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
+		return ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
+			$ciphertext,
+			$nonce,
+			$key,
+			ParagonIE_Sodium_Core_Util::store64_le(1)
+		);
+	}
+
+	/**
+	 * AEAD Encryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $ad
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function aead_chacha20poly1305_ietf_encrypt(
+		$message = '',
+		$ad = '',
+		$nonce = '',
+		$key = ''
+	) {
+		/** @var int $len - Length of the plaintext message */
+		$len = ParagonIE_Sodium_Core_Util::strlen($message);
+
+		/** @var int $adlen - Length of the associated data */
+		$adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
+
+		/** @var string The first block of the chacha20 keystream, used as a poly1305 key */
+		$block0 = ParagonIE_Sodium_Core_ChaCha20::ietfStream(
+			32,
+			$nonce,
+			$key
+		);
+		$state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
+		try {
+			ParagonIE_Sodium_Compat::memzero($block0);
+		} catch (SodiumException $ex) {
+			$block0 = null;
+		}
+
+		/** @var string $ciphertext - Raw encrypted data */
+		$ciphertext = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
+			$message,
+			$nonce,
+			$key,
+			ParagonIE_Sodium_Core_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_Core_Util::store64_le($adlen));
+		$state->update(ParagonIE_Sodium_Core_Util::store64_le($len));
+		return $ciphertext . $state->finish();
+	}
+
+	/**
+	 * AEAD Decryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $ad
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function aead_xchacha20poly1305_ietf_decrypt(
+		$message = '',
+		$ad = '',
+		$nonce = '',
+		$key = ''
+	) {
+		$subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
+			ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
+			$key
+		);
+		$nonceLast = "\x00\x00\x00\x00" .
+			ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+
+		return self::aead_chacha20poly1305_ietf_decrypt($message, $ad, $nonceLast, $subkey);
+	}
+
+	/**
+	 * AEAD Encryption with ChaCha20-Poly1305, IETF mode (96-bit nonce)
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $ad
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function aead_xchacha20poly1305_ietf_encrypt(
+		$message = '',
+		$ad = '',
+		$nonce = '',
+		$key = ''
+	) {
+		$subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
+			ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
+			$key
+		);
+		$nonceLast = "\x00\x00\x00\x00" .
+			ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+
+		return self::aead_chacha20poly1305_ietf_encrypt($message, $ad, $nonceLast, $subkey);
+	}
+
+	/**
+	 * HMAC-SHA-512-256 (a.k.a. the leftmost 256 bits of HMAC-SHA-512)
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $key
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function auth($message, $key)
+	{
+		return ParagonIE_Sodium_Core_Util::substr(
+			hash_hmac('sha512', $message, $key, true),
+			0,
+			32
+		);
+	}
+
+	/**
+	 * HMAC-SHA-512-256 validation. Constant-time via hash_equals().
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $mac
+	 * @param string $message
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function auth_verify($mac, $message, $key)
+	{
+		return ParagonIE_Sodium_Core_Util::hashEquals(
+			$mac,
+			self::auth($message, $key)
+		);
+	}
+
+	/**
+	 * X25519 key exchange followed by XSalsa20Poly1305 symmetric encryption
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $plaintext
+	 * @param string $nonce
+	 * @param string $keypair
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box($plaintext, $nonce, $keypair)
+	{
+		$c = self::secretbox(
+			$plaintext,
+			$nonce,
+			self::box_beforenm(
+				self::box_secretkey($keypair),
+				self::box_publickey($keypair)
+			)
+		);
+		return $c;
+	}
+
+	/**
+	 * X25519-XSalsa20-Poly1305 with one ephemeral X25519 keypair.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $publicKey
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_seal($message, $publicKey)
+	{
+		/** @var string $ephemeralKeypair */
+		$ephemeralKeypair = self::box_keypair();
+
+		/** @var string $ephemeralSK */
+		$ephemeralSK = self::box_secretkey($ephemeralKeypair);
+
+		/** @var string $ephemeralPK */
+		$ephemeralPK = self::box_publickey($ephemeralKeypair);
+
+		/** @var string $nonce */
+		$nonce = self::generichash(
+			$ephemeralPK . $publicKey,
+			'',
+			24
+		);
+
+		/** @var string $keypair - The combined keypair used in crypto_box() */
+		$keypair = self::box_keypair_from_secretkey_and_publickey($ephemeralSK, $publicKey);
+
+		/** @var string $ciphertext Ciphertext + MAC from crypto_box */
+		$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) {
+			$ephemeralKeypair = null;
+			$ephemeralSK = null;
+			$nonce = null;
+		}
+		return $ephemeralPK . $ciphertext;
+	}
+
+	/**
+	 * Opens a message encrypted via box_seal().
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $keypair
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_seal_open($message, $keypair)
+	{
+		/** @var string $ephemeralPK */
+		$ephemeralPK = ParagonIE_Sodium_Core_Util::substr($message, 0, 32);
+
+		/** @var string $ciphertext (ciphertext + MAC) */
+		$ciphertext = ParagonIE_Sodium_Core_Util::substr($message, 32);
+
+		/** @var string $secretKey */
+		$secretKey = self::box_secretkey($keypair);
+
+		/** @var string $publicKey */
+		$publicKey = self::box_publickey($keypair);
+
+		/** @var string $nonce */
+		$nonce = self::generichash(
+			$ephemeralPK . $publicKey,
+			'',
+			24
+		);
+
+		/** @var string $keypair */
+		$keypair = self::box_keypair_from_secretkey_and_publickey($secretKey, $ephemeralPK);
+
+		/** @var string $m */
+		$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) {
+			$secretKey = null;
+			$ephemeralPK = null;
+			$nonce = null;
+		}
+		return $m;
+	}
+
+	/**
+	 * Used by crypto_box() to get the crypto_secretbox() key.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $sk
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_beforenm($sk, $pk)
+	{
+		return ParagonIE_Sodium_Core_HSalsa20::hsalsa20(
+			str_repeat("\x00", 16),
+			self::scalarmult($sk, $pk)
+		);
+	}
+
+	/**
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_keypair()
+	{
+		$sKey = random_bytes(32);
+		$pKey = self::scalarmult_base($sKey);
+		return $sKey . $pKey;
+	}
+
+	/**
+	 * @param string $seed
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_seed_keypair($seed)
+	{
+		$sKey = ParagonIE_Sodium_Core_Util::substr(
+			hash('sha512', $seed, true),
+			0,
+			32
+		);
+		$pKey = self::scalarmult_base($sKey);
+		return $sKey . $pKey;
+	}
+
+	/**
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $sKey
+	 * @param string $pKey
+	 * @return string
+	 * @throws TypeError
+	 */
+	public static function box_keypair_from_secretkey_and_publickey($sKey, $pKey)
+	{
+		return ParagonIE_Sodium_Core_Util::substr($sKey, 0, 32) .
+			ParagonIE_Sodium_Core_Util::substr($pKey, 0, 32);
+	}
+
+	/**
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $keypair
+	 * @return string
+	 * @throws RangeException
+	 * @throws TypeError
+	 */
+	public static function box_secretkey($keypair)
+	{
+		if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== 64) {
+			throw new RangeException(
+				'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES bytes long.'
+			);
+		}
+		return ParagonIE_Sodium_Core_Util::substr($keypair, 0, 32);
+	}
+
+	/**
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $keypair
+	 * @return string
+	 * @throws RangeException
+	 * @throws TypeError
+	 */
+	public static function box_publickey($keypair)
+	{
+		if (ParagonIE_Sodium_Core_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_Core_Util::substr($keypair, 32, 32);
+	}
+
+	/**
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $sKey
+	 * @return string
+	 * @throws RangeException
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_publickey_from_secretkey($sKey)
+	{
+		if (ParagonIE_Sodium_Core_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);
+	}
+
+	/**
+	 * Decrypt a message encrypted with box().
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $ciphertext
+	 * @param string $nonce
+	 * @param string $keypair
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	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)
+			)
+		);
+	}
+
+	/**
+	 * Calculate a BLAKE2b hash.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string|null $key
+	 * @param int $outlen
+	 * @return string
+	 * @throws RangeException
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function generichash($message, $key = '', $outlen = 32)
+	{
+		// This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
+		ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
+
+		$k = null;
+		if (!empty($key)) {
+			/** @var SplFixedArray $k */
+			$k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
+			if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
+				throw new RangeException('Invalid key size');
+			}
+		}
+
+		/** @var SplFixedArray $in */
+		$in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($message);
+
+		/** @var SplFixedArray $ctx */
+		$ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outlen);
+		ParagonIE_Sodium_Core_BLAKE2b::update($ctx, $in, $in->count());
+
+		/** @var SplFixedArray $out */
+		$out = new SplFixedArray($outlen);
+		$out = ParagonIE_Sodium_Core_BLAKE2b::finish($ctx, $out);
+
+		/** @var array<int, int> */
+		$outArray = $out->toArray();
+		return ParagonIE_Sodium_Core_Util::intArrayToString($outArray);
+	}
+
+	/**
+	 * Finalize a BLAKE2b hashing context, returning the hash.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $ctx
+	 * @param int $outlen
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function generichash_final($ctx, $outlen = 32)
+	{
+		if (!is_string($ctx)) {
+			throw new TypeError('Context must be a string');
+		}
+		$out = new SplFixedArray($outlen);
+
+		/** @var SplFixedArray $context */
+		$context = ParagonIE_Sodium_Core_BLAKE2b::stringToContext($ctx);
+
+		/** @var SplFixedArray $out */
+		$out = ParagonIE_Sodium_Core_BLAKE2b::finish($context, $out);
+
+		/** @var array<int, int> */
+		$outArray = $out->toArray();
+		return ParagonIE_Sodium_Core_Util::intArrayToString($outArray);
+	}
+
+	/**
+	 * Initialize a hashing context for BLAKE2b.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $key
+	 * @param int $outputLength
+	 * @return string
+	 * @throws RangeException
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function generichash_init($key = '', $outputLength = 32)
+	{
+		// This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
+		ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
+
+		$k = null;
+		if (!empty($key)) {
+			$k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
+			if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
+				throw new RangeException('Invalid key size');
+			}
+		}
+
+		/** @var SplFixedArray $ctx */
+		$ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outputLength);
+
+		return ParagonIE_Sodium_Core_BLAKE2b::contextToString($ctx);
+	}
+
+	/**
+	 * Initialize a hashing context for BLAKE2b.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $key
+	 * @param int $outputLength
+	 * @param string $salt
+	 * @param string $personal
+	 * @return string
+	 * @throws RangeException
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function generichash_init_salt_personal(
+		$key = '',
+		$outputLength = 32,
+		$salt = '',
+		$personal = ''
+	) {
+		// This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
+		ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
+
+		$k = null;
+		if (!empty($key)) {
+			$k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
+			if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
+				throw new RangeException('Invalid key size');
+			}
+		}
+		if (!empty($salt)) {
+			$s = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($salt);
+		} else {
+			$s = null;
+		}
+		if (!empty($salt)) {
+			$p = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($personal);
+		} else {
+			$p = null;
+		}
+
+		/** @var SplFixedArray $ctx */
+		$ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outputLength, $s, $p);
+
+		return ParagonIE_Sodium_Core_BLAKE2b::contextToString($ctx);
+	}
+
+	/**
+	 * Update a hashing context for BLAKE2b with $message
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $ctx
+	 * @param string $message
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function generichash_update($ctx, $message)
+	{
+		// This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
+		ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
+
+		/** @var SplFixedArray $context */
+		$context = ParagonIE_Sodium_Core_BLAKE2b::stringToContext($ctx);
+
+		/** @var SplFixedArray $in */
+		$in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($message);
+
+		ParagonIE_Sodium_Core_BLAKE2b::update($context, $in, $in->count());
+
+		return ParagonIE_Sodium_Core_BLAKE2b::contextToString($context);
+	}
+
+	/**
+	 * Libsodium's crypto_kx().
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $my_sk
+	 * @param string $their_pk
+	 * @param string $client_pk
+	 * @param string $server_pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function keyExchange($my_sk, $their_pk, $client_pk, $server_pk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_generichash(
+			ParagonIE_Sodium_Compat::crypto_scalarmult($my_sk, $their_pk) .
+			$client_pk .
+			$server_pk
+		);
+	}
+
+	/**
+	 * ECDH over Curve25519
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $sKey
+	 * @param string $pKey
+	 * @return string
+	 *
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function scalarmult($sKey, $pKey)
+	{
+		$q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10($sKey, $pKey);
+		self::scalarmult_throw_if_zero($q);
+		return $q;
+	}
+
+	/**
+	 * ECDH over Curve25519, using the basepoint.
+	 * Used to get a secret key from a public key.
+	 *
+	 * @param string $secret
+	 * @return string
+	 *
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function scalarmult_base($secret)
+	{
+		$q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10_base($secret);
+		self::scalarmult_throw_if_zero($q);
+		return $q;
+	}
+
+	/**
+	 * This throws an Error if a zero public key was passed to the function.
+	 *
+	 * @param string $q
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function scalarmult_throw_if_zero($q)
+	{
+		$d = 0;
+		for ($i = 0; $i < self::box_curve25519xsalsa20poly1305_SECRETKEYBYTES; ++$i) {
+			$d |= ParagonIE_Sodium_Core_Util::chrToInt($q[$i]);
+		}
+
+		/* branch-free variant of === 0 */
+		if (-(1 & (($d - 1) >> 8))) {
+			throw new SodiumException('Zero public key is not allowed');
+		}
+	}
+
+	/**
+	 * XSalsa20-Poly1305 authenticated symmetric-key encryption.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $plaintext
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function secretbox($plaintext, $nonce, $key)
+	{
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
+
+		/** @var string $block0 */
+		$block0 = str_repeat("\x00", 32);
+
+		/** @var int $mlen - Length of the plaintext message */
+		$mlen = ParagonIE_Sodium_Core_Util::strlen($plaintext);
+		$mlen0 = $mlen;
+		if ($mlen0 > 64 - self::secretbox_xsalsa20poly1305_ZEROBYTES) {
+			$mlen0 = 64 - self::secretbox_xsalsa20poly1305_ZEROBYTES;
+		}
+		$block0 .= ParagonIE_Sodium_Core_Util::substr($plaintext, 0, $mlen0);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core_Salsa20::salsa20_xor(
+			$block0,
+			ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+			$subkey
+		);
+
+		/** @var string $c */
+		$c = ParagonIE_Sodium_Core_Util::substr(
+			$block0,
+			self::secretbox_xsalsa20poly1305_ZEROBYTES
+		);
+		if ($mlen > $mlen0) {
+			$c .= ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
+				ParagonIE_Sodium_Core_Util::substr(
+					$plaintext,
+					self::secretbox_xsalsa20poly1305_ZEROBYTES
+				),
+				ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+				1,
+				$subkey
+			);
+		}
+		$state = new ParagonIE_Sodium_Core_Poly1305_State(
+			ParagonIE_Sodium_Core_Util::substr(
+				$block0,
+				0,
+				self::onetimeauth_poly1305_KEYBYTES
+			)
+		);
+		try {
+			ParagonIE_Sodium_Compat::memzero($block0);
+			ParagonIE_Sodium_Compat::memzero($subkey);
+		} catch (SodiumException $ex) {
+			$block0 = null;
+			$subkey = null;
+		}
+
+		$state->update($c);
+
+		/** @var string $c - MAC || ciphertext */
+		$c = $state->finish() . $c;
+		unset($state);
+
+		return $c;
+	}
+
+	/**
+	 * Decrypt a ciphertext generated via secretbox().
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $ciphertext
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function secretbox_open($ciphertext, $nonce, $key)
+	{
+		/** @var string $mac */
+		$mac = ParagonIE_Sodium_Core_Util::substr(
+			$ciphertext,
+			0,
+			self::secretbox_xsalsa20poly1305_MACBYTES
+		);
+
+		/** @var string $c */
+		$c = ParagonIE_Sodium_Core_Util::substr(
+			$ciphertext,
+			self::secretbox_xsalsa20poly1305_MACBYTES
+		);
+
+		/** @var int $clen */
+		$clen = ParagonIE_Sodium_Core_Util::strlen($c);
+
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core_Salsa20::salsa20(
+			64,
+			ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+			$subkey
+		);
+		$verified = ParagonIE_Sodium_Core_Poly1305::onetimeauth_verify(
+			$mac,
+			$c,
+			ParagonIE_Sodium_Core_Util::substr($block0, 0, 32)
+		);
+		if (!$verified) {
+			try {
+				ParagonIE_Sodium_Compat::memzero($subkey);
+			} catch (SodiumException $ex) {
+				$subkey = null;
+			}
+			throw new SodiumException('Invalid MAC');
+		}
+
+		/** @var string $m - Decrypted message */
+		$m = ParagonIE_Sodium_Core_Util::xorStrings(
+			ParagonIE_Sodium_Core_Util::substr($block0, self::secretbox_xsalsa20poly1305_ZEROBYTES),
+			ParagonIE_Sodium_Core_Util::substr($c, 0, 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_Core_Salsa20::salsa20_xor_ic(
+				ParagonIE_Sodium_Core_Util::substr(
+					$c,
+					self::secretbox_xsalsa20poly1305_ZEROBYTES
+				),
+				ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+				1,
+				(string) $subkey
+			);
+		}
+		return $m;
+	}
+
+	/**
+	 * XChaCha20-Poly1305 authenticated symmetric-key encryption.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $plaintext
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function secretbox_xchacha20poly1305($plaintext, $nonce, $key)
+	{
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
+			ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
+			$key
+		);
+		$nonceLast = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+
+		/** @var string $block0 */
+		$block0 = str_repeat("\x00", 32);
+
+		/** @var int $mlen - Length of the plaintext message */
+		$mlen = ParagonIE_Sodium_Core_Util::strlen($plaintext);
+		$mlen0 = $mlen;
+		if ($mlen0 > 64 - self::secretbox_xchacha20poly1305_ZEROBYTES) {
+			$mlen0 = 64 - self::secretbox_xchacha20poly1305_ZEROBYTES;
+		}
+		$block0 .= ParagonIE_Sodium_Core_Util::substr($plaintext, 0, $mlen0);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
+			$block0,
+			$nonceLast,
+			$subkey
+		);
+
+		/** @var string $c */
+		$c = ParagonIE_Sodium_Core_Util::substr(
+			$block0,
+			self::secretbox_xchacha20poly1305_ZEROBYTES
+		);
+		if ($mlen > $mlen0) {
+			$c .= ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
+				ParagonIE_Sodium_Core_Util::substr(
+					$plaintext,
+					self::secretbox_xchacha20poly1305_ZEROBYTES
+				),
+				$nonceLast,
+				$subkey,
+				ParagonIE_Sodium_Core_Util::store64_le(1)
+			);
+		}
+		$state = new ParagonIE_Sodium_Core_Poly1305_State(
+			ParagonIE_Sodium_Core_Util::substr(
+				$block0,
+				0,
+				self::onetimeauth_poly1305_KEYBYTES
+			)
+		);
+		try {
+			ParagonIE_Sodium_Compat::memzero($block0);
+			ParagonIE_Sodium_Compat::memzero($subkey);
+		} catch (SodiumException $ex) {
+			$block0 = null;
+			$subkey = null;
+		}
+
+		$state->update($c);
+
+		/** @var string $c - MAC || ciphertext */
+		$c = $state->finish() . $c;
+		unset($state);
+
+		return $c;
+	}
+
+	/**
+	 * Decrypt a ciphertext generated via secretbox_xchacha20poly1305().
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $ciphertext
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key)
+	{
+		/** @var string $mac */
+		$mac = ParagonIE_Sodium_Core_Util::substr(
+			$ciphertext,
+			0,
+			self::secretbox_xchacha20poly1305_MACBYTES
+		);
+
+		/** @var string $c */
+		$c = ParagonIE_Sodium_Core_Util::substr(
+			$ciphertext,
+			self::secretbox_xchacha20poly1305_MACBYTES
+		);
+
+		/** @var int $clen */
+		$clen = ParagonIE_Sodium_Core_Util::strlen($c);
+
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core_HChaCha20::hchacha20($nonce, $key);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
+			64,
+			ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+			$subkey
+		);
+		$verified = ParagonIE_Sodium_Core_Poly1305::onetimeauth_verify(
+			$mac,
+			$c,
+			ParagonIE_Sodium_Core_Util::substr($block0, 0, 32)
+		);
+
+		if (!$verified) {
+			try {
+				ParagonIE_Sodium_Compat::memzero($subkey);
+			} catch (SodiumException $ex) {
+				$subkey = null;
+			}
+			throw new SodiumException('Invalid MAC');
+		}
+
+		/** @var string $m - Decrypted message */
+		$m = ParagonIE_Sodium_Core_Util::xorStrings(
+			ParagonIE_Sodium_Core_Util::substr($block0, self::secretbox_xchacha20poly1305_ZEROBYTES),
+			ParagonIE_Sodium_Core_Util::substr($c, 0, 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_Core_ChaCha20::streamXorIc(
+				ParagonIE_Sodium_Core_Util::substr(
+					$c,
+					self::secretbox_xchacha20poly1305_ZEROBYTES
+				),
+				ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+				(string) $subkey,
+				ParagonIE_Sodium_Core_Util::store64_le(1)
+			);
+		}
+		return $m;
+	}
+
+	/**
+	 * @param string $key
+	 * @return array<int, string> Returns a state and a header.
+	 * @throws Exception
+	 * @throws SodiumException
+	 */
+	public static function secretstream_xchacha20poly1305_init_push($key)
+	{
+		# randombytes_buf(out, crypto_secretstream_xchacha20poly1305_HEADERBYTES);
+		$out = random_bytes(24);
+
+		# crypto_core_hchacha20(state->k, out, k, NULL);
+		$subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20($out, $key);
+		$state = new ParagonIE_Sodium_Core_SecretStream_State(
+			$subkey,
+			ParagonIE_Sodium_Core_Util::substr($out, 16, 8) . str_repeat("\0", 4)
+		);
+
+		# _crypto_secretstream_xchacha20poly1305_counter_reset(state);
+		$state->counterReset();
+
+		# memcpy(STATE_INONCE(state), out + crypto_core_hchacha20_INPUTBYTES,
+		#        crypto_secretstream_xchacha20poly1305_INONCEBYTES);
+		# memset(state->_pad, 0, sizeof state->_pad);
+		return array(
+			$state->toString(),
+			$out
+		);
+	}
+
+	/**
+	 * @param string $key
+	 * @param string $header
+	 * @return string Returns a state.
+	 * @throws Exception
+	 */
+	public static function secretstream_xchacha20poly1305_init_pull($key, $header)
+	{
+		# crypto_core_hchacha20(state->k, in, k, NULL);
+		$subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
+			ParagonIE_Sodium_Core_Util::substr($header, 0, 16),
+			$key
+		);
+		$state = new ParagonIE_Sodium_Core_SecretStream_State(
+			$subkey,
+			ParagonIE_Sodium_Core_Util::substr($header, 16)
+		);
+		$state->counterReset();
+		# memcpy(STATE_INONCE(state), in + crypto_core_hchacha20_INPUTBYTES,
+		#     crypto_secretstream_xchacha20poly1305_INONCEBYTES);
+		# memset(state->_pad, 0, sizeof state->_pad);
+		# return 0;
+		return $state->toString();
+	}
+
+	/**
+	 * @param string $state
+	 * @param string $msg
+	 * @param string $aad
+	 * @param int $tag
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
+	{
+		$st = ParagonIE_Sodium_Core_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_Core_Util::strlen($msg);
+		$aadlen = ParagonIE_Sodium_Core_Util::strlen($aad);
+
+		if ((($msglen + 63) >> 6) > 0xfffffffe) {
+			throw new SodiumException(
+				'message cannot be larger than SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX bytes'
+			);
+		}
+
+		# if (outlen_p != NULL) {
+		#     *outlen_p = 0U;
+		# }
+		# if (mlen > crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX) {
+		#     sodium_misuse();
+		# }
+
+		# crypto_stream_chacha20_ietf(block, sizeof block, state->nonce, state->k);
+		# crypto_onetimeauth_poly1305_init(&poly1305_state, block);
+		# sodium_memzero(block, sizeof block);
+		$auth = new ParagonIE_Sodium_Core_Poly1305_State(
+			ParagonIE_Sodium_Core_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
+		);
+
+		# crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
+		$auth->update($aad);
+
+		# crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
+		#     (0x10 - adlen) & 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_Core_ChaCha20::ietfStreamXorIc(
+			ParagonIE_Sodium_Core_Util::intToChr($tag) . str_repeat("\0", 63),
+			$st->getCombinedNonce(),
+			$st->getKey(),
+			ParagonIE_Sodium_Core_Util::store64_le(1)
+		);
+
+		# crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
+		$auth->update($block);
+
+		# out[0] = 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_Core_ChaCha20::ietfStreamXorIc(
+			$msg,
+			$st->getCombinedNonce(),
+			$st->getKey(),
+			ParagonIE_Sodium_Core_Util::store64_le(2)
+		);
+
+		# crypto_onetimeauth_poly1305_update(&poly1305_state, c, mlen);
+		$auth->update($cipher);
+
+		$out .= $cipher;
+		unset($cipher);
+
+		# crypto_onetimeauth_poly1305_update
+		# (&poly1305_state, _pad0, (0x10 - (sizeof block) + mlen) & 0xf);
+		$auth->update(str_repeat("\0", ((0x10 - 64 + $msglen) & 0xf)));
+
+		# STORE64_LE(slen, (uint64_t) adlen);
+		$slen = ParagonIE_Sodium_Core_Util::store64_le($aadlen);
+
+		# crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
+		$auth->update($slen);
+
+		# STORE64_LE(slen, (sizeof block) + mlen);
+		$slen = ParagonIE_Sodium_Core_Util::store64_le(64 + $msglen);
+
+		# crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
+		$auth->update($slen);
+
+		# mac = c + mlen;
+		# crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
+		$mac = $auth->finish();
+		$out .= $mac;
+
+		# sodium_memzero(&poly1305_state, sizeof poly1305_state);
+		unset($auth);
+
+
+		# XOR_BUF(STATE_INONCE(state), mac,
+		#     crypto_secretstream_xchacha20poly1305_INONCEBYTES);
+		$st->xorNonce($mac);
+
+		# sodium_increment(STATE_COUNTER(state),
+		#     crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
+		$st->incrementCounter();
+		// Overwrite by reference:
+		$state = $st->toString();
+
+		/** @var bool $rekey */
+		$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()) {
+			// DO REKEY
+			self::secretstream_xchacha20poly1305_rekey($state);
+		}
+		# if (outlen_p != NULL) {
+		#     *outlen_p = crypto_secretstream_xchacha20poly1305_ABYTES + mlen;
+		# }
+		return $out;
+	}
+
+	/**
+	 * @param string $state
+	 * @param string $cipher
+	 * @param string $aad
+	 * @return bool|array{0: string, 1: int}
+	 * @throws SodiumException
+	 */
+	public static function secretstream_xchacha20poly1305_pull(&$state, $cipher, $aad = '')
+	{
+		$st = ParagonIE_Sodium_Core_SecretStream_State::fromString($state);
+
+		$cipherlen = ParagonIE_Sodium_Core_Util::strlen($cipher);
+		#     mlen = inlen - crypto_secretstream_xchacha20poly1305_ABYTES;
+		$msglen = $cipherlen - ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES;
+		$aadlen = ParagonIE_Sodium_Core_Util::strlen($aad);
+
+		#     if (mlen > crypto_secretstream_xchacha20poly1305_MESSAGEBYTES_MAX) {
+		#         sodium_misuse();
+		#     }
+		if ((($msglen + 63) >> 6) > 0xfffffffe) {
+			throw new SodiumException(
+				'message cannot be larger than SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX bytes'
+			);
+		}
+
+		#     crypto_stream_chacha20_ietf(block, sizeof block, state->nonce, state->k);
+		#     crypto_onetimeauth_poly1305_init(&poly1305_state, block);
+		#     sodium_memzero(block, sizeof block);
+		$auth = new ParagonIE_Sodium_Core_Poly1305_State(
+			ParagonIE_Sodium_Core_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
+		);
+
+		#     crypto_onetimeauth_poly1305_update(&poly1305_state, ad, adlen);
+		$auth->update($aad);
+
+		#     crypto_onetimeauth_poly1305_update(&poly1305_state, _pad0,
+		#         (0x10 - adlen) & 0xf);
+		$auth->update(str_repeat("\0", ((0x10 - $aadlen) & 0xf)));
+
+
+		#     memset(block, 0, sizeof block);
+		#     block[0] = in[0];
+		#     crypto_stream_chacha20_ietf_xor_ic(block, block, sizeof block,
+		#                                        state->nonce, 1U, state->k);
+		$block = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
+			$cipher[0] . str_repeat("\0", 63),
+			$st->getCombinedNonce(),
+			$st->getKey(),
+			ParagonIE_Sodium_Core_Util::store64_le(1)
+		);
+		#     tag = block[0];
+		#     block[0] = in[0];
+		#     crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
+		$tag = ParagonIE_Sodium_Core_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_Core_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)));
+
+		#     STORE64_LE(slen, (uint64_t) adlen);
+		#     crypto_onetimeauth_poly1305_update(&poly1305_state, slen, sizeof slen);
+		$slen = ParagonIE_Sodium_Core_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_Core_Util::store64_le(64 + $msglen);
+		$auth->update($slen);
+
+		#     crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
+		#     sodium_memzero(&poly1305_state, sizeof poly1305_state);
+		$mac = $auth->finish();
+
+		#     stored_mac = c + mlen;
+		#     if (sodium_memcmp(mac, stored_mac, sizeof mac) != 0) {
+		#     sodium_memzero(mac, sizeof mac);
+		#         return -1;
+		#     }
+
+		$stored = ParagonIE_Sodium_Core_Util::substr($cipher, $msglen + 1, 16);
+		if (!ParagonIE_Sodium_Core_Util::hashEquals($mac, $stored)) {
+			return false;
+		}
+
+		#     crypto_stream_chacha20_ietf_xor_ic(m, c, mlen, state->nonce, 2U, state->k);
+		$out = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
+			ParagonIE_Sodium_Core_Util::substr($cipher, 1, $msglen),
+			$st->getCombinedNonce(),
+			$st->getKey(),
+			ParagonIE_Sodium_Core_Util::store64_le(2)
+		);
+
+		#     XOR_BUF(STATE_INONCE(state), mac,
+		#         crypto_secretstream_xchacha20poly1305_INONCEBYTES);
+		$st->xorNonce($mac);
+
+		#     sodium_increment(STATE_COUNTER(state),
+		#         crypto_secretstream_xchacha20poly1305_COUNTERBYTES);
+		$st->incrementCounter();
+
+		#     if ((tag & crypto_secretstream_xchacha20poly1305_TAG_REKEY) != 0 ||
+		#         sodium_is_zero(STATE_COUNTER(state),
+		#             crypto_secretstream_xchacha20poly1305_COUNTERBYTES)) {
+		#         crypto_secretstream_xchacha20poly1305_rekey(state);
+		#     }
+
+		// Overwrite by reference:
+		$state = $st->toString();
+
+		/** @var bool $rekey */
+		$rekey = ($tag & ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY) !== 0;
+		if ($rekey || $st->needsRekey()) {
+			// DO REKEY
+			self::secretstream_xchacha20poly1305_rekey($state);
+		}
+		return array($out, $tag);
+	}
+
+	/**
+	 * @param string $state
+	 * @return void
+	 * @throws SodiumException
+	 */
+	public static function secretstream_xchacha20poly1305_rekey(&$state)
+	{
+		$st = ParagonIE_Sodium_Core_SecretStream_State::fromString($state);
+		# unsigned char new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES +
+		# crypto_secretstream_xchacha20poly1305_INONCEBYTES];
+		# size_t        i;
+		# for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
+		#     new_key_and_inonce[i] = state->k[i];
+		# }
+		$new_key_and_inonce = $st->getKey();
+
+		# for (i = 0U; i < crypto_secretstream_xchacha20poly1305_INONCEBYTES; i++) {
+		#     new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i] =
+		#         STATE_INONCE(state)[i];
+		# }
+		$new_key_and_inonce .= ParagonIE_Sodium_Core_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_Core_ChaCha20::ietfStreamXorIc(
+			$new_key_and_inonce,
+			$st->getCombinedNonce(),
+			$st->getKey(),
+			ParagonIE_Sodium_Core_Util::store64_le(0)
+		));
+
+		# for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
+		#     state->k[i] = new_key_and_inonce[i];
+		# }
+		# for (i = 0U; i < crypto_secretstream_xchacha20poly1305_INONCEBYTES; i++) {
+		#     STATE_INONCE(state)[i] =
+		#          new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i];
+		# }
+		# _crypto_secretstream_xchacha20poly1305_counter_reset(state);
+		$st->counterReset();
+
+		$state = $st->toString();
+	}
+
+	/**
+	 * Detached Ed25519 signature.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sign_detached($message, $sk)
+	{
+		return ParagonIE_Sodium_Core_Ed25519::sign_detached($message, $sk);
+	}
+
+	/**
+	 * Attached Ed25519 signature. (Returns a signed message.)
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $message
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sign($message, $sk)
+	{
+		return ParagonIE_Sodium_Core_Ed25519::sign($message, $sk);
+	}
+
+	/**
+	 * Opens a signed message. If valid, returns the message.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $signedMessage
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sign_open($signedMessage, $pk)
+	{
+		return ParagonIE_Sodium_Core_Ed25519::sign_open($signedMessage, $pk);
+	}
+
+	/**
+	 * Verify a detached signature of a given message and public key.
+	 *
+	 * @internal Do not use this directly. Use ParagonIE_Sodium_Compat.
+	 *
+	 * @param string $signature
+	 * @param string $message
+	 * @param string $pk
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sign_verify_detached($signature, $message, $pk)
+	{
+		return ParagonIE_Sodium_Core_Ed25519::verify_detached($signature, $message, $pk);
+	}
 }

Spacing +290 added lines, -290 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_Crypto', false)) {
+if ( class_exists( 'ParagonIE_Sodium_Crypto', false ) ) {
     return;
 }
 
@@ -75,13 +75,13 @@ 
         $key = ''
     ) {
         /** @var int $len - Length of message (ciphertext + MAC) */
-        $len = ParagonIE_Sodium_Core_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core_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_Core_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core_Util::strlen( $ad );
 
         /** @var string $mac - Message authentication code */
         $mac = ParagonIE_Sodium_Core_Util::substr(
@@ -91,7 +91,7 @@ 
         );
 
         /** @var string $ciphertext - The encrypted message (sans MAC) */
-        $ciphertext = ParagonIE_Sodium_Core_Util::substr($message, 0, $clen);
+        $ciphertext = ParagonIE_Sodium_Core_Util::substr( $message, 0, $clen );
 
         /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
         $block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
@@ -101,21 +101,21 @@ 
         );
 
         /* Recalculate the Poly1305 authentication tag (MAC): */
-        $state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core_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_Core_Util::store64_le($adlen));
-        $state->update($ciphertext);
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($clen));
+        $state->update( $ad );
+        $state->update( ParagonIE_Sodium_Core_Util::store64_le( $adlen ) );
+        $state->update( $ciphertext );
+        $state->update( ParagonIE_Sodium_Core_Util::store64_le( $clen ) );
         $computed_mac = $state->finish();
 
         /* Compare the given MAC with the recalculated MAC: */
-        if (!ParagonIE_Sodium_Core_Util::verify_16($computed_mac, $mac)) {
-            throw new SodiumException('Invalid MAC');
+        if ( ! ParagonIE_Sodium_Core_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_Core_Util::store64_le(1)
+            ParagonIE_Sodium_Core_Util::store64_le( 1 )
         );
     }
 
@@ -147,10 +147,10 @@ 
         $key = ''
     ) {
         /** @var int $len - Length of the plaintext message */
-        $len = ParagonIE_Sodium_Core_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core_Util::strlen( $message );
 
         /** @var int $adlen - Length of the associated data */
-        $adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core_Util::strlen( $ad );
 
         /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
         $block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
@@ -158,10 +158,10 @@ 
             $nonce,
             $key
         );
-        $state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core_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_Core_Util::store64_le(1)
+            ParagonIE_Sodium_Core_Util::store64_le( 1 )
         );
 
-        $state->update($ad);
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($adlen));
-        $state->update($ciphertext);
-        $state->update(ParagonIE_Sodium_Core_Util::store64_le($len));
+        $state->update( $ad );
+        $state->update( ParagonIE_Sodium_Core_Util::store64_le( $adlen ) );
+        $state->update( $ciphertext );
+        $state->update( ParagonIE_Sodium_Core_Util::store64_le( $len ) );
         return $ciphertext . $state->finish();
     }
 
@@ -200,10 +200,10 @@ 
         $key = ''
     ) {
         /** @var int $adlen - Length of associated data */
-        $adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core_Util::strlen( $ad );
 
         /** @var int $len - Length of message (ciphertext + MAC) */
-        $len = ParagonIE_Sodium_Core_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core_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_Core_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core_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_Core_Util::store64_le($adlen));
-        $state->update(ParagonIE_Sodium_Core_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_Core_Util::store64_le( $adlen ) );
+        $state->update( ParagonIE_Sodium_Core_Util::store64_le( $clen ) );
         $computed_mac = $state->finish();
 
         /* Compare the given MAC with the recalculated MAC: */
-        if (!ParagonIE_Sodium_Core_Util::verify_16($computed_mac, $mac)) {
-            throw new SodiumException('Invalid MAC');
+        if ( ! ParagonIE_Sodium_Core_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_Core_Util::store64_le(1)
+            ParagonIE_Sodium_Core_Util::store64_le( 1 )
         );
     }
 
@@ -278,10 +278,10 @@ 
         $key = ''
     ) {
         /** @var int $len - Length of the plaintext message */
-        $len = ParagonIE_Sodium_Core_Util::strlen($message);
+        $len = ParagonIE_Sodium_Core_Util::strlen( $message );
 
         /** @var int $adlen - Length of the associated data */
-        $adlen = ParagonIE_Sodium_Core_Util::strlen($ad);
+        $adlen = ParagonIE_Sodium_Core_Util::strlen( $ad );
 
         /** @var string The first block of the chacha20 keystream, used as a poly1305 key */
         $block0 = ParagonIE_Sodium_Core_ChaCha20::ietfStream(
@@ -289,10 +289,10 @@ 
             $nonce,
             $key
         );
-        $state = new ParagonIE_Sodium_Core_Poly1305_State($block0);
+        $state = new ParagonIE_Sodium_Core_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_Core_Util::store64_le(1)
+            ParagonIE_Sodium_Core_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_Core_Util::store64_le($adlen));
-        $state->update(ParagonIE_Sodium_Core_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_Core_Util::store64_le( $adlen ) );
+        $state->update( ParagonIE_Sodium_Core_Util::store64_le( $len ) );
         return $ciphertext . $state->finish();
     }
 
@@ -333,13 +333,13 @@ 
         $key = ''
     ) {
         $subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
+            ParagonIE_Sodium_Core_Util::substr( $nonce, 0, 16 ),
             $key
         );
         $nonceLast = "\x00\x00\x00\x00" .
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+            ParagonIE_Sodium_Core_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_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
+            ParagonIE_Sodium_Core_Util::substr( $nonce, 0, 16 ),
             $key
         );
         $nonceLast = "\x00\x00\x00\x00" .
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+            ParagonIE_Sodium_Core_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_Core_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_Core_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 )
     {
         $c = self::secretbox(
             $plaintext,
             $nonce,
             self::box_beforenm(
-                self::box_secretkey($keypair),
-                self::box_publickey($keypair)
+                self::box_secretkey( $keypair ),
+                self::box_publickey( $keypair )
             )
         );
         return $c;
@@ -446,16 +446,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(
@@ -465,15 +465,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;
@@ -492,19 +492,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_Core_Util::substr($message, 0, 32);
+        $ephemeralPK = ParagonIE_Sodium_Core_Util::substr( $message, 0, 32 );
 
         /** @var string $ciphertext (ciphertext + MAC) */
-        $ciphertext = ParagonIE_Sodium_Core_Util::substr($message, 32);
+        $ciphertext = ParagonIE_Sodium_Core_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(
@@ -514,15 +514,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;
@@ -541,11 +541,11 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_beforenm($sk, $pk)
+    public static function box_beforenm( $sk, $pk )
     {
         return ParagonIE_Sodium_Core_HSalsa20::hsalsa20(
-            str_repeat("\x00", 16),
-            self::scalarmult($sk, $pk)
+            str_repeat( "\x00", 16 ),
+            self::scalarmult( $sk, $pk )
         );
     }
 
@@ -559,8 +559,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;
     }
 
@@ -570,14 +570,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seed_keypair($seed)
+    public static function box_seed_keypair( $seed )
     {
         $sKey = ParagonIE_Sodium_Core_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;
     }
 
@@ -589,10 +589,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_Core_Util::substr($sKey, 0, 32) .
-            ParagonIE_Sodium_Core_Util::substr($pKey, 0, 32);
+        return ParagonIE_Sodium_Core_Util::substr( $sKey, 0, 32 ) .
+            ParagonIE_Sodium_Core_Util::substr( $pKey, 0, 32 );
     }
 
     /**
@@ -603,14 +603,14 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function box_secretkey($keypair)
+    public static function box_secretkey( $keypair )
     {
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== 64) {
+        if ( ParagonIE_Sodium_Core_Util::strlen( $keypair ) !== 64 ) {
             throw new RangeException(
                 'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES bytes long.'
             );
         }
-        return ParagonIE_Sodium_Core_Util::substr($keypair, 0, 32);
+        return ParagonIE_Sodium_Core_Util::substr( $keypair, 0, 32 );
     }
 
     /**
@@ -621,14 +621,14 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function box_publickey($keypair)
+    public static function box_publickey( $keypair )
     {
-        if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
+        if ( ParagonIE_Sodium_Core_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_Core_Util::substr($keypair, 32, 32);
+        return ParagonIE_Sodium_Core_Util::substr( $keypair, 32, 32 );
     }
 
     /**
@@ -640,14 +640,14 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_publickey_from_secretkey($sKey)
+    public static function box_publickey_from_secretkey( $sKey )
     {
-        if (ParagonIE_Sodium_Core_Util::strlen($sKey) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES) {
+        if ( ParagonIE_Sodium_Core_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 );
     }
 
     /**
@@ -662,14 +662,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 )
             )
         );
     }
@@ -687,34 +687,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_Core_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
 
         $k = null;
-        if (!empty($key)) {
+        if ( ! empty( $key ) ) {
             /** @var SplFixedArray $k */
-            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
+            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray( $key );
+            if ( $k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES ) {
+                throw new RangeException( 'Invalid key size' );
             }
         }
 
         /** @var SplFixedArray $in */
-        $in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($message);
+        $in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray( $message );
 
         /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outlen);
-        ParagonIE_Sodium_Core_BLAKE2b::update($ctx, $in, $in->count());
+        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init( $k, $outlen );
+        ParagonIE_Sodium_Core_BLAKE2b::update( $ctx, $in, $in->count() );
 
         /** @var SplFixedArray $out */
-        $out = new SplFixedArray($outlen);
-        $out = ParagonIE_Sodium_Core_BLAKE2b::finish($ctx, $out);
+        $out = new SplFixedArray( $outlen );
+        $out = ParagonIE_Sodium_Core_BLAKE2b::finish( $ctx, $out );
 
         /** @var array<int, int> */
         $outArray = $out->toArray();
-        return ParagonIE_Sodium_Core_Util::intArrayToString($outArray);
+        return ParagonIE_Sodium_Core_Util::intArrayToString( $outArray );
     }
 
     /**
@@ -728,22 +728,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_Core_BLAKE2b::stringToContext($ctx);
+        $context = ParagonIE_Sodium_Core_BLAKE2b::stringToContext( $ctx );
 
         /** @var SplFixedArray $out */
-        $out = ParagonIE_Sodium_Core_BLAKE2b::finish($context, $out);
+        $out = ParagonIE_Sodium_Core_BLAKE2b::finish( $context, $out );
 
         /** @var array<int, int> */
         $outArray = $out->toArray();
-        return ParagonIE_Sodium_Core_Util::intArrayToString($outArray);
+        return ParagonIE_Sodium_Core_Util::intArrayToString( $outArray );
     }
 
     /**
@@ -758,23 +758,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_Core_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
 
         $k = null;
-        if (!empty($key)) {
-            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
+        if ( ! empty( $key ) ) {
+            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray( $key );
+            if ( $k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES ) {
+                throw new RangeException( 'Invalid key size' );
             }
         }
 
         /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outputLength);
+        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init( $k, $outputLength );
 
-        return ParagonIE_Sodium_Core_BLAKE2b::contextToString($ctx);
+        return ParagonIE_Sodium_Core_BLAKE2b::contextToString( $ctx );
     }
 
     /**
@@ -801,27 +801,27 @@ 
         ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
 
         $k = null;
-        if (!empty($key)) {
-            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($key);
-            if ($k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES) {
-                throw new RangeException('Invalid key size');
+        if ( ! empty( $key ) ) {
+            $k = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray( $key );
+            if ( $k->count() > ParagonIE_Sodium_Core_BLAKE2b::KEYBYTES ) {
+                throw new RangeException( 'Invalid key size' );
             }
         }
-        if (!empty($salt)) {
-            $s = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($salt);
+        if ( ! empty( $salt ) ) {
+            $s = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray( $salt );
         } else {
             $s = null;
         }
-        if (!empty($salt)) {
-            $p = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($personal);
+        if ( ! empty( $salt ) ) {
+            $p = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray( $personal );
         } else {
             $p = null;
         }
 
         /** @var SplFixedArray $ctx */
-        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init($k, $outputLength, $s, $p);
+        $ctx = ParagonIE_Sodium_Core_BLAKE2b::init( $k, $outputLength, $s, $p );
 
-        return ParagonIE_Sodium_Core_BLAKE2b::contextToString($ctx);
+        return ParagonIE_Sodium_Core_BLAKE2b::contextToString( $ctx );
     }
 
     /**
@@ -835,20 +835,20 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function generichash_update($ctx, $message)
+    public static function generichash_update( $ctx, $message )
     {
         // This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
 
         /** @var SplFixedArray $context */
-        $context = ParagonIE_Sodium_Core_BLAKE2b::stringToContext($ctx);
+        $context = ParagonIE_Sodium_Core_BLAKE2b::stringToContext( $ctx );
 
         /** @var SplFixedArray $in */
-        $in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray($message);
+        $in = ParagonIE_Sodium_Core_BLAKE2b::stringToSplFixedArray( $message );
 
-        ParagonIE_Sodium_Core_BLAKE2b::update($context, $in, $in->count());
+        ParagonIE_Sodium_Core_BLAKE2b::update( $context, $in, $in->count() );
 
-        return ParagonIE_Sodium_Core_BLAKE2b::contextToString($context);
+        return ParagonIE_Sodium_Core_BLAKE2b::contextToString( $context );
     }
 
     /**
@@ -864,10 +864,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 ParagonIE_Sodium_Compat::crypto_generichash(
-            ParagonIE_Sodium_Compat::crypto_scalarmult($my_sk, $their_pk) .
+            ParagonIE_Sodium_Compat::crypto_scalarmult( $my_sk, $their_pk ) .
             $client_pk .
             $server_pk
         );
@@ -885,10 +885,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function scalarmult($sKey, $pKey)
+    public static function scalarmult( $sKey, $pKey )
     {
-        $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10($sKey, $pKey);
-        self::scalarmult_throw_if_zero($q);
+        $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10( $sKey, $pKey );
+        self::scalarmult_throw_if_zero( $q );
         return $q;
     }
 
@@ -902,10 +902,10 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function scalarmult_base($secret)
+    public static function scalarmult_base( $secret )
     {
-        $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10_base($secret);
-        self::scalarmult_throw_if_zero($q);
+        $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10_base( $secret );
+        self::scalarmult_throw_if_zero( $q );
         return $q;
     }
 
@@ -917,16 +917,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_Core_Util::chrToInt($q[$i]);
+        for ( $i = 0; $i < self::box_curve25519xsalsa20poly1305_SECRETKEYBYTES; ++$i ) {
+            $d |= ParagonIE_Sodium_Core_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' );
         }
     }
 
@@ -942,26 +942,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_Core_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core_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_Core_Util::strlen($plaintext);
+        $mlen = ParagonIE_Sodium_Core_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_Core_Util::substr($plaintext, 0, $mlen0);
+        $block0 .= ParagonIE_Sodium_Core_Util::substr( $plaintext, 0, $mlen0 );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20_xor(
             $block0,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+            ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 ),
             $subkey
         );
 
@@ -970,13 +970,13 @@ 
             $block0,
             self::secretbox_xsalsa20poly1305_ZEROBYTES
         );
-        if ($mlen > $mlen0) {
+        if ( $mlen > $mlen0 ) {
             $c .= ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
                 ParagonIE_Sodium_Core_Util::substr(
                     $plaintext,
                     self::secretbox_xsalsa20poly1305_ZEROBYTES
                 ),
-                ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+                ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 ),
                 1,
                 $subkey
             );
@@ -989,18 +989,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;
     }
@@ -1017,7 +1017,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_Core_Util::substr(
@@ -1033,46 +1033,46 @@ 
         );
 
         /** @var int $clen */
-        $clen = ParagonIE_Sodium_Core_Util::strlen($c);
+        $clen = ParagonIE_Sodium_Core_Util::strlen( $c );
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20( $nonce, $key );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20(
             64,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+            ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 ),
             $subkey
         );
         $verified = ParagonIE_Sodium_Core_Poly1305::onetimeauth_verify(
             $mac,
             $c,
-            ParagonIE_Sodium_Core_Util::substr($block0, 0, 32)
+            ParagonIE_Sodium_Core_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_Core_Util::xorStrings(
-            ParagonIE_Sodium_Core_Util::substr($block0, self::secretbox_xsalsa20poly1305_ZEROBYTES),
-            ParagonIE_Sodium_Core_Util::substr($c, 0, self::secretbox_xsalsa20poly1305_ZEROBYTES)
+            ParagonIE_Sodium_Core_Util::substr( $block0, self::secretbox_xsalsa20poly1305_ZEROBYTES ),
+            ParagonIE_Sodium_Core_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_Core_Salsa20::salsa20_xor_ic(
                 ParagonIE_Sodium_Core_Util::substr(
                     $c,
                     self::secretbox_xsalsa20poly1305_ZEROBYTES
                 ),
-                ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+                ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 ),
                 1,
-                (string) $subkey
+                (string)$subkey
             );
         }
         return $m;
@@ -1090,25 +1090,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_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
+            ParagonIE_Sodium_Core_Util::substr( $nonce, 0, 16 ),
             $key
         );
-        $nonceLast = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+        $nonceLast = ParagonIE_Sodium_Core_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_Core_Util::strlen($plaintext);
+        $mlen = ParagonIE_Sodium_Core_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_Core_Util::substr($plaintext, 0, $mlen0);
+        $block0 .= ParagonIE_Sodium_Core_Util::substr( $plaintext, 0, $mlen0 );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
@@ -1122,7 +1122,7 @@ 
             $block0,
             self::secretbox_xchacha20poly1305_ZEROBYTES
         );
-        if ($mlen > $mlen0) {
+        if ( $mlen > $mlen0 ) {
             $c .= ParagonIE_Sodium_Core_ChaCha20::streamXorIc(
                 ParagonIE_Sodium_Core_Util::substr(
                     $plaintext,
@@ -1130,7 +1130,7 @@ 
                 ),
                 $nonceLast,
                 $subkey,
-                ParagonIE_Sodium_Core_Util::store64_le(1)
+                ParagonIE_Sodium_Core_Util::store64_le( 1 )
             );
         }
         $state = new ParagonIE_Sodium_Core_Poly1305_State(
@@ -1141,18 +1141,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;
     }
@@ -1169,7 +1169,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_Core_Util::substr(
@@ -1185,48 +1185,48 @@ 
         );
 
         /** @var int $clen */
-        $clen = ParagonIE_Sodium_Core_Util::strlen($c);
+        $clen = ParagonIE_Sodium_Core_Util::strlen( $c );
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HChaCha20::hchacha20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core_HChaCha20::hchacha20( $nonce, $key );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core_ChaCha20::stream(
             64,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+            ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 ),
             $subkey
         );
         $verified = ParagonIE_Sodium_Core_Poly1305::onetimeauth_verify(
             $mac,
             $c,
-            ParagonIE_Sodium_Core_Util::substr($block0, 0, 32)
+            ParagonIE_Sodium_Core_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_Core_Util::xorStrings(
-            ParagonIE_Sodium_Core_Util::substr($block0, self::secretbox_xchacha20poly1305_ZEROBYTES),
-            ParagonIE_Sodium_Core_Util::substr($c, 0, self::secretbox_xchacha20poly1305_ZEROBYTES)
+            ParagonIE_Sodium_Core_Util::substr( $block0, self::secretbox_xchacha20poly1305_ZEROBYTES ),
+            ParagonIE_Sodium_Core_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_Core_ChaCha20::streamXorIc(
                 ParagonIE_Sodium_Core_Util::substr(
                     $c,
                     self::secretbox_xchacha20poly1305_ZEROBYTES
                 ),
-                ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-                (string) $subkey,
-                ParagonIE_Sodium_Core_Util::store64_le(1)
+                ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 ),
+                (string)$subkey,
+                ParagonIE_Sodium_Core_Util::store64_le( 1 )
             );
         }
         return $m;
@@ -1238,16 +1238,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_Core_HChaCha20::hChaCha20($out, $key);
+        $subkey = ParagonIE_Sodium_Core_HChaCha20::hChaCha20( $out, $key );
         $state = new ParagonIE_Sodium_Core_SecretStream_State(
             $subkey,
-            ParagonIE_Sodium_Core_Util::substr($out, 16, 8) . str_repeat("\0", 4)
+            ParagonIE_Sodium_Core_Util::substr( $out, 16, 8 ) . str_repeat( "\0", 4 )
         );
 
         # _crypto_secretstream_xchacha20poly1305_counter_reset(state);
@@ -1268,16 +1268,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_Core_HChaCha20::hChaCha20(
-            ParagonIE_Sodium_Core_Util::substr($header, 0, 16),
+            ParagonIE_Sodium_Core_Util::substr( $header, 0, 16 ),
             $key
         );
         $state = new ParagonIE_Sodium_Core_SecretStream_State(
             $subkey,
-            ParagonIE_Sodium_Core_Util::substr($header, 16)
+            ParagonIE_Sodium_Core_Util::substr( $header, 16 )
         );
         $state->counterReset();
         # memcpy(STATE_INONCE(state), in + crypto_core_hchacha20_INPUTBYTES,
@@ -1295,19 +1295,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_Core_SecretStream_State::fromString($state);
+        $st = ParagonIE_Sodium_Core_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_Core_Util::strlen($msg);
-        $aadlen = ParagonIE_Sodium_Core_Util::strlen($aad);
+        $msglen = ParagonIE_Sodium_Core_Util::strlen( $msg );
+        $aadlen = ParagonIE_Sodium_Core_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'
             );
@@ -1324,62 +1324,62 @@ 
         # crypto_onetimeauth_poly1305_init(&poly1305_state, block);
         # sodium_memzero(block, sizeof block);
         $auth = new ParagonIE_Sodium_Core_Poly1305_State(
-            ParagonIE_Sodium_Core_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
+            ParagonIE_Sodium_Core_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_Core_ChaCha20::ietfStreamXorIc(
-            ParagonIE_Sodium_Core_Util::intToChr($tag) . str_repeat("\0", 63),
+            ParagonIE_Sodium_Core_Util::intToChr( $tag ) . str_repeat( "\0", 63 ),
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(1)
+            ParagonIE_Sodium_Core_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_Core_ChaCha20::ietfStreamXorIc(
             $msg,
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(2)
+            ParagonIE_Sodium_Core_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_Core_Util::store64_le($aadlen);
+        $slen = ParagonIE_Sodium_Core_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_Core_Util::store64_le(64 + $msglen);
+        $slen = ParagonIE_Sodium_Core_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);
@@ -1387,12 +1387,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);
@@ -1401,15 +1401,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;
@@ -1424,19 +1424,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_Core_SecretStream_State::fromString($state);
+        $st = ParagonIE_Sodium_Core_SecretStream_State::fromString( $state );
 
-        $cipherlen = ParagonIE_Sodium_Core_Util::strlen($cipher);
+        $cipherlen = ParagonIE_Sodium_Core_Util::strlen( $cipher );
         #     mlen = inlen - crypto_secretstream_xchacha20poly1305_ABYTES;
         $msglen = $cipherlen - ParagonIE_Sodium_Compat::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES;
-        $aadlen = ParagonIE_Sodium_Core_Util::strlen($aad);
+        $aadlen = ParagonIE_Sodium_Core_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'
             );
@@ -1446,15 +1446,15 @@ 
         #     crypto_onetimeauth_poly1305_init(&poly1305_state, block);
         #     sodium_memzero(block, sizeof block);
         $auth = new ParagonIE_Sodium_Core_Poly1305_State(
-            ParagonIE_Sodium_Core_ChaCha20::ietfStream(32, $st->getCombinedNonce(), $st->getKey())
+            ParagonIE_Sodium_Core_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);
@@ -1462,36 +1462,36 @@ 
         #     crypto_stream_chacha20_ietf_xor_ic(block, block, sizeof block,
         #                                        state->nonce, 1U, state->k);
         $block = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
-            $cipher[0] . str_repeat("\0", 63),
+            $cipher[ 0 ] . str_repeat( "\0", 63 ),
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(1)
+            ParagonIE_Sodium_Core_Util::store64_le( 1 )
         );
         #     tag = block[0];
         #     block[0] = in[0];
         #     crypto_onetimeauth_poly1305_update(&poly1305_state, block, sizeof block);
-        $tag = ParagonIE_Sodium_Core_Util::chrToInt($block[0]);
-        $block[0] = $cipher[0];
-        $auth->update($block);
+        $tag = ParagonIE_Sodium_Core_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_Core_Util::substr($cipher, 1, $msglen));
+        $auth->update( ParagonIE_Sodium_Core_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_Core_Util::store64_le($aadlen);
-        $auth->update($slen);
+        $slen = ParagonIE_Sodium_Core_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_Core_Util::store64_le(64 + $msglen);
-        $auth->update($slen);
+        $slen = ParagonIE_Sodium_Core_Util::store64_le( 64 + $msglen );
+        $auth->update( $slen );
 
         #     crypto_onetimeauth_poly1305_final(&poly1305_state, mac);
         #     sodium_memzero(&poly1305_state, sizeof poly1305_state);
@@ -1503,22 +1503,22 @@ 
         #         return -1;
         #     }
 
-        $stored = ParagonIE_Sodium_Core_Util::substr($cipher, $msglen + 1, 16);
-        if (!ParagonIE_Sodium_Core_Util::hashEquals($mac, $stored)) {
+        $stored = ParagonIE_Sodium_Core_Util::substr( $cipher, $msglen + 1, 16 );
+        if ( ! ParagonIE_Sodium_Core_Util::hashEquals( $mac, $stored ) ) {
             return false;
         }
 
         #     crypto_stream_chacha20_ietf_xor_ic(m, c, mlen, state->nonce, 2U, state->k);
         $out = ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
-            ParagonIE_Sodium_Core_Util::substr($cipher, 1, $msglen),
+            ParagonIE_Sodium_Core_Util::substr( $cipher, 1, $msglen ),
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(2)
+            ParagonIE_Sodium_Core_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);
@@ -1534,12 +1534,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 );
     }
 
     /**
@@ -1547,9 +1547,9 @@ 
      * @return void
      * @throws SodiumException
      */
-    public static function secretstream_xchacha20poly1305_rekey(&$state)
+    public static function secretstream_xchacha20poly1305_rekey( &$state )
     {
-        $st = ParagonIE_Sodium_Core_SecretStream_State::fromString($state);
+        $st = ParagonIE_Sodium_Core_SecretStream_State::fromString( $state );
         # unsigned char new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES +
         # crypto_secretstream_xchacha20poly1305_INONCEBYTES];
         # size_t        i;
@@ -1562,18 +1562,18 @@ 
         #     new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES + i] =
         #         STATE_INONCE(state)[i];
         # }
-        $new_key_and_inonce .= ParagonIE_Sodium_Core_Util::substR($st->getNonce(), 0, 8);
+        $new_key_and_inonce .= ParagonIE_Sodium_Core_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_Core_ChaCha20::ietfStreamXorIc(
+        $st->rekey( ParagonIE_Sodium_Core_ChaCha20::ietfStreamXorIc(
             $new_key_and_inonce,
             $st->getCombinedNonce(),
             $st->getKey(),
-            ParagonIE_Sodium_Core_Util::store64_le(0)
-        ));
+            ParagonIE_Sodium_Core_Util::store64_le( 0 )
+        ) );
 
         # for (i = 0U; i < crypto_stream_chacha20_ietf_KEYBYTES; i++) {
         #     state->k[i] = new_key_and_inonce[i];
@@ -1599,9 +1599,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_detached($message, $sk)
+    public static function sign_detached( $message, $sk )
     {
-        return ParagonIE_Sodium_Core_Ed25519::sign_detached($message, $sk);
+        return ParagonIE_Sodium_Core_Ed25519::sign_detached( $message, $sk );
     }
 
     /**
@@ -1615,9 +1615,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($message, $sk)
+    public static function sign( $message, $sk )
     {
-        return ParagonIE_Sodium_Core_Ed25519::sign($message, $sk);
+        return ParagonIE_Sodium_Core_Ed25519::sign( $message, $sk );
     }
 
     /**
@@ -1631,9 +1631,9 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_open($signedMessage, $pk)
+    public static function sign_open( $signedMessage, $pk )
     {
-        return ParagonIE_Sodium_Core_Ed25519::sign_open($signedMessage, $pk);
+        return ParagonIE_Sodium_Core_Ed25519::sign_open( $signedMessage, $pk );
     }
 
     /**
@@ -1648,8 +1648,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_Core_Ed25519::verify_detached($signature, $message, $pk);
+        return ParagonIE_Sodium_Core_Ed25519::verify_detached( $signature, $message, $pk );
     }
 }

Braces +35 added lines, -70 removed lines

@@ -12,8 +12,7 @@ 
  * If you are using this library, you should be using
  * ParagonIE_Sodium_Compat in your code, not this class.
  */
-abstract class ParagonIE_Sodium_Crypto
-{
+abstract class ParagonIE_Sodium_Crypto {
     const aead_chacha20poly1305_KEYBYTES = 32;
     const aead_chacha20poly1305_NSECBYTES = 0;
     const aead_chacha20poly1305_NPUBBYTES = 8;
@@ -381,8 +380,7 @@ 
      * @return string
      * @throws TypeError
      */
-    public static function auth($message, $key)
-    {
+    public static function auth($message, $key) {
         return ParagonIE_Sodium_Core_Util::substr(
             hash_hmac('sha512', $message, $key, true),
             0,
@@ -402,8 +400,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function auth_verify($mac, $message, $key)
-    {
+    public static function auth_verify($mac, $message, $key) {
         return ParagonIE_Sodium_Core_Util::hashEquals(
             $mac,
             self::auth($message, $key)
@@ -422,8 +419,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box($plaintext, $nonce, $keypair)
-    {
+    public static function box($plaintext, $nonce, $keypair) {
         $c = self::secretbox(
             $plaintext,
             $nonce,
@@ -446,8 +442,7 @@ 
      * @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();
 
@@ -492,8 +487,7 @@ 
      * @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_Core_Util::substr($message, 0, 32);
 
@@ -541,8 +535,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_beforenm($sk, $pk)
-    {
+    public static function box_beforenm($sk, $pk) {
         return ParagonIE_Sodium_Core_HSalsa20::hsalsa20(
             str_repeat("\x00", 16),
             self::scalarmult($sk, $pk)
@@ -557,8 +550,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_keypair()
-    {
+    public static function box_keypair() {
         $sKey = random_bytes(32);
         $pKey = self::scalarmult_base($sKey);
         return $sKey . $pKey;
@@ -570,8 +562,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seed_keypair($seed)
-    {
+    public static function box_seed_keypair($seed) {
         $sKey = ParagonIE_Sodium_Core_Util::substr(
             hash('sha512', $seed, true),
             0,
@@ -589,8 +580,7 @@ 
      * @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_Core_Util::substr($sKey, 0, 32) .
             ParagonIE_Sodium_Core_Util::substr($pKey, 0, 32);
     }
@@ -603,8 +593,7 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function box_secretkey($keypair)
-    {
+    public static function box_secretkey($keypair) {
         if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== 64) {
             throw new RangeException(
                 'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES bytes long.'
@@ -621,8 +610,7 @@ 
      * @throws RangeException
      * @throws TypeError
      */
-    public static function box_publickey($keypair)
-    {
+    public static function box_publickey($keypair) {
         if (ParagonIE_Sodium_Core_Util::strlen($keypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
             throw new RangeException(
                 'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES bytes long.'
@@ -640,8 +628,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_publickey_from_secretkey($sKey)
-    {
+    public static function box_publickey_from_secretkey($sKey) {
         if (ParagonIE_Sodium_Core_Util::strlen($sKey) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES) {
             throw new RangeException(
                 'Must be ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES bytes long.'
@@ -662,8 +649,7 @@ 
      * @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,
@@ -687,8 +673,7 @@ 
      * @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_Core_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
 
@@ -728,8 +713,7 @@ 
      * @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');
         }
@@ -758,8 +742,7 @@ 
      * @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_Core_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
 
@@ -835,8 +818,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function generichash_update($ctx, $message)
-    {
+    public static function generichash_update($ctx, $message) {
         // This ensures that ParagonIE_Sodium_Core_BLAKE2b::$iv is initialized
         ParagonIE_Sodium_Core_BLAKE2b::pseudoConstructor();
 
@@ -864,8 +846,7 @@ 
      * @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 ParagonIE_Sodium_Compat::crypto_generichash(
             ParagonIE_Sodium_Compat::crypto_scalarmult($my_sk, $their_pk) .
             $client_pk .
@@ -885,8 +866,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function scalarmult($sKey, $pKey)
-    {
+    public static function scalarmult($sKey, $pKey) {
         $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10($sKey, $pKey);
         self::scalarmult_throw_if_zero($q);
         return $q;
@@ -902,8 +882,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function scalarmult_base($secret)
-    {
+    public static function scalarmult_base($secret) {
         $q = ParagonIE_Sodium_Core_X25519::crypto_scalarmult_curve25519_ref10_base($secret);
         self::scalarmult_throw_if_zero($q);
         return $q;
@@ -917,8 +896,7 @@ 
      * @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_Core_Util::chrToInt($q[$i]);
@@ -942,8 +920,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox($plaintext, $nonce, $key)
-    {
+    public static function secretbox($plaintext, $nonce, $key) {
         /** @var string $subkey */
         $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
 
@@ -1017,8 +994,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_Core_Util::substr(
             $ciphertext,
@@ -1090,8 +1066,7 @@ 
      * @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_Core_HChaCha20::hChaCha20(
             ParagonIE_Sodium_Core_Util::substr($nonce, 0, 16),
@@ -1169,8 +1144,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_Core_Util::substr(
             $ciphertext,
@@ -1238,8 +1212,7 @@ 
      * @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);
 
@@ -1268,8 +1241,7 @@ 
      * @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_Core_HChaCha20::hChaCha20(
             ParagonIE_Sodium_Core_Util::substr($header, 0, 16),
@@ -1295,8 +1267,7 @@ 
      * @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_Core_SecretStream_State::fromString($state);
         # crypto_onetimeauth_poly1305_state poly1305_state;
         # unsigned char                     block[64U];
@@ -1424,8 +1395,7 @@ 
      * @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_Core_SecretStream_State::fromString($state);
 
         $cipherlen = ParagonIE_Sodium_Core_Util::strlen($cipher);
@@ -1547,8 +1517,7 @@ 
      * @return void
      * @throws SodiumException
      */
-    public static function secretstream_xchacha20poly1305_rekey(&$state)
-    {
+    public static function secretstream_xchacha20poly1305_rekey(&$state) {
         $st = ParagonIE_Sodium_Core_SecretStream_State::fromString($state);
         # unsigned char new_key_and_inonce[crypto_stream_chacha20_ietf_KEYBYTES +
         # crypto_secretstream_xchacha20poly1305_INONCEBYTES];
@@ -1599,8 +1568,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_detached($message, $sk)
-    {
+    public static function sign_detached($message, $sk) {
         return ParagonIE_Sodium_Core_Ed25519::sign_detached($message, $sk);
     }
 
@@ -1615,8 +1583,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($message, $sk)
-    {
+    public static function sign($message, $sk) {
         return ParagonIE_Sodium_Core_Ed25519::sign($message, $sk);
     }
 
@@ -1631,8 +1598,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign_open($signedMessage, $pk)
-    {
+    public static function sign_open($signedMessage, $pk) {
         return ParagonIE_Sodium_Core_Ed25519::sign_open($signedMessage, $pk);
     }
 
@@ -1648,8 +1614,7 @@ 
      * @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_Core_Ed25519::verify_detached($signature, $message, $pk);
     }
 }

vendor/paragonie/sodium_compat/src/File.php

Indentation +1532 added lines, -1532 removed lines

@@ -1,1560 +1,1560 @@
 <?php
 
 if (class_exists('ParagonIE_Sodium_File', false)) {
-    return;
+	return;
 }
 /**
  * Class ParagonIE_Sodium_File
  */
 class ParagonIE_Sodium_File extends ParagonIE_Sodium_Core_Util
 {
-    /* PHP's default buffer size is 8192 for fread()/fwrite(). */
-    const BUFFER_SIZE = 8192;
-
-    /**
-     * Box a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_box(), but produces
-     * the same result.
-     *
-     * @param string $inputFile  Absolute path to a file on the filesystem
-     * @param string $outputFile Absolute path to a file on the filesystem
-     * @param string $nonce      Number to be used only once
-     * @param string $keyPair    ECDH secret key and ECDH public key concatenated
-     *
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box($inputFile, $outputFile, $nonce, $keyPair)
-    {
-        /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
-        }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
-        }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
-        }
-
-        /* Input validation: */
-        if (!is_string($keyPair)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($keyPair) . ' given.');
-        }
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_BOX_NONCEBYTES bytes');
-        }
-        if (self::strlen($keyPair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
-        }
-
-        /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
-        }
-
-        $res = self::box_encrypt($ifp, $ofp, $size, $nonce, $keyPair);
-        fclose($ifp);
-        fclose($ofp);
-        return $res;
-    }
-
-    /**
-     * Open a boxed file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_box_open(), but produces
-     * the same result.
-     *
-     * Warning: Does not protect against TOCTOU attacks. You should
-     * just load the file into memory and use crypto_box_open() if
-     * you are worried about those.
-     *
-     * @param string $inputFile
-     * @param string $outputFile
-     * @param string $nonce
-     * @param string $keypair
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_open($inputFile, $outputFile, $nonce, $keypair)
-    {
-        /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
-        }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
-        }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
-        }
-        if (!is_string($keypair)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($keypair) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_BOX_NONCEBYTES bytes');
-        }
-        if (self::strlen($keypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
-        }
-
-        /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
-        }
-
-        $res = self::box_decrypt($ifp, $ofp, $size, $nonce, $keypair);
-        fclose($ifp);
-        fclose($ofp);
-        try {
-            ParagonIE_Sodium_Compat::memzero($nonce);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-        } catch (SodiumException $ex) {
-            if (isset($ephKeypair)) {
-                unset($ephKeypair);
-            }
-        }
-        return $res;
-    }
-
-    /**
-     * Seal a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_box_seal(), but produces
-     * the same result.
-     *
-     * @param string $inputFile  Absolute path to a file on the filesystem
-     * @param string $outputFile Absolute path to a file on the filesystem
-     * @param string $publicKey  ECDH public key
-     *
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_seal($inputFile, $outputFile, $publicKey)
-    {
-        /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
-        }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
-        }
-        if (!is_string($publicKey)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($publicKey) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($publicKey) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_BOX_PUBLICKEYBYTES bytes');
-        }
-
-        /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
-        }
-
-        /** @var string $ephKeypair */
-        $ephKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair();
-
-        /** @var string $msgKeypair */
-        $msgKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey(
-            ParagonIE_Sodium_Compat::crypto_box_secretkey($ephKeypair),
-            $publicKey
-        );
-
-        /** @var string $ephemeralPK */
-        $ephemeralPK = ParagonIE_Sodium_Compat::crypto_box_publickey($ephKeypair);
-
-        /** @var string $nonce */
-        $nonce = ParagonIE_Sodium_Compat::crypto_generichash(
-            $ephemeralPK . $publicKey,
-            '',
-            24
-        );
-
-        /** @var int $firstWrite */
-        $firstWrite = fwrite(
-            $ofp,
-            $ephemeralPK,
-            ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES
-        );
-        if (!is_int($firstWrite)) {
-            fclose($ifp);
-            fclose($ofp);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-            throw new SodiumException('Could not write to output file');
-        }
-        if ($firstWrite !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-            fclose($ifp);
-            fclose($ofp);
-            throw new SodiumException('Error writing public key to output file');
-        }
-
-        $res = self::box_encrypt($ifp, $ofp, $size, $nonce, $msgKeypair);
-        fclose($ifp);
-        fclose($ofp);
-        try {
-            ParagonIE_Sodium_Compat::memzero($nonce);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-        } catch (SodiumException $ex) {
-            /** @psalm-suppress PossiblyUndefinedVariable */
-            unset($ephKeypair);
-        }
-        return $res;
-    }
-
-    /**
-     * Open a sealed file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_box_seal_open(), but produces
-     * the same result.
-     *
-     * Warning: Does not protect against TOCTOU attacks. You should
-     * just load the file into memory and use crypto_box_seal_open() if
-     * you are worried about those.
-     *
-     * @param string $inputFile
-     * @param string $outputFile
-     * @param string $ecdhKeypair
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function box_seal_open($inputFile, $outputFile, $ecdhKeypair)
-    {
-        /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
-        }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
-        }
-        if (!is_string($ecdhKeypair)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($ecdhKeypair) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($ecdhKeypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
-        }
-
-        $publicKey = ParagonIE_Sodium_Compat::crypto_box_publickey($ecdhKeypair);
-
-        /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
-        }
-
-        $ephemeralPK = fread($ifp, ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES);
-        if (!is_string($ephemeralPK)) {
-            throw new SodiumException('Could not read input file');
-        }
-        if (self::strlen($ephemeralPK) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
-            fclose($ifp);
-            fclose($ofp);
-            throw new SodiumException('Could not read public key from sealed file');
-        }
-
-        $nonce = ParagonIE_Sodium_Compat::crypto_generichash(
-            $ephemeralPK . $publicKey,
-            '',
-            24
-        );
-        $msgKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey(
-            ParagonIE_Sodium_Compat::crypto_box_secretkey($ecdhKeypair),
-            $ephemeralPK
-        );
-
-        $res = self::box_decrypt($ifp, $ofp, $size, $nonce, $msgKeypair);
-        fclose($ifp);
-        fclose($ofp);
-        try {
-            ParagonIE_Sodium_Compat::memzero($nonce);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-        } catch (SodiumException $ex) {
-            if (isset($ephKeypair)) {
-                unset($ephKeypair);
-            }
-        }
-        return $res;
-    }
-
-    /**
-     * Calculate the BLAKE2b hash of a file.
-     *
-     * @param string      $filePath     Absolute path to a file on the filesystem
-     * @param string|null $key          BLAKE2b key
-     * @param int         $outputLength Length of hash output
-     *
-     * @return string                   BLAKE2b hash
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress FailedTypeResolution
-     */
-    public static function generichash($filePath, $key = '', $outputLength = 32)
-    {
-        /* Type checks: */
-        if (!is_string($filePath)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
-        }
-        if (!is_string($key)) {
-            if (is_null($key)) {
-                $key = '';
-            } else {
-                throw new TypeError('Argument 2 must be a string, ' . gettype($key) . ' given.');
-            }
-        }
-        if (!is_int($outputLength)) {
-            if (!is_numeric($outputLength)) {
-                throw new TypeError('Argument 3 must be an integer, ' . gettype($outputLength) . ' given.');
-            }
-            $outputLength = (int) $outputLength;
-        }
-
-        /* Input validation: */
-        if (!empty($key)) {
-            if (self::strlen($key) < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MIN) {
-                throw new TypeError('Argument 2 must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes');
-            }
-            if (self::strlen($key) > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MAX) {
-                throw new TypeError('Argument 2 must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes');
-            }
-        }
-        if ($outputLength < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MIN) {
-            throw new SodiumException('Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MIN');
-        }
-        if ($outputLength > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MAX) {
-            throw new SodiumException('Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MAX');
-        }
-
-        /** @var int $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-        $ctx = ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outputLength);
-        while ($size > 0) {
-            $blockSize = $size > 64
-                ? 64
-                : $size;
-            $read = fread($fp, $blockSize);
-            if (!is_string($read)) {
-                throw new SodiumException('Could not read input file');
-            }
-            ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $read);
-            $size -= $blockSize;
-        }
-
-        fclose($fp);
-        return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
-    }
-
-    /**
-     * Encrypt a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_secretbox(), but produces
-     * the same result.
-     *
-     * @param string $inputFile  Absolute path to a file on the filesystem
-     * @param string $outputFile Absolute path to a file on the filesystem
-     * @param string $nonce      Number to be used only once
-     * @param string $key        Encryption key
-     *
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function secretbox($inputFile, $outputFile, $nonce, $key)
-    {
-        /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given..');
-        }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
-        }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_SECRETBOX_NONCEBYTES bytes');
-        }
-        if (!is_string($key)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($key) . ' given.');
-        }
-        if (self::strlen($key) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_SECRETBOX_KEYBYTES bytes');
-        }
-
-        /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
-        }
-
-        $res = self::secretbox_encrypt($ifp, $ofp, $size, $nonce, $key);
-        fclose($ifp);
-        fclose($ofp);
-        return $res;
-    }
-    /**
-     * Seal a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_secretbox_open(), but produces
-     * the same result.
-     *
-     * Warning: Does not protect against TOCTOU attacks. You should
-     * just load the file into memory and use crypto_secretbox_open() if
-     * you are worried about those.
-     *
-     * @param string $inputFile
-     * @param string $outputFile
-     * @param string $nonce
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function secretbox_open($inputFile, $outputFile, $nonce, $key)
-    {
-        /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
-        }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
-        }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
-        }
-        if (!is_string($key)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($key) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_SECRETBOX_NONCEBYTES bytes');
-        }
-        if (self::strlen($key) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_SECRETBOXBOX_KEYBYTES bytes');
-        }
-
-        /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
-        }
-
-        $res = self::secretbox_decrypt($ifp, $ofp, $size, $nonce, $key);
-        fclose($ifp);
-        fclose($ofp);
-        try {
-            ParagonIE_Sodium_Compat::memzero($key);
-        } catch (SodiumException $ex) {
-            /** @psalm-suppress PossiblyUndefinedVariable */
-            unset($key);
-        }
-        return $res;
-    }
-
-    /**
-     * Sign a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_sign_detached(), but produces
-     * the same result.
-     *
-     * @param string $filePath  Absolute path to a file on the filesystem
-     * @param string $secretKey Secret signing key
-     *
-     * @return string           Ed25519 signature
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function sign($filePath, $secretKey)
-    {
-        /* Type checks: */
-        if (!is_string($filePath)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
-        }
-        if (!is_string($secretKey)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($secretKey) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($secretKey) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_SECRETKEYBYTES) {
-            throw new TypeError('Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES bytes');
-        }
-        if (PHP_INT_SIZE === 4) {
-            return self::sign_core32($filePath, $secretKey);
-        }
-
-        /** @var int $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var string $az */
-        $az = hash('sha512', self::substr($secretKey, 0, 32), true);
-
-        $az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
-        $az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
-
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($az, 32, 32));
-        /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
-
-        /** @var string $nonceHash */
-        $nonceHash = hash_final($hs, true);
-
-        /** @var string $pk */
-        $pk = self::substr($secretKey, 32, 32);
-
-        /** @var string $nonce */
-        $nonce = ParagonIE_Sodium_Core_Ed25519::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
-
-        /** @var string $sig */
-        $sig = ParagonIE_Sodium_Core_Ed25519::ge_p3_tobytes(
-            ParagonIE_Sodium_Core_Ed25519::ge_scalarmult_base($nonce)
-        );
-
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($pk, 0, 32));
-        /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
-
-        /** @var string $hramHash */
-        $hramHash = hash_final($hs, true);
-
-        /** @var string $hram */
-        $hram = ParagonIE_Sodium_Core_Ed25519::sc_reduce($hramHash);
-
-        /** @var string $sigAfter */
-        $sigAfter = ParagonIE_Sodium_Core_Ed25519::sc_muladd($hram, $az, $nonce);
-
-        /** @var string $sig */
-        $sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
-
-        try {
-            ParagonIE_Sodium_Compat::memzero($az);
-        } catch (SodiumException $ex) {
-            $az = null;
-        }
-        fclose($fp);
-        return $sig;
-    }
-
-    /**
-     * Verify a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_sign_verify_detached(), but
-     * produces the same result.
-     *
-     * @param string $sig       Ed25519 signature
-     * @param string $filePath  Absolute path to a file on the filesystem
-     * @param string $publicKey Signing public key
-     *
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     * @throws Exception
-     */
-    public static function verify($sig, $filePath, $publicKey)
-    {
-        /* Type checks: */
-        if (!is_string($sig)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($sig) . ' given.');
-        }
-        if (!is_string($filePath)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($filePath) . ' given.');
-        }
-        if (!is_string($publicKey)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($publicKey) . ' given.');
-        }
-
-        /* Input validation: */
-        if (self::strlen($sig) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_BYTES) {
-            throw new TypeError('Argument 1 must be CRYPTO_SIGN_BYTES bytes');
-        }
-        if (self::strlen($publicKey) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_PUBLICKEYBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_SIGN_PUBLICKEYBYTES bytes');
-        }
-        if (self::strlen($sig) < 64) {
-            throw new SodiumException('Signature is too short');
-        }
-
-        if (PHP_INT_SIZE === 4) {
-            return self::verify_core32($sig, $filePath, $publicKey);
-        }
-
-        /* Security checks */
-        if (
-            (ParagonIE_Sodium_Core_Ed25519::chrToInt($sig[63]) & 240)
-                &&
-            ParagonIE_Sodium_Core_Ed25519::check_S_lt_L(self::substr($sig, 32, 32))
-        ) {
-            throw new SodiumException('S < L - Invalid signature');
-        }
-        if (ParagonIE_Sodium_Core_Ed25519::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');
-        }
-        $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= self::chrToInt($publicKey[$i]);
-        }
-        if ($d === 0) {
-            throw new SodiumException('All zero public key');
-        }
-
-        /** @var int $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-
-        /** @var resource $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-
-        /** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
-        $orig = ParagonIE_Sodium_Compat::$fastMult;
-
-        // Set ParagonIE_Sodium_Compat::$fastMult to true to speed up verification.
-        ParagonIE_Sodium_Compat::$fastMult = true;
-
-        /** @var ParagonIE_Sodium_Core_Curve25519_Ge_P3 $A */
-        $A = ParagonIE_Sodium_Core_Ed25519::ge_frombytes_negate_vartime($publicKey);
-
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($publicKey, 0, 32));
-        /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
-        /** @var string $hDigest */
-        $hDigest = hash_final($hs, true);
-
-        /** @var string $h */
-        $h = ParagonIE_Sodium_Core_Ed25519::sc_reduce($hDigest) . self::substr($hDigest, 32);
-
-        /** @var ParagonIE_Sodium_Core_Curve25519_Ge_P2 $R */
-        $R = ParagonIE_Sodium_Core_Ed25519::ge_double_scalarmult_vartime(
-            $h,
-            $A,
-            self::substr($sig, 32)
-        );
-
-        /** @var string $rcheck */
-        $rcheck = ParagonIE_Sodium_Core_Ed25519::ge_tobytes($R);
-
-        // Close the file handle
-        fclose($fp);
-
-        // 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));
-    }
-
-    /**
-     * @param resource $ifp
-     * @param resource $ofp
-     * @param int      $mlen
-     * @param string   $nonce
-     * @param string   $boxKeypair
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function box_encrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
-    {
-        if (PHP_INT_SIZE === 4) {
-            return self::secretbox_encrypt(
-                $ifp,
-                $ofp,
-                $mlen,
-                $nonce,
-                ParagonIE_Sodium_Crypto32::box_beforenm(
-                    ParagonIE_Sodium_Crypto32::box_secretkey($boxKeypair),
-                    ParagonIE_Sodium_Crypto32::box_publickey($boxKeypair)
-                )
-            );
-        }
-        return self::secretbox_encrypt(
-            $ifp,
-            $ofp,
-            $mlen,
-            $nonce,
-            ParagonIE_Sodium_Crypto::box_beforenm(
-                ParagonIE_Sodium_Crypto::box_secretkey($boxKeypair),
-                ParagonIE_Sodium_Crypto::box_publickey($boxKeypair)
-            )
-        );
-    }
-
-
-    /**
-     * @param resource $ifp
-     * @param resource $ofp
-     * @param int      $mlen
-     * @param string   $nonce
-     * @param string   $boxKeypair
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function box_decrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
-    {
-        if (PHP_INT_SIZE === 4) {
-            return self::secretbox_decrypt(
-                $ifp,
-                $ofp,
-                $mlen,
-                $nonce,
-                ParagonIE_Sodium_Crypto32::box_beforenm(
-                    ParagonIE_Sodium_Crypto32::box_secretkey($boxKeypair),
-                    ParagonIE_Sodium_Crypto32::box_publickey($boxKeypair)
-                )
-            );
-        }
-        return self::secretbox_decrypt(
-            $ifp,
-            $ofp,
-            $mlen,
-            $nonce,
-            ParagonIE_Sodium_Crypto::box_beforenm(
-                ParagonIE_Sodium_Crypto::box_secretkey($boxKeypair),
-                ParagonIE_Sodium_Crypto::box_publickey($boxKeypair)
-            )
-        );
-    }
-
-    /**
-     * Encrypt a file
-     *
-     * @param resource $ifp
-     * @param resource $ofp
-     * @param int $mlen
-     * @param string $nonce
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function secretbox_encrypt($ifp, $ofp, $mlen, $nonce, $key)
-    {
-        if (PHP_INT_SIZE === 4) {
-            return self::secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
-        }
-
-        $plaintext = fread($ifp, 32);
-        if (!is_string($plaintext)) {
-            throw new SodiumException('Could not read input file');
-        }
-        $first32 = self::ftell($ifp);
-
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
-
-        /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
-
-        /** @var string $block0 */
-        $block0 = str_repeat("\x00", 32);
-
-        /** @var int $mlen - Length of the plaintext message */
-        $mlen0 = $mlen;
-        if ($mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES) {
-            $mlen0 = 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES;
-        }
-        $block0 .= ParagonIE_Sodium_Core_Util::substr($plaintext, 0, $mlen0);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20_xor(
-            $block0,
-            $realNonce,
-            $subkey
-        );
-
-        $state = new ParagonIE_Sodium_Core_Poly1305_State(
-            ParagonIE_Sodium_Core_Util::substr(
-                $block0,
-                0,
-                ParagonIE_Sodium_Crypto::onetimeauth_poly1305_KEYBYTES
-            )
-        );
-
-        // Pre-write 16 blank bytes for the Poly1305 tag
-        $start = self::ftell($ofp);
-        fwrite($ofp, str_repeat("\x00", 16));
-
-        /** @var string $c */
-        $cBlock = ParagonIE_Sodium_Core_Util::substr(
-            $block0,
-            ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES
-        );
-        $state->update($cBlock);
-        fwrite($ofp, $cBlock);
-        $mlen -= 32;
-
-        /** @var int $iter */
-        $iter = 1;
-
-        /** @var int $incr */
-        $incr = self::BUFFER_SIZE >> 6;
-
-        /*
+	/* PHP's default buffer size is 8192 for fread()/fwrite(). */
+	const BUFFER_SIZE = 8192;
+
+	/**
+	 * Box a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_box(), but produces
+	 * the same result.
+	 *
+	 * @param string $inputFile  Absolute path to a file on the filesystem
+	 * @param string $outputFile Absolute path to a file on the filesystem
+	 * @param string $nonce      Number to be used only once
+	 * @param string $keyPair    ECDH secret key and ECDH public key concatenated
+	 *
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box($inputFile, $outputFile, $nonce, $keyPair)
+	{
+		/* Type checks: */
+		if (!is_string($inputFile)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+		}
+		if (!is_string($outputFile)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+		}
+		if (!is_string($nonce)) {
+			throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+		}
+
+		/* Input validation: */
+		if (!is_string($keyPair)) {
+			throw new TypeError('Argument 4 must be a string, ' . gettype($keyPair) . ' given.');
+		}
+		if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES) {
+			throw new TypeError('Argument 3 must be CRYPTO_BOX_NONCEBYTES bytes');
+		}
+		if (self::strlen($keyPair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
+			throw new TypeError('Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
+		}
+
+		/** @var int $size */
+		$size = filesize($inputFile);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $ifp */
+		$ifp = fopen($inputFile, 'rb');
+		if (!is_resource($ifp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var resource $ofp */
+		$ofp = fopen($outputFile, 'wb');
+		if (!is_resource($ofp)) {
+			fclose($ifp);
+			throw new SodiumException('Could not open output file for writing');
+		}
+
+		$res = self::box_encrypt($ifp, $ofp, $size, $nonce, $keyPair);
+		fclose($ifp);
+		fclose($ofp);
+		return $res;
+	}
+
+	/**
+	 * Open a boxed file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_box_open(), but produces
+	 * the same result.
+	 *
+	 * Warning: Does not protect against TOCTOU attacks. You should
+	 * just load the file into memory and use crypto_box_open() if
+	 * you are worried about those.
+	 *
+	 * @param string $inputFile
+	 * @param string $outputFile
+	 * @param string $nonce
+	 * @param string $keypair
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_open($inputFile, $outputFile, $nonce, $keypair)
+	{
+		/* Type checks: */
+		if (!is_string($inputFile)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+		}
+		if (!is_string($outputFile)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+		}
+		if (!is_string($nonce)) {
+			throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+		}
+		if (!is_string($keypair)) {
+			throw new TypeError('Argument 4 must be a string, ' . gettype($keypair) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES) {
+			throw new TypeError('Argument 4 must be CRYPTO_BOX_NONCEBYTES bytes');
+		}
+		if (self::strlen($keypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
+			throw new TypeError('Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
+		}
+
+		/** @var int $size */
+		$size = filesize($inputFile);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $ifp */
+		$ifp = fopen($inputFile, 'rb');
+		if (!is_resource($ifp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var resource $ofp */
+		$ofp = fopen($outputFile, 'wb');
+		if (!is_resource($ofp)) {
+			fclose($ifp);
+			throw new SodiumException('Could not open output file for writing');
+		}
+
+		$res = self::box_decrypt($ifp, $ofp, $size, $nonce, $keypair);
+		fclose($ifp);
+		fclose($ofp);
+		try {
+			ParagonIE_Sodium_Compat::memzero($nonce);
+			ParagonIE_Sodium_Compat::memzero($ephKeypair);
+		} catch (SodiumException $ex) {
+			if (isset($ephKeypair)) {
+				unset($ephKeypair);
+			}
+		}
+		return $res;
+	}
+
+	/**
+	 * Seal a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_box_seal(), but produces
+	 * the same result.
+	 *
+	 * @param string $inputFile  Absolute path to a file on the filesystem
+	 * @param string $outputFile Absolute path to a file on the filesystem
+	 * @param string $publicKey  ECDH public key
+	 *
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_seal($inputFile, $outputFile, $publicKey)
+	{
+		/* Type checks: */
+		if (!is_string($inputFile)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+		}
+		if (!is_string($outputFile)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+		}
+		if (!is_string($publicKey)) {
+			throw new TypeError('Argument 3 must be a string, ' . gettype($publicKey) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($publicKey) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
+			throw new TypeError('Argument 3 must be CRYPTO_BOX_PUBLICKEYBYTES bytes');
+		}
+
+		/** @var int $size */
+		$size = filesize($inputFile);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $ifp */
+		$ifp = fopen($inputFile, 'rb');
+		if (!is_resource($ifp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var resource $ofp */
+		$ofp = fopen($outputFile, 'wb');
+		if (!is_resource($ofp)) {
+			fclose($ifp);
+			throw new SodiumException('Could not open output file for writing');
+		}
+
+		/** @var string $ephKeypair */
+		$ephKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair();
+
+		/** @var string $msgKeypair */
+		$msgKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey(
+			ParagonIE_Sodium_Compat::crypto_box_secretkey($ephKeypair),
+			$publicKey
+		);
+
+		/** @var string $ephemeralPK */
+		$ephemeralPK = ParagonIE_Sodium_Compat::crypto_box_publickey($ephKeypair);
+
+		/** @var string $nonce */
+		$nonce = ParagonIE_Sodium_Compat::crypto_generichash(
+			$ephemeralPK . $publicKey,
+			'',
+			24
+		);
+
+		/** @var int $firstWrite */
+		$firstWrite = fwrite(
+			$ofp,
+			$ephemeralPK,
+			ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES
+		);
+		if (!is_int($firstWrite)) {
+			fclose($ifp);
+			fclose($ofp);
+			ParagonIE_Sodium_Compat::memzero($ephKeypair);
+			throw new SodiumException('Could not write to output file');
+		}
+		if ($firstWrite !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
+			ParagonIE_Sodium_Compat::memzero($ephKeypair);
+			fclose($ifp);
+			fclose($ofp);
+			throw new SodiumException('Error writing public key to output file');
+		}
+
+		$res = self::box_encrypt($ifp, $ofp, $size, $nonce, $msgKeypair);
+		fclose($ifp);
+		fclose($ofp);
+		try {
+			ParagonIE_Sodium_Compat::memzero($nonce);
+			ParagonIE_Sodium_Compat::memzero($ephKeypair);
+		} catch (SodiumException $ex) {
+			/** @psalm-suppress PossiblyUndefinedVariable */
+			unset($ephKeypair);
+		}
+		return $res;
+	}
+
+	/**
+	 * Open a sealed file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_box_seal_open(), but produces
+	 * the same result.
+	 *
+	 * Warning: Does not protect against TOCTOU attacks. You should
+	 * just load the file into memory and use crypto_box_seal_open() if
+	 * you are worried about those.
+	 *
+	 * @param string $inputFile
+	 * @param string $outputFile
+	 * @param string $ecdhKeypair
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function box_seal_open($inputFile, $outputFile, $ecdhKeypair)
+	{
+		/* Type checks: */
+		if (!is_string($inputFile)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+		}
+		if (!is_string($outputFile)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+		}
+		if (!is_string($ecdhKeypair)) {
+			throw new TypeError('Argument 3 must be a string, ' . gettype($ecdhKeypair) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($ecdhKeypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
+			throw new TypeError('Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
+		}
+
+		$publicKey = ParagonIE_Sodium_Compat::crypto_box_publickey($ecdhKeypair);
+
+		/** @var int $size */
+		$size = filesize($inputFile);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $ifp */
+		$ifp = fopen($inputFile, 'rb');
+		if (!is_resource($ifp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var resource $ofp */
+		$ofp = fopen($outputFile, 'wb');
+		if (!is_resource($ofp)) {
+			fclose($ifp);
+			throw new SodiumException('Could not open output file for writing');
+		}
+
+		$ephemeralPK = fread($ifp, ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES);
+		if (!is_string($ephemeralPK)) {
+			throw new SodiumException('Could not read input file');
+		}
+		if (self::strlen($ephemeralPK) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
+			fclose($ifp);
+			fclose($ofp);
+			throw new SodiumException('Could not read public key from sealed file');
+		}
+
+		$nonce = ParagonIE_Sodium_Compat::crypto_generichash(
+			$ephemeralPK . $publicKey,
+			'',
+			24
+		);
+		$msgKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey(
+			ParagonIE_Sodium_Compat::crypto_box_secretkey($ecdhKeypair),
+			$ephemeralPK
+		);
+
+		$res = self::box_decrypt($ifp, $ofp, $size, $nonce, $msgKeypair);
+		fclose($ifp);
+		fclose($ofp);
+		try {
+			ParagonIE_Sodium_Compat::memzero($nonce);
+			ParagonIE_Sodium_Compat::memzero($ephKeypair);
+		} catch (SodiumException $ex) {
+			if (isset($ephKeypair)) {
+				unset($ephKeypair);
+			}
+		}
+		return $res;
+	}
+
+	/**
+	 * Calculate the BLAKE2b hash of a file.
+	 *
+	 * @param string      $filePath     Absolute path to a file on the filesystem
+	 * @param string|null $key          BLAKE2b key
+	 * @param int         $outputLength Length of hash output
+	 *
+	 * @return string                   BLAKE2b hash
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress FailedTypeResolution
+	 */
+	public static function generichash($filePath, $key = '', $outputLength = 32)
+	{
+		/* Type checks: */
+		if (!is_string($filePath)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
+		}
+		if (!is_string($key)) {
+			if (is_null($key)) {
+				$key = '';
+			} else {
+				throw new TypeError('Argument 2 must be a string, ' . gettype($key) . ' given.');
+			}
+		}
+		if (!is_int($outputLength)) {
+			if (!is_numeric($outputLength)) {
+				throw new TypeError('Argument 3 must be an integer, ' . gettype($outputLength) . ' given.');
+			}
+			$outputLength = (int) $outputLength;
+		}
+
+		/* Input validation: */
+		if (!empty($key)) {
+			if (self::strlen($key) < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MIN) {
+				throw new TypeError('Argument 2 must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes');
+			}
+			if (self::strlen($key) > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MAX) {
+				throw new TypeError('Argument 2 must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes');
+			}
+		}
+		if ($outputLength < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MIN) {
+			throw new SodiumException('Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MIN');
+		}
+		if ($outputLength > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MAX) {
+			throw new SodiumException('Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MAX');
+		}
+
+		/** @var int $size */
+		$size = filesize($filePath);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $fp */
+		$fp = fopen($filePath, 'rb');
+		if (!is_resource($fp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+		$ctx = ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outputLength);
+		while ($size > 0) {
+			$blockSize = $size > 64
+				? 64
+				: $size;
+			$read = fread($fp, $blockSize);
+			if (!is_string($read)) {
+				throw new SodiumException('Could not read input file');
+			}
+			ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $read);
+			$size -= $blockSize;
+		}
+
+		fclose($fp);
+		return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
+	}
+
+	/**
+	 * Encrypt a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_secretbox(), but produces
+	 * the same result.
+	 *
+	 * @param string $inputFile  Absolute path to a file on the filesystem
+	 * @param string $outputFile Absolute path to a file on the filesystem
+	 * @param string $nonce      Number to be used only once
+	 * @param string $key        Encryption key
+	 *
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function secretbox($inputFile, $outputFile, $nonce, $key)
+	{
+		/* Type checks: */
+		if (!is_string($inputFile)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given..');
+		}
+		if (!is_string($outputFile)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+		}
+		if (!is_string($nonce)) {
+			throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES) {
+			throw new TypeError('Argument 3 must be CRYPTO_SECRETBOX_NONCEBYTES bytes');
+		}
+		if (!is_string($key)) {
+			throw new TypeError('Argument 4 must be a string, ' . gettype($key) . ' given.');
+		}
+		if (self::strlen($key) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES) {
+			throw new TypeError('Argument 4 must be CRYPTO_SECRETBOX_KEYBYTES bytes');
+		}
+
+		/** @var int $size */
+		$size = filesize($inputFile);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $ifp */
+		$ifp = fopen($inputFile, 'rb');
+		if (!is_resource($ifp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var resource $ofp */
+		$ofp = fopen($outputFile, 'wb');
+		if (!is_resource($ofp)) {
+			fclose($ifp);
+			throw new SodiumException('Could not open output file for writing');
+		}
+
+		$res = self::secretbox_encrypt($ifp, $ofp, $size, $nonce, $key);
+		fclose($ifp);
+		fclose($ofp);
+		return $res;
+	}
+	/**
+	 * Seal a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_secretbox_open(), but produces
+	 * the same result.
+	 *
+	 * Warning: Does not protect against TOCTOU attacks. You should
+	 * just load the file into memory and use crypto_secretbox_open() if
+	 * you are worried about those.
+	 *
+	 * @param string $inputFile
+	 * @param string $outputFile
+	 * @param string $nonce
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function secretbox_open($inputFile, $outputFile, $nonce, $key)
+	{
+		/* Type checks: */
+		if (!is_string($inputFile)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+		}
+		if (!is_string($outputFile)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+		}
+		if (!is_string($nonce)) {
+			throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+		}
+		if (!is_string($key)) {
+			throw new TypeError('Argument 4 must be a string, ' . gettype($key) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES) {
+			throw new TypeError('Argument 4 must be CRYPTO_SECRETBOX_NONCEBYTES bytes');
+		}
+		if (self::strlen($key) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES) {
+			throw new TypeError('Argument 4 must be CRYPTO_SECRETBOXBOX_KEYBYTES bytes');
+		}
+
+		/** @var int $size */
+		$size = filesize($inputFile);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $ifp */
+		$ifp = fopen($inputFile, 'rb');
+		if (!is_resource($ifp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var resource $ofp */
+		$ofp = fopen($outputFile, 'wb');
+		if (!is_resource($ofp)) {
+			fclose($ifp);
+			throw new SodiumException('Could not open output file for writing');
+		}
+
+		$res = self::secretbox_decrypt($ifp, $ofp, $size, $nonce, $key);
+		fclose($ifp);
+		fclose($ofp);
+		try {
+			ParagonIE_Sodium_Compat::memzero($key);
+		} catch (SodiumException $ex) {
+			/** @psalm-suppress PossiblyUndefinedVariable */
+			unset($key);
+		}
+		return $res;
+	}
+
+	/**
+	 * Sign a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_sign_detached(), but produces
+	 * the same result.
+	 *
+	 * @param string $filePath  Absolute path to a file on the filesystem
+	 * @param string $secretKey Secret signing key
+	 *
+	 * @return string           Ed25519 signature
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function sign($filePath, $secretKey)
+	{
+		/* Type checks: */
+		if (!is_string($filePath)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
+		}
+		if (!is_string($secretKey)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($secretKey) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($secretKey) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_SECRETKEYBYTES) {
+			throw new TypeError('Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES bytes');
+		}
+		if (PHP_INT_SIZE === 4) {
+			return self::sign_core32($filePath, $secretKey);
+		}
+
+		/** @var int $size */
+		$size = filesize($filePath);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $fp */
+		$fp = fopen($filePath, 'rb');
+		if (!is_resource($fp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var string $az */
+		$az = hash('sha512', self::substr($secretKey, 0, 32), true);
+
+		$az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
+		$az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
+
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($az, 32, 32));
+		/** @var resource $hs */
+		$hs = self::updateHashWithFile($hs, $fp, $size);
+
+		/** @var string $nonceHash */
+		$nonceHash = hash_final($hs, true);
+
+		/** @var string $pk */
+		$pk = self::substr($secretKey, 32, 32);
+
+		/** @var string $nonce */
+		$nonce = ParagonIE_Sodium_Core_Ed25519::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
+
+		/** @var string $sig */
+		$sig = ParagonIE_Sodium_Core_Ed25519::ge_p3_tobytes(
+			ParagonIE_Sodium_Core_Ed25519::ge_scalarmult_base($nonce)
+		);
+
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($sig, 0, 32));
+		self::hash_update($hs, self::substr($pk, 0, 32));
+		/** @var resource $hs */
+		$hs = self::updateHashWithFile($hs, $fp, $size);
+
+		/** @var string $hramHash */
+		$hramHash = hash_final($hs, true);
+
+		/** @var string $hram */
+		$hram = ParagonIE_Sodium_Core_Ed25519::sc_reduce($hramHash);
+
+		/** @var string $sigAfter */
+		$sigAfter = ParagonIE_Sodium_Core_Ed25519::sc_muladd($hram, $az, $nonce);
+
+		/** @var string $sig */
+		$sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
+
+		try {
+			ParagonIE_Sodium_Compat::memzero($az);
+		} catch (SodiumException $ex) {
+			$az = null;
+		}
+		fclose($fp);
+		return $sig;
+	}
+
+	/**
+	 * Verify a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_sign_verify_detached(), but
+	 * produces the same result.
+	 *
+	 * @param string $sig       Ed25519 signature
+	 * @param string $filePath  Absolute path to a file on the filesystem
+	 * @param string $publicKey Signing public key
+	 *
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @throws Exception
+	 */
+	public static function verify($sig, $filePath, $publicKey)
+	{
+		/* Type checks: */
+		if (!is_string($sig)) {
+			throw new TypeError('Argument 1 must be a string, ' . gettype($sig) . ' given.');
+		}
+		if (!is_string($filePath)) {
+			throw new TypeError('Argument 2 must be a string, ' . gettype($filePath) . ' given.');
+		}
+		if (!is_string($publicKey)) {
+			throw new TypeError('Argument 3 must be a string, ' . gettype($publicKey) . ' given.');
+		}
+
+		/* Input validation: */
+		if (self::strlen($sig) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_BYTES) {
+			throw new TypeError('Argument 1 must be CRYPTO_SIGN_BYTES bytes');
+		}
+		if (self::strlen($publicKey) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_PUBLICKEYBYTES) {
+			throw new TypeError('Argument 3 must be CRYPTO_SIGN_PUBLICKEYBYTES bytes');
+		}
+		if (self::strlen($sig) < 64) {
+			throw new SodiumException('Signature is too short');
+		}
+
+		if (PHP_INT_SIZE === 4) {
+			return self::verify_core32($sig, $filePath, $publicKey);
+		}
+
+		/* Security checks */
+		if (
+			(ParagonIE_Sodium_Core_Ed25519::chrToInt($sig[63]) & 240)
+				&&
+			ParagonIE_Sodium_Core_Ed25519::check_S_lt_L(self::substr($sig, 32, 32))
+		) {
+			throw new SodiumException('S < L - Invalid signature');
+		}
+		if (ParagonIE_Sodium_Core_Ed25519::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');
+		}
+		$d = 0;
+		for ($i = 0; $i < 32; ++$i) {
+			$d |= self::chrToInt($publicKey[$i]);
+		}
+		if ($d === 0) {
+			throw new SodiumException('All zero public key');
+		}
+
+		/** @var int $size */
+		$size = filesize($filePath);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+
+		/** @var resource $fp */
+		$fp = fopen($filePath, 'rb');
+		if (!is_resource($fp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+
+		/** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
+		$orig = ParagonIE_Sodium_Compat::$fastMult;
+
+		// Set ParagonIE_Sodium_Compat::$fastMult to true to speed up verification.
+		ParagonIE_Sodium_Compat::$fastMult = true;
+
+		/** @var ParagonIE_Sodium_Core_Curve25519_Ge_P3 $A */
+		$A = ParagonIE_Sodium_Core_Ed25519::ge_frombytes_negate_vartime($publicKey);
+
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($sig, 0, 32));
+		self::hash_update($hs, self::substr($publicKey, 0, 32));
+		/** @var resource $hs */
+		$hs = self::updateHashWithFile($hs, $fp, $size);
+		/** @var string $hDigest */
+		$hDigest = hash_final($hs, true);
+
+		/** @var string $h */
+		$h = ParagonIE_Sodium_Core_Ed25519::sc_reduce($hDigest) . self::substr($hDigest, 32);
+
+		/** @var ParagonIE_Sodium_Core_Curve25519_Ge_P2 $R */
+		$R = ParagonIE_Sodium_Core_Ed25519::ge_double_scalarmult_vartime(
+			$h,
+			$A,
+			self::substr($sig, 32)
+		);
+
+		/** @var string $rcheck */
+		$rcheck = ParagonIE_Sodium_Core_Ed25519::ge_tobytes($R);
+
+		// Close the file handle
+		fclose($fp);
+
+		// 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));
+	}
+
+	/**
+	 * @param resource $ifp
+	 * @param resource $ofp
+	 * @param int      $mlen
+	 * @param string   $nonce
+	 * @param string   $boxKeypair
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function box_encrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
+	{
+		if (PHP_INT_SIZE === 4) {
+			return self::secretbox_encrypt(
+				$ifp,
+				$ofp,
+				$mlen,
+				$nonce,
+				ParagonIE_Sodium_Crypto32::box_beforenm(
+					ParagonIE_Sodium_Crypto32::box_secretkey($boxKeypair),
+					ParagonIE_Sodium_Crypto32::box_publickey($boxKeypair)
+				)
+			);
+		}
+		return self::secretbox_encrypt(
+			$ifp,
+			$ofp,
+			$mlen,
+			$nonce,
+			ParagonIE_Sodium_Crypto::box_beforenm(
+				ParagonIE_Sodium_Crypto::box_secretkey($boxKeypair),
+				ParagonIE_Sodium_Crypto::box_publickey($boxKeypair)
+			)
+		);
+	}
+
+
+	/**
+	 * @param resource $ifp
+	 * @param resource $ofp
+	 * @param int      $mlen
+	 * @param string   $nonce
+	 * @param string   $boxKeypair
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function box_decrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
+	{
+		if (PHP_INT_SIZE === 4) {
+			return self::secretbox_decrypt(
+				$ifp,
+				$ofp,
+				$mlen,
+				$nonce,
+				ParagonIE_Sodium_Crypto32::box_beforenm(
+					ParagonIE_Sodium_Crypto32::box_secretkey($boxKeypair),
+					ParagonIE_Sodium_Crypto32::box_publickey($boxKeypair)
+				)
+			);
+		}
+		return self::secretbox_decrypt(
+			$ifp,
+			$ofp,
+			$mlen,
+			$nonce,
+			ParagonIE_Sodium_Crypto::box_beforenm(
+				ParagonIE_Sodium_Crypto::box_secretkey($boxKeypair),
+				ParagonIE_Sodium_Crypto::box_publickey($boxKeypair)
+			)
+		);
+	}
+
+	/**
+	 * Encrypt a file
+	 *
+	 * @param resource $ifp
+	 * @param resource $ofp
+	 * @param int $mlen
+	 * @param string $nonce
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function secretbox_encrypt($ifp, $ofp, $mlen, $nonce, $key)
+	{
+		if (PHP_INT_SIZE === 4) {
+			return self::secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
+		}
+
+		$plaintext = fread($ifp, 32);
+		if (!is_string($plaintext)) {
+			throw new SodiumException('Could not read input file');
+		}
+		$first32 = self::ftell($ifp);
+
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
+
+		/** @var string $realNonce */
+		$realNonce = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+
+		/** @var string $block0 */
+		$block0 = str_repeat("\x00", 32);
+
+		/** @var int $mlen - Length of the plaintext message */
+		$mlen0 = $mlen;
+		if ($mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES) {
+			$mlen0 = 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES;
+		}
+		$block0 .= ParagonIE_Sodium_Core_Util::substr($plaintext, 0, $mlen0);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core_Salsa20::salsa20_xor(
+			$block0,
+			$realNonce,
+			$subkey
+		);
+
+		$state = new ParagonIE_Sodium_Core_Poly1305_State(
+			ParagonIE_Sodium_Core_Util::substr(
+				$block0,
+				0,
+				ParagonIE_Sodium_Crypto::onetimeauth_poly1305_KEYBYTES
+			)
+		);
+
+		// Pre-write 16 blank bytes for the Poly1305 tag
+		$start = self::ftell($ofp);
+		fwrite($ofp, str_repeat("\x00", 16));
+
+		/** @var string $c */
+		$cBlock = ParagonIE_Sodium_Core_Util::substr(
+			$block0,
+			ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES
+		);
+		$state->update($cBlock);
+		fwrite($ofp, $cBlock);
+		$mlen -= 32;
+
+		/** @var int $iter */
+		$iter = 1;
+
+		/** @var int $incr */
+		$incr = self::BUFFER_SIZE >> 6;
+
+		/*
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        fseek($ifp, $first32, SEEK_SET);
-
-        while ($mlen > 0) {
-            $blockSize = $mlen > self::BUFFER_SIZE
-                ? self::BUFFER_SIZE
-                : $mlen;
-            $plaintext = fread($ifp, $blockSize);
-            if (!is_string($plaintext)) {
-                throw new SodiumException('Could not read input file');
-            }
-            $cBlock = ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
-                $plaintext,
-                $realNonce,
-                $iter,
-                $subkey
-            );
-            fwrite($ofp, $cBlock, $blockSize);
-            $state->update($cBlock);
-
-            $mlen -= $blockSize;
-            $iter += $incr;
-        }
-        try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-            ParagonIE_Sodium_Compat::memzero($subkey);
-        } catch (SodiumException $ex) {
-            $block0 = null;
-            $subkey = null;
-        }
-        $end = self::ftell($ofp);
-
-        /*
+		fseek($ifp, $first32, SEEK_SET);
+
+		while ($mlen > 0) {
+			$blockSize = $mlen > self::BUFFER_SIZE
+				? self::BUFFER_SIZE
+				: $mlen;
+			$plaintext = fread($ifp, $blockSize);
+			if (!is_string($plaintext)) {
+				throw new SodiumException('Could not read input file');
+			}
+			$cBlock = ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
+				$plaintext,
+				$realNonce,
+				$iter,
+				$subkey
+			);
+			fwrite($ofp, $cBlock, $blockSize);
+			$state->update($cBlock);
+
+			$mlen -= $blockSize;
+			$iter += $incr;
+		}
+		try {
+			ParagonIE_Sodium_Compat::memzero($block0);
+			ParagonIE_Sodium_Compat::memzero($subkey);
+		} catch (SodiumException $ex) {
+			$block0 = null;
+			$subkey = null;
+		}
+		$end = self::ftell($ofp);
+
+		/*
          * Write the Poly1305 authentication tag that provides integrity
          * over the ciphertext (encrypt-then-MAC)
          */
-        fseek($ofp, $start, SEEK_SET);
-        fwrite($ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES);
-        fseek($ofp, $end, SEEK_SET);
-        unset($state);
-
-        return true;
-    }
-
-    /**
-     * Decrypt a file
-     *
-     * @param resource $ifp
-     * @param resource $ofp
-     * @param int $mlen
-     * @param string $nonce
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function secretbox_decrypt($ifp, $ofp, $mlen, $nonce, $key)
-    {
-        if (PHP_INT_SIZE === 4) {
-            return self::secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
-        }
-        $tag = fread($ifp, 16);
-        if (!is_string($tag)) {
-            throw new SodiumException('Could not read input file');
-        }
-
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
-
-        /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20(
-            64,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
-            $subkey
-        );
-
-        /* Verify the Poly1305 MAC -before- attempting to decrypt! */
-        $state = new ParagonIE_Sodium_Core_Poly1305_State(self::substr($block0, 0, 32));
-        if (!self::onetimeauth_verify($state, $ifp, $tag, $mlen)) {
-            throw new SodiumException('Invalid MAC');
-        }
-
-        /*
+		fseek($ofp, $start, SEEK_SET);
+		fwrite($ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES);
+		fseek($ofp, $end, SEEK_SET);
+		unset($state);
+
+		return true;
+	}
+
+	/**
+	 * Decrypt a file
+	 *
+	 * @param resource $ifp
+	 * @param resource $ofp
+	 * @param int $mlen
+	 * @param string $nonce
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function secretbox_decrypt($ifp, $ofp, $mlen, $nonce, $key)
+	{
+		if (PHP_INT_SIZE === 4) {
+			return self::secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
+		}
+		$tag = fread($ifp, 16);
+		if (!is_string($tag)) {
+			throw new SodiumException('Could not read input file');
+		}
+
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
+
+		/** @var string $realNonce */
+		$realNonce = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core_Salsa20::salsa20(
+			64,
+			ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+			$subkey
+		);
+
+		/* Verify the Poly1305 MAC -before- attempting to decrypt! */
+		$state = new ParagonIE_Sodium_Core_Poly1305_State(self::substr($block0, 0, 32));
+		if (!self::onetimeauth_verify($state, $ifp, $tag, $mlen)) {
+			throw new SodiumException('Invalid MAC');
+		}
+
+		/*
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        $first32 = fread($ifp, 32);
-        if (!is_string($first32)) {
-            throw new SodiumException('Could not read input file');
-        }
-        $first32len = self::strlen($first32);
-        fwrite(
-            $ofp,
-            self::xorStrings(
-                self::substr($block0, 32, $first32len),
-                self::substr($first32, 0, $first32len)
-            )
-        );
-        $mlen -= 32;
-
-        /** @var int $iter */
-        $iter = 1;
-
-        /** @var int $incr */
-        $incr = self::BUFFER_SIZE >> 6;
-
-        /* Decrypts ciphertext, writes to output file. */
-        while ($mlen > 0) {
-            $blockSize = $mlen > self::BUFFER_SIZE
-                ? self::BUFFER_SIZE
-                : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
-            }
-            $pBlock = ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
-                $ciphertext,
-                $realNonce,
-                $iter,
-                $subkey
-            );
-            fwrite($ofp, $pBlock, $blockSize);
-            $mlen -= $blockSize;
-            $iter += $incr;
-        }
-        return true;
-    }
-
-    /**
-     * @param ParagonIE_Sodium_Core_Poly1305_State $state
-     * @param resource $ifp
-     * @param string $tag
-     * @param int $mlen
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function onetimeauth_verify(
-        ParagonIE_Sodium_Core_Poly1305_State $state,
-        $ifp,
-        $tag = '',
-        $mlen = 0
-    ) {
-        /** @var int $pos */
-        $pos = self::ftell($ifp);
-
-        /** @var int $iter */
-        $iter = 1;
-
-        /** @var int $incr */
-        $incr = self::BUFFER_SIZE >> 6;
-
-        while ($mlen > 0) {
-            $blockSize = $mlen > self::BUFFER_SIZE
-                ? self::BUFFER_SIZE
-                : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
-            }
-            $state->update($ciphertext);
-            $mlen -= $blockSize;
-            $iter += $incr;
-        }
-        $res = ParagonIE_Sodium_Core_Util::verify_16($tag, $state->finish());
-
-        fseek($ifp, $pos, SEEK_SET);
-        return $res;
-    }
-
-    /**
-     * Update a hash context with the contents of a file, without
-     * loading the entire file into memory.
-     *
-     * @param resource|HashContext $hash
-     * @param resource $fp
-     * @param int $size
-     * @return resource|object Resource on PHP < 7.2, HashContext object on PHP >= 7.2
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress PossiblyInvalidArgument
-     *                 PHP 7.2 changes from a resource to an object,
-     *                 which causes Psalm to complain about an error.
-     * @psalm-suppress TypeCoercion
-     *                 Ditto.
-     */
-    public static function updateHashWithFile($hash, $fp, $size = 0)
-    {
-        /* Type checks: */
-        if (PHP_VERSION_ID < 70200) {
-            if (!is_resource($hash)) {
-                throw new TypeError('Argument 1 must be a resource, ' . gettype($hash) . ' given.');
-            }
-        } else {
-            if (!is_object($hash)) {
-                throw new TypeError('Argument 1 must be an object (PHP 7.2+), ' . gettype($hash) . ' given.');
-            }
-        }
-
-        if (!is_resource($fp)) {
-            throw new TypeError('Argument 2 must be a resource, ' . gettype($fp) . ' given.');
-        }
-        if (!is_int($size)) {
-            throw new TypeError('Argument 3 must be an integer, ' . gettype($size) . ' given.');
-        }
-
-        /** @var int $originalPosition */
-        $originalPosition = self::ftell($fp);
-
-        // Move file pointer to beginning of file
-        fseek($fp, 0, SEEK_SET);
-        for ($i = 0; $i < $size; $i += self::BUFFER_SIZE) {
-            /** @var string|bool $message */
-            $message = fread(
-                $fp,
-                ($size - $i) > self::BUFFER_SIZE
-                    ? $size - $i
-                    : self::BUFFER_SIZE
-            );
-            if (!is_string($message)) {
-                throw new SodiumException('Unexpected error reading from file.');
-            }
-            /** @var string $message */
-            /** @psalm-suppress InvalidArgument */
-            self::hash_update($hash, $message);
-        }
-        // Reset file pointer's position
-        fseek($fp, $originalPosition, SEEK_SET);
-        return $hash;
-    }
-
-    /**
-     * Sign a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_sign_detached(), but produces
-     * the same result. (32-bit)
-     *
-     * @param string $filePath  Absolute path to a file on the filesystem
-     * @param string $secretKey Secret signing key
-     *
-     * @return string           Ed25519 signature
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    private static function sign_core32($filePath, $secretKey)
-    {
-        /** @var int|bool $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-        /** @var int $size */
-
-        /** @var resource|bool $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-        /** @var resource $fp */
-
-        /** @var string $az */
-        $az = hash('sha512', self::substr($secretKey, 0, 32), true);
-
-        $az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
-        $az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
-
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($az, 32, 32));
-        /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
-
-        /** @var string $nonceHash */
-        $nonceHash = hash_final($hs, true);
-
-        /** @var string $pk */
-        $pk = self::substr($secretKey, 32, 32);
-
-        /** @var string $nonce */
-        $nonce = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
-
-        /** @var string $sig */
-        $sig = ParagonIE_Sodium_Core32_Ed25519::ge_p3_tobytes(
-            ParagonIE_Sodium_Core32_Ed25519::ge_scalarmult_base($nonce)
-        );
-
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($pk, 0, 32));
-        /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
-
-        /** @var string $hramHash */
-        $hramHash = hash_final($hs, true);
-
-        /** @var string $hram */
-        $hram = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($hramHash);
-
-        /** @var string $sigAfter */
-        $sigAfter = ParagonIE_Sodium_Core32_Ed25519::sc_muladd($hram, $az, $nonce);
-
-        /** @var string $sig */
-        $sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
-
-        try {
-            ParagonIE_Sodium_Compat::memzero($az);
-        } catch (SodiumException $ex) {
-            $az = null;
-        }
-        fclose($fp);
-        return $sig;
-    }
-
-    /**
-     *
-     * Verify a file (rather than a string). Uses less memory than
-     * ParagonIE_Sodium_Compat::crypto_sign_verify_detached(), but
-     * produces the same result. (32-bit)
-     *
-     * @param string $sig       Ed25519 signature
-     * @param string $filePath  Absolute path to a file on the filesystem
-     * @param string $publicKey Signing public key
-     *
-     * @return bool
-     * @throws SodiumException
-     * @throws Exception
-     */
-    public static function verify_core32($sig, $filePath, $publicKey)
-    {
-        /* Security checks */
-        if (ParagonIE_Sodium_Core32_Ed25519::check_S_lt_L(self::substr($sig, 32, 32))) {
-            throw new SodiumException('S < L - Invalid signature');
-        }
-        if (ParagonIE_Sodium_Core32_Ed25519::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');
-        }
-        $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= self::chrToInt($publicKey[$i]);
-        }
-        if ($d === 0) {
-            throw new SodiumException('All zero public key');
-        }
-
-        /** @var int|bool $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
-        }
-        /** @var int $size */
-
-        /** @var resource|bool $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
-        }
-        /** @var resource $fp */
-
-        /** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
-        $orig = ParagonIE_Sodium_Compat::$fastMult;
-
-        // Set ParagonIE_Sodium_Compat::$fastMult to true to speed up verification.
-        ParagonIE_Sodium_Compat::$fastMult = true;
-
-        /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P3 $A */
-        $A = ParagonIE_Sodium_Core32_Ed25519::ge_frombytes_negate_vartime($publicKey);
-
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($publicKey, 0, 32));
-        /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
-        /** @var string $hDigest */
-        $hDigest = hash_final($hs, true);
-
-        /** @var string $h */
-        $h = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($hDigest) . self::substr($hDigest, 32);
-
-        /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P2 $R */
-        $R = ParagonIE_Sodium_Core32_Ed25519::ge_double_scalarmult_vartime(
-            $h,
-            $A,
-            self::substr($sig, 32)
-        );
-
-        /** @var string $rcheck */
-        $rcheck = ParagonIE_Sodium_Core32_Ed25519::ge_tobytes($R);
-
-        // Close the file handle
-        fclose($fp);
-
-        // 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));
-    }
-
-    /**
-     * Encrypt a file (32-bit)
-     *
-     * @param resource $ifp
-     * @param resource $ofp
-     * @param int $mlen
-     * @param string $nonce
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
-    {
-        $plaintext = fread($ifp, 32);
-        if (!is_string($plaintext)) {
-            throw new SodiumException('Could not read input file');
-        }
-        $first32 = self::ftell($ifp);
-
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
-
-        /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
-
-        /** @var string $block0 */
-        $block0 = str_repeat("\x00", 32);
-
-        /** @var int $mlen - Length of the plaintext message */
-        $mlen0 = $mlen;
-        if ($mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES) {
-            $mlen0 = 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES;
-        }
-        $block0 .= ParagonIE_Sodium_Core32_Util::substr($plaintext, 0, $mlen0);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor(
-            $block0,
-            $realNonce,
-            $subkey
-        );
-
-        $state = new ParagonIE_Sodium_Core32_Poly1305_State(
-            ParagonIE_Sodium_Core32_Util::substr(
-                $block0,
-                0,
-                ParagonIE_Sodium_Crypto::onetimeauth_poly1305_KEYBYTES
-            )
-        );
-
-        // Pre-write 16 blank bytes for the Poly1305 tag
-        $start = self::ftell($ofp);
-        fwrite($ofp, str_repeat("\x00", 16));
-
-        /** @var string $c */
-        $cBlock = ParagonIE_Sodium_Core32_Util::substr(
-            $block0,
-            ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES
-        );
-        $state->update($cBlock);
-        fwrite($ofp, $cBlock);
-        $mlen -= 32;
-
-        /** @var int $iter */
-        $iter = 1;
-
-        /** @var int $incr */
-        $incr = self::BUFFER_SIZE >> 6;
-
-        /*
+		$first32 = fread($ifp, 32);
+		if (!is_string($first32)) {
+			throw new SodiumException('Could not read input file');
+		}
+		$first32len = self::strlen($first32);
+		fwrite(
+			$ofp,
+			self::xorStrings(
+				self::substr($block0, 32, $first32len),
+				self::substr($first32, 0, $first32len)
+			)
+		);
+		$mlen -= 32;
+
+		/** @var int $iter */
+		$iter = 1;
+
+		/** @var int $incr */
+		$incr = self::BUFFER_SIZE >> 6;
+
+		/* Decrypts ciphertext, writes to output file. */
+		while ($mlen > 0) {
+			$blockSize = $mlen > self::BUFFER_SIZE
+				? self::BUFFER_SIZE
+				: $mlen;
+			$ciphertext = fread($ifp, $blockSize);
+			if (!is_string($ciphertext)) {
+				throw new SodiumException('Could not read input file');
+			}
+			$pBlock = ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
+				$ciphertext,
+				$realNonce,
+				$iter,
+				$subkey
+			);
+			fwrite($ofp, $pBlock, $blockSize);
+			$mlen -= $blockSize;
+			$iter += $incr;
+		}
+		return true;
+	}
+
+	/**
+	 * @param ParagonIE_Sodium_Core_Poly1305_State $state
+	 * @param resource $ifp
+	 * @param string $tag
+	 * @param int $mlen
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function onetimeauth_verify(
+		ParagonIE_Sodium_Core_Poly1305_State $state,
+		$ifp,
+		$tag = '',
+		$mlen = 0
+	) {
+		/** @var int $pos */
+		$pos = self::ftell($ifp);
+
+		/** @var int $iter */
+		$iter = 1;
+
+		/** @var int $incr */
+		$incr = self::BUFFER_SIZE >> 6;
+
+		while ($mlen > 0) {
+			$blockSize = $mlen > self::BUFFER_SIZE
+				? self::BUFFER_SIZE
+				: $mlen;
+			$ciphertext = fread($ifp, $blockSize);
+			if (!is_string($ciphertext)) {
+				throw new SodiumException('Could not read input file');
+			}
+			$state->update($ciphertext);
+			$mlen -= $blockSize;
+			$iter += $incr;
+		}
+		$res = ParagonIE_Sodium_Core_Util::verify_16($tag, $state->finish());
+
+		fseek($ifp, $pos, SEEK_SET);
+		return $res;
+	}
+
+	/**
+	 * Update a hash context with the contents of a file, without
+	 * loading the entire file into memory.
+	 *
+	 * @param resource|HashContext $hash
+	 * @param resource $fp
+	 * @param int $size
+	 * @return resource|object Resource on PHP < 7.2, HashContext object on PHP >= 7.2
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress PossiblyInvalidArgument
+	 *                 PHP 7.2 changes from a resource to an object,
+	 *                 which causes Psalm to complain about an error.
+	 * @psalm-suppress TypeCoercion
+	 *                 Ditto.
+	 */
+	public static function updateHashWithFile($hash, $fp, $size = 0)
+	{
+		/* Type checks: */
+		if (PHP_VERSION_ID < 70200) {
+			if (!is_resource($hash)) {
+				throw new TypeError('Argument 1 must be a resource, ' . gettype($hash) . ' given.');
+			}
+		} else {
+			if (!is_object($hash)) {
+				throw new TypeError('Argument 1 must be an object (PHP 7.2+), ' . gettype($hash) . ' given.');
+			}
+		}
+
+		if (!is_resource($fp)) {
+			throw new TypeError('Argument 2 must be a resource, ' . gettype($fp) . ' given.');
+		}
+		if (!is_int($size)) {
+			throw new TypeError('Argument 3 must be an integer, ' . gettype($size) . ' given.');
+		}
+
+		/** @var int $originalPosition */
+		$originalPosition = self::ftell($fp);
+
+		// Move file pointer to beginning of file
+		fseek($fp, 0, SEEK_SET);
+		for ($i = 0; $i < $size; $i += self::BUFFER_SIZE) {
+			/** @var string|bool $message */
+			$message = fread(
+				$fp,
+				($size - $i) > self::BUFFER_SIZE
+					? $size - $i
+					: self::BUFFER_SIZE
+			);
+			if (!is_string($message)) {
+				throw new SodiumException('Unexpected error reading from file.');
+			}
+			/** @var string $message */
+			/** @psalm-suppress InvalidArgument */
+			self::hash_update($hash, $message);
+		}
+		// Reset file pointer's position
+		fseek($fp, $originalPosition, SEEK_SET);
+		return $hash;
+	}
+
+	/**
+	 * Sign a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_sign_detached(), but produces
+	 * the same result. (32-bit)
+	 *
+	 * @param string $filePath  Absolute path to a file on the filesystem
+	 * @param string $secretKey Secret signing key
+	 *
+	 * @return string           Ed25519 signature
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	private static function sign_core32($filePath, $secretKey)
+	{
+		/** @var int|bool $size */
+		$size = filesize($filePath);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+		/** @var int $size */
+
+		/** @var resource|bool $fp */
+		$fp = fopen($filePath, 'rb');
+		if (!is_resource($fp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+		/** @var resource $fp */
+
+		/** @var string $az */
+		$az = hash('sha512', self::substr($secretKey, 0, 32), true);
+
+		$az[0] = self::intToChr(self::chrToInt($az[0]) & 248);
+		$az[31] = self::intToChr((self::chrToInt($az[31]) & 63) | 64);
+
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($az, 32, 32));
+		/** @var resource $hs */
+		$hs = self::updateHashWithFile($hs, $fp, $size);
+
+		/** @var string $nonceHash */
+		$nonceHash = hash_final($hs, true);
+
+		/** @var string $pk */
+		$pk = self::substr($secretKey, 32, 32);
+
+		/** @var string $nonce */
+		$nonce = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
+
+		/** @var string $sig */
+		$sig = ParagonIE_Sodium_Core32_Ed25519::ge_p3_tobytes(
+			ParagonIE_Sodium_Core32_Ed25519::ge_scalarmult_base($nonce)
+		);
+
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($sig, 0, 32));
+		self::hash_update($hs, self::substr($pk, 0, 32));
+		/** @var resource $hs */
+		$hs = self::updateHashWithFile($hs, $fp, $size);
+
+		/** @var string $hramHash */
+		$hramHash = hash_final($hs, true);
+
+		/** @var string $hram */
+		$hram = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($hramHash);
+
+		/** @var string $sigAfter */
+		$sigAfter = ParagonIE_Sodium_Core32_Ed25519::sc_muladd($hram, $az, $nonce);
+
+		/** @var string $sig */
+		$sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
+
+		try {
+			ParagonIE_Sodium_Compat::memzero($az);
+		} catch (SodiumException $ex) {
+			$az = null;
+		}
+		fclose($fp);
+		return $sig;
+	}
+
+	/**
+	 *
+	 * Verify a file (rather than a string). Uses less memory than
+	 * ParagonIE_Sodium_Compat::crypto_sign_verify_detached(), but
+	 * produces the same result. (32-bit)
+	 *
+	 * @param string $sig       Ed25519 signature
+	 * @param string $filePath  Absolute path to a file on the filesystem
+	 * @param string $publicKey Signing public key
+	 *
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws Exception
+	 */
+	public static function verify_core32($sig, $filePath, $publicKey)
+	{
+		/* Security checks */
+		if (ParagonIE_Sodium_Core32_Ed25519::check_S_lt_L(self::substr($sig, 32, 32))) {
+			throw new SodiumException('S < L - Invalid signature');
+		}
+		if (ParagonIE_Sodium_Core32_Ed25519::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');
+		}
+		$d = 0;
+		for ($i = 0; $i < 32; ++$i) {
+			$d |= self::chrToInt($publicKey[$i]);
+		}
+		if ($d === 0) {
+			throw new SodiumException('All zero public key');
+		}
+
+		/** @var int|bool $size */
+		$size = filesize($filePath);
+		if (!is_int($size)) {
+			throw new SodiumException('Could not obtain the file size');
+		}
+		/** @var int $size */
+
+		/** @var resource|bool $fp */
+		$fp = fopen($filePath, 'rb');
+		if (!is_resource($fp)) {
+			throw new SodiumException('Could not open input file for reading');
+		}
+		/** @var resource $fp */
+
+		/** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
+		$orig = ParagonIE_Sodium_Compat::$fastMult;
+
+		// Set ParagonIE_Sodium_Compat::$fastMult to true to speed up verification.
+		ParagonIE_Sodium_Compat::$fastMult = true;
+
+		/** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P3 $A */
+		$A = ParagonIE_Sodium_Core32_Ed25519::ge_frombytes_negate_vartime($publicKey);
+
+		$hs = hash_init('sha512');
+		self::hash_update($hs, self::substr($sig, 0, 32));
+		self::hash_update($hs, self::substr($publicKey, 0, 32));
+		/** @var resource $hs */
+		$hs = self::updateHashWithFile($hs, $fp, $size);
+		/** @var string $hDigest */
+		$hDigest = hash_final($hs, true);
+
+		/** @var string $h */
+		$h = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($hDigest) . self::substr($hDigest, 32);
+
+		/** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P2 $R */
+		$R = ParagonIE_Sodium_Core32_Ed25519::ge_double_scalarmult_vartime(
+			$h,
+			$A,
+			self::substr($sig, 32)
+		);
+
+		/** @var string $rcheck */
+		$rcheck = ParagonIE_Sodium_Core32_Ed25519::ge_tobytes($R);
+
+		// Close the file handle
+		fclose($fp);
+
+		// 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));
+	}
+
+	/**
+	 * Encrypt a file (32-bit)
+	 *
+	 * @param resource $ifp
+	 * @param resource $ofp
+	 * @param int $mlen
+	 * @param string $nonce
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
+	{
+		$plaintext = fread($ifp, 32);
+		if (!is_string($plaintext)) {
+			throw new SodiumException('Could not read input file');
+		}
+		$first32 = self::ftell($ifp);
+
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
+
+		/** @var string $realNonce */
+		$realNonce = ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
+
+		/** @var string $block0 */
+		$block0 = str_repeat("\x00", 32);
+
+		/** @var int $mlen - Length of the plaintext message */
+		$mlen0 = $mlen;
+		if ($mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES) {
+			$mlen0 = 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES;
+		}
+		$block0 .= ParagonIE_Sodium_Core32_Util::substr($plaintext, 0, $mlen0);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor(
+			$block0,
+			$realNonce,
+			$subkey
+		);
+
+		$state = new ParagonIE_Sodium_Core32_Poly1305_State(
+			ParagonIE_Sodium_Core32_Util::substr(
+				$block0,
+				0,
+				ParagonIE_Sodium_Crypto::onetimeauth_poly1305_KEYBYTES
+			)
+		);
+
+		// Pre-write 16 blank bytes for the Poly1305 tag
+		$start = self::ftell($ofp);
+		fwrite($ofp, str_repeat("\x00", 16));
+
+		/** @var string $c */
+		$cBlock = ParagonIE_Sodium_Core32_Util::substr(
+			$block0,
+			ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES
+		);
+		$state->update($cBlock);
+		fwrite($ofp, $cBlock);
+		$mlen -= 32;
+
+		/** @var int $iter */
+		$iter = 1;
+
+		/** @var int $incr */
+		$incr = self::BUFFER_SIZE >> 6;
+
+		/*
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        fseek($ifp, $first32, SEEK_SET);
-
-        while ($mlen > 0) {
-            $blockSize = $mlen > self::BUFFER_SIZE
-                ? self::BUFFER_SIZE
-                : $mlen;
-            $plaintext = fread($ifp, $blockSize);
-            if (!is_string($plaintext)) {
-                throw new SodiumException('Could not read input file');
-            }
-            $cBlock = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
-                $plaintext,
-                $realNonce,
-                $iter,
-                $subkey
-            );
-            fwrite($ofp, $cBlock, $blockSize);
-            $state->update($cBlock);
-
-            $mlen -= $blockSize;
-            $iter += $incr;
-        }
-        try {
-            ParagonIE_Sodium_Compat::memzero($block0);
-            ParagonIE_Sodium_Compat::memzero($subkey);
-        } catch (SodiumException $ex) {
-            $block0 = null;
-            $subkey = null;
-        }
-        $end = self::ftell($ofp);
-
-        /*
+		fseek($ifp, $first32, SEEK_SET);
+
+		while ($mlen > 0) {
+			$blockSize = $mlen > self::BUFFER_SIZE
+				? self::BUFFER_SIZE
+				: $mlen;
+			$plaintext = fread($ifp, $blockSize);
+			if (!is_string($plaintext)) {
+				throw new SodiumException('Could not read input file');
+			}
+			$cBlock = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
+				$plaintext,
+				$realNonce,
+				$iter,
+				$subkey
+			);
+			fwrite($ofp, $cBlock, $blockSize);
+			$state->update($cBlock);
+
+			$mlen -= $blockSize;
+			$iter += $incr;
+		}
+		try {
+			ParagonIE_Sodium_Compat::memzero($block0);
+			ParagonIE_Sodium_Compat::memzero($subkey);
+		} catch (SodiumException $ex) {
+			$block0 = null;
+			$subkey = null;
+		}
+		$end = self::ftell($ofp);
+
+		/*
          * Write the Poly1305 authentication tag that provides integrity
          * over the ciphertext (encrypt-then-MAC)
          */
-        fseek($ofp, $start, SEEK_SET);
-        fwrite($ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES);
-        fseek($ofp, $end, SEEK_SET);
-        unset($state);
-
-        return true;
-    }
-
-    /**
-     * Decrypt a file (32-bit)
-     *
-     * @param resource $ifp
-     * @param resource $ofp
-     * @param int $mlen
-     * @param string $nonce
-     * @param string $key
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
-    {
-        $tag = fread($ifp, 16);
-        if (!is_string($tag)) {
-            throw new SodiumException('Could not read input file');
-        }
-
-        /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
-
-        /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
-
-        /** @var string $block0 */
-        $block0 = ParagonIE_Sodium_Core32_Salsa20::salsa20(
-            64,
-            ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
-            $subkey
-        );
-
-        /* Verify the Poly1305 MAC -before- attempting to decrypt! */
-        $state = new ParagonIE_Sodium_Core32_Poly1305_State(self::substr($block0, 0, 32));
-        if (!self::onetimeauth_verify_core32($state, $ifp, $tag, $mlen)) {
-            throw new SodiumException('Invalid MAC');
-        }
-
-        /*
+		fseek($ofp, $start, SEEK_SET);
+		fwrite($ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES);
+		fseek($ofp, $end, SEEK_SET);
+		unset($state);
+
+		return true;
+	}
+
+	/**
+	 * Decrypt a file (32-bit)
+	 *
+	 * @param resource $ifp
+	 * @param resource $ofp
+	 * @param int $mlen
+	 * @param string $nonce
+	 * @param string $key
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
+	{
+		$tag = fread($ifp, 16);
+		if (!is_string($tag)) {
+			throw new SodiumException('Could not read input file');
+		}
+
+		/** @var string $subkey */
+		$subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
+
+		/** @var string $realNonce */
+		$realNonce = ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
+
+		/** @var string $block0 */
+		$block0 = ParagonIE_Sodium_Core32_Salsa20::salsa20(
+			64,
+			ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8),
+			$subkey
+		);
+
+		/* Verify the Poly1305 MAC -before- attempting to decrypt! */
+		$state = new ParagonIE_Sodium_Core32_Poly1305_State(self::substr($block0, 0, 32));
+		if (!self::onetimeauth_verify_core32($state, $ifp, $tag, $mlen)) {
+			throw new SodiumException('Invalid MAC');
+		}
+
+		/*
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        $first32 = fread($ifp, 32);
-        if (!is_string($first32)) {
-            throw new SodiumException('Could not read input file');
-        }
-        $first32len = self::strlen($first32);
-        fwrite(
-            $ofp,
-            self::xorStrings(
-                self::substr($block0, 32, $first32len),
-                self::substr($first32, 0, $first32len)
-            )
-        );
-        $mlen -= 32;
-
-        /** @var int $iter */
-        $iter = 1;
-
-        /** @var int $incr */
-        $incr = self::BUFFER_SIZE >> 6;
-
-        /* Decrypts ciphertext, writes to output file. */
-        while ($mlen > 0) {
-            $blockSize = $mlen > self::BUFFER_SIZE
-                ? self::BUFFER_SIZE
-                : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
-            }
-            $pBlock = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
-                $ciphertext,
-                $realNonce,
-                $iter,
-                $subkey
-            );
-            fwrite($ofp, $pBlock, $blockSize);
-            $mlen -= $blockSize;
-            $iter += $incr;
-        }
-        return true;
-    }
-
-    /**
-     * One-time message authentication for 32-bit systems
-     *
-     * @param ParagonIE_Sodium_Core32_Poly1305_State $state
-     * @param resource $ifp
-     * @param string $tag
-     * @param int $mlen
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    protected static function onetimeauth_verify_core32(
-        ParagonIE_Sodium_Core32_Poly1305_State $state,
-        $ifp,
-        $tag = '',
-        $mlen = 0
-    ) {
-        /** @var int $pos */
-        $pos = self::ftell($ifp);
-
-        while ($mlen > 0) {
-            $blockSize = $mlen > self::BUFFER_SIZE
-                ? self::BUFFER_SIZE
-                : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
-            }
-            $state->update($ciphertext);
-            $mlen -= $blockSize;
-        }
-        $res = ParagonIE_Sodium_Core32_Util::verify_16($tag, $state->finish());
-
-        fseek($ifp, $pos, SEEK_SET);
-        return $res;
-    }
-
-    /**
-     * @param resource $resource
-     * @return int
-     * @throws SodiumException
-     */
-    private static function ftell($resource)
-    {
-        $return = ftell($resource);
-        if (!is_int($return)) {
-            throw new SodiumException('ftell() returned false');
-        }
-        return (int) $return;
-    }
+		$first32 = fread($ifp, 32);
+		if (!is_string($first32)) {
+			throw new SodiumException('Could not read input file');
+		}
+		$first32len = self::strlen($first32);
+		fwrite(
+			$ofp,
+			self::xorStrings(
+				self::substr($block0, 32, $first32len),
+				self::substr($first32, 0, $first32len)
+			)
+		);
+		$mlen -= 32;
+
+		/** @var int $iter */
+		$iter = 1;
+
+		/** @var int $incr */
+		$incr = self::BUFFER_SIZE >> 6;
+
+		/* Decrypts ciphertext, writes to output file. */
+		while ($mlen > 0) {
+			$blockSize = $mlen > self::BUFFER_SIZE
+				? self::BUFFER_SIZE
+				: $mlen;
+			$ciphertext = fread($ifp, $blockSize);
+			if (!is_string($ciphertext)) {
+				throw new SodiumException('Could not read input file');
+			}
+			$pBlock = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
+				$ciphertext,
+				$realNonce,
+				$iter,
+				$subkey
+			);
+			fwrite($ofp, $pBlock, $blockSize);
+			$mlen -= $blockSize;
+			$iter += $incr;
+		}
+		return true;
+	}
+
+	/**
+	 * One-time message authentication for 32-bit systems
+	 *
+	 * @param ParagonIE_Sodium_Core32_Poly1305_State $state
+	 * @param resource $ifp
+	 * @param string $tag
+	 * @param int $mlen
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	protected static function onetimeauth_verify_core32(
+		ParagonIE_Sodium_Core32_Poly1305_State $state,
+		$ifp,
+		$tag = '',
+		$mlen = 0
+	) {
+		/** @var int $pos */
+		$pos = self::ftell($ifp);
+
+		while ($mlen > 0) {
+			$blockSize = $mlen > self::BUFFER_SIZE
+				? self::BUFFER_SIZE
+				: $mlen;
+			$ciphertext = fread($ifp, $blockSize);
+			if (!is_string($ciphertext)) {
+				throw new SodiumException('Could not read input file');
+			}
+			$state->update($ciphertext);
+			$mlen -= $blockSize;
+		}
+		$res = ParagonIE_Sodium_Core32_Util::verify_16($tag, $state->finish());
+
+		fseek($ifp, $pos, SEEK_SET);
+		return $res;
+	}
+
+	/**
+	 * @param resource $resource
+	 * @return int
+	 * @throws SodiumException
+	 */
+	private static function ftell($resource)
+	{
+		$return = ftell($resource);
+		if (!is_int($return)) {
+			throw new SodiumException('ftell() returned false');
+		}
+		return (int) $return;
+	}
 }

Spacing +513 added lines, -513 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('ParagonIE_Sodium_File', false)) {
+if ( class_exists( 'ParagonIE_Sodium_File', false ) ) {
     return;
 }
 /**
@@ -25,52 +25,52 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box($inputFile, $outputFile, $nonce, $keyPair)
+    public static function box( $inputFile, $outputFile, $nonce, $keyPair )
     {
         /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+        if ( ! is_string( $inputFile ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $inputFile ) . ' given.' );
         }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+        if ( ! is_string( $outputFile ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $outputFile ) . ' given.' );
         }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+        if ( ! is_string( $nonce ) ) {
+            throw new TypeError( 'Argument 3 must be a string, ' . gettype( $nonce ) . ' given.' );
         }
 
         /* Input validation: */
-        if (!is_string($keyPair)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($keyPair) . ' given.');
+        if ( ! is_string( $keyPair ) ) {
+            throw new TypeError( 'Argument 4 must be a string, ' . gettype( $keyPair ) . ' given.' );
         }
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_BOX_NONCEBYTES bytes');
+        if ( self::strlen( $nonce ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES ) {
+            throw new TypeError( 'Argument 3 must be CRYPTO_BOX_NONCEBYTES bytes' );
         }
-        if (self::strlen($keyPair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
+        if ( self::strlen( $keyPair ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new TypeError( 'Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes' );
         }
 
         /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $inputFile );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $ifp = fopen( $inputFile, 'rb' );
+        if ( ! is_resource( $ifp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
+        $ofp = fopen( $outputFile, 'wb' );
+        if ( ! is_resource( $ofp ) ) {
+            fclose( $ifp );
+            throw new SodiumException( 'Could not open output file for writing' );
         }
 
-        $res = self::box_encrypt($ifp, $ofp, $size, $nonce, $keyPair);
-        fclose($ifp);
-        fclose($ofp);
+        $res = self::box_encrypt( $ifp, $ofp, $size, $nonce, $keyPair );
+        fclose( $ifp );
+        fclose( $ofp );
         return $res;
     }
 
@@ -91,58 +91,58 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_open($inputFile, $outputFile, $nonce, $keypair)
+    public static function box_open( $inputFile, $outputFile, $nonce, $keypair )
     {
         /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+        if ( ! is_string( $inputFile ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $inputFile ) . ' given.' );
         }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+        if ( ! is_string( $outputFile ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $outputFile ) . ' given.' );
         }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+        if ( ! is_string( $nonce ) ) {
+            throw new TypeError( 'Argument 3 must be a string, ' . gettype( $nonce ) . ' given.' );
         }
-        if (!is_string($keypair)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($keypair) . ' given.');
+        if ( ! is_string( $keypair ) ) {
+            throw new TypeError( 'Argument 4 must be a string, ' . gettype( $keypair ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_BOX_NONCEBYTES bytes');
+        if ( self::strlen( $nonce ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES ) {
+            throw new TypeError( 'Argument 4 must be CRYPTO_BOX_NONCEBYTES bytes' );
         }
-        if (self::strlen($keypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
+        if ( self::strlen( $keypair ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new TypeError( 'Argument 4 must be CRYPTO_BOX_KEYPAIRBYTES bytes' );
         }
 
         /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $inputFile );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $ifp = fopen( $inputFile, 'rb' );
+        if ( ! is_resource( $ifp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
+        $ofp = fopen( $outputFile, 'wb' );
+        if ( ! is_resource( $ofp ) ) {
+            fclose( $ifp );
+            throw new SodiumException( 'Could not open output file for writing' );
         }
 
-        $res = self::box_decrypt($ifp, $ofp, $size, $nonce, $keypair);
-        fclose($ifp);
-        fclose($ofp);
+        $res = self::box_decrypt( $ifp, $ofp, $size, $nonce, $keypair );
+        fclose( $ifp );
+        fclose( $ofp );
         try {
-            ParagonIE_Sodium_Compat::memzero($nonce);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-        } catch (SodiumException $ex) {
-            if (isset($ephKeypair)) {
-                unset($ephKeypair);
+            ParagonIE_Sodium_Compat::memzero( $nonce );
+            ParagonIE_Sodium_Compat::memzero( $ephKeypair );
+        } catch ( SodiumException $ex ) {
+            if ( isset( $ephKeypair ) ) {
+                unset( $ephKeypair );
             }
         }
         return $res;
@@ -161,41 +161,41 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seal($inputFile, $outputFile, $publicKey)
+    public static function box_seal( $inputFile, $outputFile, $publicKey )
     {
         /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+        if ( ! is_string( $inputFile ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $inputFile ) . ' given.' );
         }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+        if ( ! is_string( $outputFile ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $outputFile ) . ' given.' );
         }
-        if (!is_string($publicKey)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($publicKey) . ' given.');
+        if ( ! is_string( $publicKey ) ) {
+            throw new TypeError( 'Argument 3 must be a string, ' . gettype( $publicKey ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($publicKey) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_BOX_PUBLICKEYBYTES bytes');
+        if ( self::strlen( $publicKey ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            throw new TypeError( 'Argument 3 must be CRYPTO_BOX_PUBLICKEYBYTES bytes' );
         }
 
         /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $inputFile );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $ifp = fopen( $inputFile, 'rb' );
+        if ( ! is_resource( $ifp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
+        $ofp = fopen( $outputFile, 'wb' );
+        if ( ! is_resource( $ofp ) ) {
+            fclose( $ifp );
+            throw new SodiumException( 'Could not open output file for writing' );
         }
 
         /** @var string $ephKeypair */
@@ -203,12 +203,12 @@ 
 
         /** @var string $msgKeypair */
         $msgKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey(
-            ParagonIE_Sodium_Compat::crypto_box_secretkey($ephKeypair),
+            ParagonIE_Sodium_Compat::crypto_box_secretkey( $ephKeypair ),
             $publicKey
         );
 
         /** @var string $ephemeralPK */
-        $ephemeralPK = ParagonIE_Sodium_Compat::crypto_box_publickey($ephKeypair);
+        $ephemeralPK = ParagonIE_Sodium_Compat::crypto_box_publickey( $ephKeypair );
 
         /** @var string $nonce */
         $nonce = ParagonIE_Sodium_Compat::crypto_generichash(
@@ -223,28 +223,28 @@ 
             $ephemeralPK,
             ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES
         );
-        if (!is_int($firstWrite)) {
-            fclose($ifp);
-            fclose($ofp);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-            throw new SodiumException('Could not write to output file');
-        }
-        if ($firstWrite !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-            fclose($ifp);
-            fclose($ofp);
-            throw new SodiumException('Error writing public key to output file');
-        }
-
-        $res = self::box_encrypt($ifp, $ofp, $size, $nonce, $msgKeypair);
-        fclose($ifp);
-        fclose($ofp);
+        if ( ! is_int( $firstWrite ) ) {
+            fclose( $ifp );
+            fclose( $ofp );
+            ParagonIE_Sodium_Compat::memzero( $ephKeypair );
+            throw new SodiumException( 'Could not write to output file' );
+        }
+        if ( $firstWrite !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            ParagonIE_Sodium_Compat::memzero( $ephKeypair );
+            fclose( $ifp );
+            fclose( $ofp );
+            throw new SodiumException( 'Error writing public key to output file' );
+        }
+
+        $res = self::box_encrypt( $ifp, $ofp, $size, $nonce, $msgKeypair );
+        fclose( $ifp );
+        fclose( $ofp );
         try {
-            ParagonIE_Sodium_Compat::memzero($nonce);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $nonce );
+            ParagonIE_Sodium_Compat::memzero( $ephKeypair );
+        } catch ( SodiumException $ex ) {
             /** @psalm-suppress PossiblyUndefinedVariable */
-            unset($ephKeypair);
+            unset( $ephKeypair );
         }
         return $res;
     }
@@ -265,53 +265,53 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seal_open($inputFile, $outputFile, $ecdhKeypair)
+    public static function box_seal_open( $inputFile, $outputFile, $ecdhKeypair )
     {
         /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+        if ( ! is_string( $inputFile ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $inputFile ) . ' given.' );
         }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+        if ( ! is_string( $outputFile ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $outputFile ) . ' given.' );
         }
-        if (!is_string($ecdhKeypair)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($ecdhKeypair) . ' given.');
+        if ( ! is_string( $ecdhKeypair ) ) {
+            throw new TypeError( 'Argument 3 must be a string, ' . gettype( $ecdhKeypair ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($ecdhKeypair) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES bytes');
+        if ( self::strlen( $ecdhKeypair ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES ) {
+            throw new TypeError( 'Argument 3 must be CRYPTO_BOX_KEYPAIRBYTES bytes' );
         }
 
-        $publicKey = ParagonIE_Sodium_Compat::crypto_box_publickey($ecdhKeypair);
+        $publicKey = ParagonIE_Sodium_Compat::crypto_box_publickey( $ecdhKeypair );
 
         /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $inputFile );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $ifp = fopen( $inputFile, 'rb' );
+        if ( ! is_resource( $ifp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
+        $ofp = fopen( $outputFile, 'wb' );
+        if ( ! is_resource( $ofp ) ) {
+            fclose( $ifp );
+            throw new SodiumException( 'Could not open output file for writing' );
         }
 
-        $ephemeralPK = fread($ifp, ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES);
-        if (!is_string($ephemeralPK)) {
-            throw new SodiumException('Could not read input file');
+        $ephemeralPK = fread( $ifp, ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES );
+        if ( ! is_string( $ephemeralPK ) ) {
+            throw new SodiumException( 'Could not read input file' );
         }
-        if (self::strlen($ephemeralPK) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES) {
-            fclose($ifp);
-            fclose($ofp);
-            throw new SodiumException('Could not read public key from sealed file');
+        if ( self::strlen( $ephemeralPK ) !== ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES ) {
+            fclose( $ifp );
+            fclose( $ofp );
+            throw new SodiumException( 'Could not read public key from sealed file' );
         }
 
         $nonce = ParagonIE_Sodium_Compat::crypto_generichash(
@@ -320,19 +320,19 @@ 
             24
         );
         $msgKeypair = ParagonIE_Sodium_Compat::crypto_box_keypair_from_secretkey_and_publickey(
-            ParagonIE_Sodium_Compat::crypto_box_secretkey($ecdhKeypair),
+            ParagonIE_Sodium_Compat::crypto_box_secretkey( $ecdhKeypair ),
             $ephemeralPK
         );
 
-        $res = self::box_decrypt($ifp, $ofp, $size, $nonce, $msgKeypair);
-        fclose($ifp);
-        fclose($ofp);
+        $res = self::box_decrypt( $ifp, $ofp, $size, $nonce, $msgKeypair );
+        fclose( $ifp );
+        fclose( $ofp );
         try {
-            ParagonIE_Sodium_Compat::memzero($nonce);
-            ParagonIE_Sodium_Compat::memzero($ephKeypair);
-        } catch (SodiumException $ex) {
-            if (isset($ephKeypair)) {
-                unset($ephKeypair);
+            ParagonIE_Sodium_Compat::memzero( $nonce );
+            ParagonIE_Sodium_Compat::memzero( $ephKeypair );
+        } catch ( SodiumException $ex ) {
+            if ( isset( $ephKeypair ) ) {
+                unset( $ephKeypair );
             }
         }
         return $res;
@@ -350,68 +350,68 @@ 
      * @throws TypeError
      * @psalm-suppress FailedTypeResolution
      */
-    public static function generichash($filePath, $key = '', $outputLength = 32)
+    public static function generichash( $filePath, $key = '', $outputLength = 32 )
     {
         /* Type checks: */
-        if (!is_string($filePath)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
+        if ( ! is_string( $filePath ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $filePath ) . ' given.' );
         }
-        if (!is_string($key)) {
-            if (is_null($key)) {
+        if ( ! is_string( $key ) ) {
+            if ( is_null( $key ) ) {
                 $key = '';
             } else {
-                throw new TypeError('Argument 2 must be a string, ' . gettype($key) . ' given.');
+                throw new TypeError( 'Argument 2 must be a string, ' . gettype( $key ) . ' given.' );
             }
         }
-        if (!is_int($outputLength)) {
-            if (!is_numeric($outputLength)) {
-                throw new TypeError('Argument 3 must be an integer, ' . gettype($outputLength) . ' given.');
+        if ( ! is_int( $outputLength ) ) {
+            if ( ! is_numeric( $outputLength ) ) {
+                throw new TypeError( 'Argument 3 must be an integer, ' . gettype( $outputLength ) . ' given.' );
             }
-            $outputLength = (int) $outputLength;
+            $outputLength = (int)$outputLength;
         }
 
         /* Input validation: */
-        if (!empty($key)) {
-            if (self::strlen($key) < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MIN) {
-                throw new TypeError('Argument 2 must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes');
+        if ( ! empty( $key ) ) {
+            if ( self::strlen( $key ) < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MIN ) {
+                throw new TypeError( 'Argument 2 must be at least CRYPTO_GENERICHASH_KEYBYTES_MIN bytes' );
             }
-            if (self::strlen($key) > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MAX) {
-                throw new TypeError('Argument 2 must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes');
+            if ( self::strlen( $key ) > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MAX ) {
+                throw new TypeError( 'Argument 2 must be at most CRYPTO_GENERICHASH_KEYBYTES_MAX bytes' );
             }
         }
-        if ($outputLength < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MIN) {
-            throw new SodiumException('Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MIN');
+        if ( $outputLength < ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MIN ) {
+            throw new SodiumException( 'Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MIN' );
         }
-        if ($outputLength > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MAX) {
-            throw new SodiumException('Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MAX');
+        if ( $outputLength > ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MAX ) {
+            throw new SodiumException( 'Argument 3 must be at least CRYPTO_GENERICHASH_BYTES_MAX' );
         }
 
         /** @var int $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $filePath );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $fp = fopen( $filePath, 'rb' );
+        if ( ! is_resource( $fp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
-        $ctx = ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outputLength);
-        while ($size > 0) {
+        $ctx = ParagonIE_Sodium_Compat::crypto_generichash_init( $key, $outputLength );
+        while ( $size > 0 ) {
             $blockSize = $size > 64
                 ? 64
                 : $size;
-            $read = fread($fp, $blockSize);
-            if (!is_string($read)) {
-                throw new SodiumException('Could not read input file');
+            $read = fread( $fp, $blockSize );
+            if ( ! is_string( $read ) ) {
+                throw new SodiumException( 'Could not read input file' );
             }
-            ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $read);
+            ParagonIE_Sodium_Compat::crypto_generichash_update( $ctx, $read );
             $size -= $blockSize;
         }
 
-        fclose($fp);
-        return ParagonIE_Sodium_Compat::crypto_generichash_final($ctx, $outputLength);
+        fclose( $fp );
+        return ParagonIE_Sodium_Compat::crypto_generichash_final( $ctx, $outputLength );
     }
 
     /**
@@ -428,52 +428,52 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox($inputFile, $outputFile, $nonce, $key)
+    public static function secretbox( $inputFile, $outputFile, $nonce, $key )
     {
         /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given..');
+        if ( ! is_string( $inputFile ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $inputFile ) . ' given..' );
         }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+        if ( ! is_string( $outputFile ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $outputFile ) . ' given.' );
         }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+        if ( ! is_string( $nonce ) ) {
+            throw new TypeError( 'Argument 3 must be a string, ' . gettype( $nonce ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_SECRETBOX_NONCEBYTES bytes');
+        if ( self::strlen( $nonce ) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES ) {
+            throw new TypeError( 'Argument 3 must be CRYPTO_SECRETBOX_NONCEBYTES bytes' );
         }
-        if (!is_string($key)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($key) . ' given.');
+        if ( ! is_string( $key ) ) {
+            throw new TypeError( 'Argument 4 must be a string, ' . gettype( $key ) . ' given.' );
         }
-        if (self::strlen($key) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_SECRETBOX_KEYBYTES bytes');
+        if ( self::strlen( $key ) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES ) {
+            throw new TypeError( 'Argument 4 must be CRYPTO_SECRETBOX_KEYBYTES bytes' );
         }
 
         /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $inputFile );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $ifp = fopen( $inputFile, 'rb' );
+        if ( ! is_resource( $ifp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
+        $ofp = fopen( $outputFile, 'wb' );
+        if ( ! is_resource( $ofp ) ) {
+            fclose( $ifp );
+            throw new SodiumException( 'Could not open output file for writing' );
         }
 
-        $res = self::secretbox_encrypt($ifp, $ofp, $size, $nonce, $key);
-        fclose($ifp);
-        fclose($ofp);
+        $res = self::secretbox_encrypt( $ifp, $ofp, $size, $nonce, $key );
+        fclose( $ifp );
+        fclose( $ofp );
         return $res;
     }
     /**
@@ -493,57 +493,57 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox_open($inputFile, $outputFile, $nonce, $key)
+    public static function secretbox_open( $inputFile, $outputFile, $nonce, $key )
     {
         /* Type checks: */
-        if (!is_string($inputFile)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
+        if ( ! is_string( $inputFile ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $inputFile ) . ' given.' );
         }
-        if (!is_string($outputFile)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($outputFile) . ' given.');
+        if ( ! is_string( $outputFile ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $outputFile ) . ' given.' );
         }
-        if (!is_string($nonce)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($nonce) . ' given.');
+        if ( ! is_string( $nonce ) ) {
+            throw new TypeError( 'Argument 3 must be a string, ' . gettype( $nonce ) . ' given.' );
         }
-        if (!is_string($key)) {
-            throw new TypeError('Argument 4 must be a string, ' . gettype($key) . ' given.');
+        if ( ! is_string( $key ) ) {
+            throw new TypeError( 'Argument 4 must be a string, ' . gettype( $key ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($nonce) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_SECRETBOX_NONCEBYTES bytes');
+        if ( self::strlen( $nonce ) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES ) {
+            throw new TypeError( 'Argument 4 must be CRYPTO_SECRETBOX_NONCEBYTES bytes' );
         }
-        if (self::strlen($key) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new TypeError('Argument 4 must be CRYPTO_SECRETBOXBOX_KEYBYTES bytes');
+        if ( self::strlen( $key ) !== ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES ) {
+            throw new TypeError( 'Argument 4 must be CRYPTO_SECRETBOXBOX_KEYBYTES bytes' );
         }
 
         /** @var int $size */
-        $size = filesize($inputFile);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $inputFile );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $ifp */
-        $ifp = fopen($inputFile, 'rb');
-        if (!is_resource($ifp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $ifp = fopen( $inputFile, 'rb' );
+        if ( ! is_resource( $ifp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var resource $ofp */
-        $ofp = fopen($outputFile, 'wb');
-        if (!is_resource($ofp)) {
-            fclose($ifp);
-            throw new SodiumException('Could not open output file for writing');
+        $ofp = fopen( $outputFile, 'wb' );
+        if ( ! is_resource( $ofp ) ) {
+            fclose( $ifp );
+            throw new SodiumException( 'Could not open output file for writing' );
         }
 
-        $res = self::secretbox_decrypt($ifp, $ofp, $size, $nonce, $key);
-        fclose($ifp);
-        fclose($ofp);
+        $res = self::secretbox_decrypt( $ifp, $ofp, $size, $nonce, $key );
+        fclose( $ifp );
+        fclose( $ofp );
         try {
-            ParagonIE_Sodium_Compat::memzero($key);
-        } catch (SodiumException $ex) {
+            ParagonIE_Sodium_Compat::memzero( $key );
+        } catch ( SodiumException $ex ) {
             /** @psalm-suppress PossiblyUndefinedVariable */
-            unset($key);
+            unset( $key );
         }
         return $res;
     }
@@ -560,85 +560,85 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($filePath, $secretKey)
+    public static function sign( $filePath, $secretKey )
     {
         /* Type checks: */
-        if (!is_string($filePath)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
+        if ( ! is_string( $filePath ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $filePath ) . ' given.' );
         }
-        if (!is_string($secretKey)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($secretKey) . ' given.');
+        if ( ! is_string( $secretKey ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $secretKey ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($secretKey) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_SECRETKEYBYTES) {
-            throw new TypeError('Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES bytes');
+        if ( self::strlen( $secretKey ) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_SECRETKEYBYTES ) {
+            throw new TypeError( 'Argument 2 must be CRYPTO_SIGN_SECRETKEYBYTES bytes' );
         }
-        if (PHP_INT_SIZE === 4) {
-            return self::sign_core32($filePath, $secretKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return self::sign_core32( $filePath, $secretKey );
         }
 
         /** @var int $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $filePath );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $fp = fopen( $filePath, 'rb' );
+        if ( ! is_resource( $fp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var string $az */
-        $az = hash('sha512', self::substr($secretKey, 0, 32), true);
+        $az = hash( 'sha512', self::substr( $secretKey, 0, 32 ), true );
 
-        $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 );
 
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($az, 32, 32));
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $az, 32, 32 ) );
         /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
+        $hs = self::updateHashWithFile( $hs, $fp, $size );
 
         /** @var string $nonceHash */
-        $nonceHash = hash_final($hs, true);
+        $nonceHash = hash_final( $hs, true );
 
         /** @var string $pk */
-        $pk = self::substr($secretKey, 32, 32);
+        $pk = self::substr( $secretKey, 32, 32 );
 
         /** @var string $nonce */
-        $nonce = ParagonIE_Sodium_Core_Ed25519::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
+        $nonce = ParagonIE_Sodium_Core_Ed25519::sc_reduce( $nonceHash ) . self::substr( $nonceHash, 32 );
 
         /** @var string $sig */
         $sig = ParagonIE_Sodium_Core_Ed25519::ge_p3_tobytes(
-            ParagonIE_Sodium_Core_Ed25519::ge_scalarmult_base($nonce)
+            ParagonIE_Sodium_Core_Ed25519::ge_scalarmult_base( $nonce )
         );
 
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($pk, 0, 32));
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $sig, 0, 32 ) );
+        self::hash_update( $hs, self::substr( $pk, 0, 32 ) );
         /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
+        $hs = self::updateHashWithFile( $hs, $fp, $size );
 
         /** @var string $hramHash */
-        $hramHash = hash_final($hs, true);
+        $hramHash = hash_final( $hs, true );
 
         /** @var string $hram */
-        $hram = ParagonIE_Sodium_Core_Ed25519::sc_reduce($hramHash);
+        $hram = ParagonIE_Sodium_Core_Ed25519::sc_reduce( $hramHash );
 
         /** @var string $sigAfter */
-        $sigAfter = ParagonIE_Sodium_Core_Ed25519::sc_muladd($hram, $az, $nonce);
+        $sigAfter = ParagonIE_Sodium_Core_Ed25519::sc_muladd( $hram, $az, $nonce );
 
         /** @var string $sig */
-        $sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
+        $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;
         }
-        fclose($fp);
+        fclose( $fp );
         return $sig;
     }
 
@@ -656,66 +656,66 @@ 
      * @throws TypeError
      * @throws Exception
      */
-    public static function verify($sig, $filePath, $publicKey)
+    public static function verify( $sig, $filePath, $publicKey )
     {
         /* Type checks: */
-        if (!is_string($sig)) {
-            throw new TypeError('Argument 1 must be a string, ' . gettype($sig) . ' given.');
+        if ( ! is_string( $sig ) ) {
+            throw new TypeError( 'Argument 1 must be a string, ' . gettype( $sig ) . ' given.' );
         }
-        if (!is_string($filePath)) {
-            throw new TypeError('Argument 2 must be a string, ' . gettype($filePath) . ' given.');
+        if ( ! is_string( $filePath ) ) {
+            throw new TypeError( 'Argument 2 must be a string, ' . gettype( $filePath ) . ' given.' );
         }
-        if (!is_string($publicKey)) {
-            throw new TypeError('Argument 3 must be a string, ' . gettype($publicKey) . ' given.');
+        if ( ! is_string( $publicKey ) ) {
+            throw new TypeError( 'Argument 3 must be a string, ' . gettype( $publicKey ) . ' given.' );
         }
 
         /* Input validation: */
-        if (self::strlen($sig) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_BYTES) {
-            throw new TypeError('Argument 1 must be CRYPTO_SIGN_BYTES bytes');
+        if ( self::strlen( $sig ) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_BYTES ) {
+            throw new TypeError( 'Argument 1 must be CRYPTO_SIGN_BYTES bytes' );
         }
-        if (self::strlen($publicKey) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_PUBLICKEYBYTES) {
-            throw new TypeError('Argument 3 must be CRYPTO_SIGN_PUBLICKEYBYTES bytes');
+        if ( self::strlen( $publicKey ) !== ParagonIE_Sodium_Compat::CRYPTO_SIGN_PUBLICKEYBYTES ) {
+            throw new TypeError( 'Argument 3 must be CRYPTO_SIGN_PUBLICKEYBYTES bytes' );
         }
-        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 (PHP_INT_SIZE === 4) {
-            return self::verify_core32($sig, $filePath, $publicKey);
+        if ( PHP_INT_SIZE === 4 ) {
+            return self::verify_core32( $sig, $filePath, $publicKey );
         }
 
         /* Security checks */
         if (
-            (ParagonIE_Sodium_Core_Ed25519::chrToInt($sig[63]) & 240)
+            ( ParagonIE_Sodium_Core_Ed25519::chrToInt( $sig[ 63 ] ) & 240 )
                 &&
-            ParagonIE_Sodium_Core_Ed25519::check_S_lt_L(self::substr($sig, 32, 32))
+            ParagonIE_Sodium_Core_Ed25519::check_S_lt_L( self::substr( $sig, 32, 32 ) )
         ) {
-            throw new SodiumException('S < L - Invalid signature');
+            throw new SodiumException( 'S < L - Invalid signature' );
         }
-        if (ParagonIE_Sodium_Core_Ed25519::small_order($sig)) {
-            throw new SodiumException('Signature is on too small of an order');
+        if ( ParagonIE_Sodium_Core_Ed25519::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($publicKey[$i]);
+        for ( $i = 0; $i < 32; ++$i ) {
+            $d |= self::chrToInt( $publicKey[ $i ] );
         }
-        if ($d === 0) {
-            throw new SodiumException('All zero public key');
+        if ( $d === 0 ) {
+            throw new SodiumException( 'All zero public key' );
         }
 
         /** @var int $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $filePath );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
 
         /** @var resource $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $fp = fopen( $filePath, 'rb' );
+        if ( ! is_resource( $fp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
 
         /** @var bool The original value of ParagonIE_Sodium_Compat::$fastMult */
@@ -725,35 +725,35 @@ 
         ParagonIE_Sodium_Compat::$fastMult = true;
 
         /** @var ParagonIE_Sodium_Core_Curve25519_Ge_P3 $A */
-        $A = ParagonIE_Sodium_Core_Ed25519::ge_frombytes_negate_vartime($publicKey);
+        $A = ParagonIE_Sodium_Core_Ed25519::ge_frombytes_negate_vartime( $publicKey );
 
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($publicKey, 0, 32));
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $sig, 0, 32 ) );
+        self::hash_update( $hs, self::substr( $publicKey, 0, 32 ) );
         /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
+        $hs = self::updateHashWithFile( $hs, $fp, $size );
         /** @var string $hDigest */
-        $hDigest = hash_final($hs, true);
+        $hDigest = hash_final( $hs, true );
 
         /** @var string $h */
-        $h = ParagonIE_Sodium_Core_Ed25519::sc_reduce($hDigest) . self::substr($hDigest, 32);
+        $h = ParagonIE_Sodium_Core_Ed25519::sc_reduce( $hDigest ) . self::substr( $hDigest, 32 );
 
         /** @var ParagonIE_Sodium_Core_Curve25519_Ge_P2 $R */
         $R = ParagonIE_Sodium_Core_Ed25519::ge_double_scalarmult_vartime(
             $h,
             $A,
-            self::substr($sig, 32)
+            self::substr( $sig, 32 )
         );
 
         /** @var string $rcheck */
-        $rcheck = ParagonIE_Sodium_Core_Ed25519::ge_tobytes($R);
+        $rcheck = ParagonIE_Sodium_Core_Ed25519::ge_tobytes( $R );
 
         // Close the file handle
-        fclose($fp);
+        fclose( $fp );
 
         // 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 ) );
     }
 
     /**
@@ -766,17 +766,17 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function box_encrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
+    protected static function box_encrypt( $ifp, $ofp, $mlen, $nonce, $boxKeypair )
     {
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return self::secretbox_encrypt(
                 $ifp,
                 $ofp,
                 $mlen,
                 $nonce,
                 ParagonIE_Sodium_Crypto32::box_beforenm(
-                    ParagonIE_Sodium_Crypto32::box_secretkey($boxKeypair),
-                    ParagonIE_Sodium_Crypto32::box_publickey($boxKeypair)
+                    ParagonIE_Sodium_Crypto32::box_secretkey( $boxKeypair ),
+                    ParagonIE_Sodium_Crypto32::box_publickey( $boxKeypair )
                 )
             );
         }
@@ -786,8 +786,8 @@ 
             $mlen,
             $nonce,
             ParagonIE_Sodium_Crypto::box_beforenm(
-                ParagonIE_Sodium_Crypto::box_secretkey($boxKeypair),
-                ParagonIE_Sodium_Crypto::box_publickey($boxKeypair)
+                ParagonIE_Sodium_Crypto::box_secretkey( $boxKeypair ),
+                ParagonIE_Sodium_Crypto::box_publickey( $boxKeypair )
             )
         );
     }
@@ -803,17 +803,17 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function box_decrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
+    protected static function box_decrypt( $ifp, $ofp, $mlen, $nonce, $boxKeypair )
     {
-        if (PHP_INT_SIZE === 4) {
+        if ( PHP_INT_SIZE === 4 ) {
             return self::secretbox_decrypt(
                 $ifp,
                 $ofp,
                 $mlen,
                 $nonce,
                 ParagonIE_Sodium_Crypto32::box_beforenm(
-                    ParagonIE_Sodium_Crypto32::box_secretkey($boxKeypair),
-                    ParagonIE_Sodium_Crypto32::box_publickey($boxKeypair)
+                    ParagonIE_Sodium_Crypto32::box_secretkey( $boxKeypair ),
+                    ParagonIE_Sodium_Crypto32::box_publickey( $boxKeypair )
                 )
             );
         }
@@ -823,8 +823,8 @@ 
             $mlen,
             $nonce,
             ParagonIE_Sodium_Crypto::box_beforenm(
-                ParagonIE_Sodium_Crypto::box_secretkey($boxKeypair),
-                ParagonIE_Sodium_Crypto::box_publickey($boxKeypair)
+                ParagonIE_Sodium_Crypto::box_secretkey( $boxKeypair ),
+                ParagonIE_Sodium_Crypto::box_publickey( $boxKeypair )
             )
         );
     }
@@ -841,33 +841,33 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_encrypt($ifp, $ofp, $mlen, $nonce, $key)
+    protected static function secretbox_encrypt( $ifp, $ofp, $mlen, $nonce, $key )
     {
-        if (PHP_INT_SIZE === 4) {
-            return self::secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return self::secretbox_encrypt_core32( $ifp, $ofp, $mlen, $nonce, $key );
         }
 
-        $plaintext = fread($ifp, 32);
-        if (!is_string($plaintext)) {
-            throw new SodiumException('Could not read input file');
+        $plaintext = fread( $ifp, 32 );
+        if ( ! is_string( $plaintext ) ) {
+            throw new SodiumException( 'Could not read input file' );
         }
-        $first32 = self::ftell($ifp);
+        $first32 = self::ftell( $ifp );
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20( $nonce, $key );
 
         /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+        $realNonce = ParagonIE_Sodium_Core_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 */
         $mlen0 = $mlen;
-        if ($mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES) {
+        if ( $mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES ) {
             $mlen0 = 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES;
         }
-        $block0 .= ParagonIE_Sodium_Core_Util::substr($plaintext, 0, $mlen0);
+        $block0 .= ParagonIE_Sodium_Core_Util::substr( $plaintext, 0, $mlen0 );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20_xor(
@@ -885,16 +885,16 @@ 
         );
 
         // Pre-write 16 blank bytes for the Poly1305 tag
-        $start = self::ftell($ofp);
-        fwrite($ofp, str_repeat("\x00", 16));
+        $start = self::ftell( $ofp );
+        fwrite( $ofp, str_repeat( "\x00", 16 ) );
 
         /** @var string $c */
         $cBlock = ParagonIE_Sodium_Core_Util::substr(
             $block0,
             ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES
         );
-        $state->update($cBlock);
-        fwrite($ofp, $cBlock);
+        $state->update( $cBlock );
+        fwrite( $ofp, $cBlock );
         $mlen -= 32;
 
         /** @var int $iter */
@@ -907,15 +907,15 @@ 
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        fseek($ifp, $first32, SEEK_SET);
+        fseek( $ifp, $first32, SEEK_SET );
 
-        while ($mlen > 0) {
+        while ( $mlen > 0 ) {
             $blockSize = $mlen > self::BUFFER_SIZE
                 ? self::BUFFER_SIZE
                 : $mlen;
-            $plaintext = fread($ifp, $blockSize);
-            if (!is_string($plaintext)) {
-                throw new SodiumException('Could not read input file');
+            $plaintext = fread( $ifp, $blockSize );
+            if ( ! is_string( $plaintext ) ) {
+                throw new SodiumException( 'Could not read input file' );
             }
             $cBlock = ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
                 $plaintext,
@@ -923,29 +923,29 @@ 
                 $iter,
                 $subkey
             );
-            fwrite($ofp, $cBlock, $blockSize);
-            $state->update($cBlock);
+            fwrite( $ofp, $cBlock, $blockSize );
+            $state->update( $cBlock );
 
             $mlen -= $blockSize;
             $iter += $incr;
         }
         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;
         }
-        $end = self::ftell($ofp);
+        $end = self::ftell( $ofp );
 
         /*
          * Write the Poly1305 authentication tag that provides integrity
          * over the ciphertext (encrypt-then-MAC)
          */
-        fseek($ofp, $start, SEEK_SET);
-        fwrite($ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES);
-        fseek($ofp, $end, SEEK_SET);
-        unset($state);
+        fseek( $ofp, $start, SEEK_SET );
+        fwrite( $ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES );
+        fseek( $ofp, $end, SEEK_SET );
+        unset( $state );
 
         return true;
     }
@@ -962,49 +962,49 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_decrypt($ifp, $ofp, $mlen, $nonce, $key)
+    protected static function secretbox_decrypt( $ifp, $ofp, $mlen, $nonce, $key )
     {
-        if (PHP_INT_SIZE === 4) {
-            return self::secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
+        if ( PHP_INT_SIZE === 4 ) {
+            return self::secretbox_decrypt_core32( $ifp, $ofp, $mlen, $nonce, $key );
         }
-        $tag = fread($ifp, 16);
-        if (!is_string($tag)) {
-            throw new SodiumException('Could not read input file');
+        $tag = fread( $ifp, 16 );
+        if ( ! is_string( $tag ) ) {
+            throw new SodiumException( 'Could not read input file' );
         }
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core_HSalsa20::hsalsa20( $nonce, $key );
 
         /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8);
+        $realNonce = ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 );
 
         /** @var string $block0 */
         $block0 = ParagonIE_Sodium_Core_Salsa20::salsa20(
             64,
-            ParagonIE_Sodium_Core_Util::substr($nonce, 16, 8),
+            ParagonIE_Sodium_Core_Util::substr( $nonce, 16, 8 ),
             $subkey
         );
 
         /* Verify the Poly1305 MAC -before- attempting to decrypt! */
-        $state = new ParagonIE_Sodium_Core_Poly1305_State(self::substr($block0, 0, 32));
-        if (!self::onetimeauth_verify($state, $ifp, $tag, $mlen)) {
-            throw new SodiumException('Invalid MAC');
+        $state = new ParagonIE_Sodium_Core_Poly1305_State( self::substr( $block0, 0, 32 ) );
+        if ( ! self::onetimeauth_verify( $state, $ifp, $tag, $mlen ) ) {
+            throw new SodiumException( 'Invalid MAC' );
         }
 
         /*
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        $first32 = fread($ifp, 32);
-        if (!is_string($first32)) {
-            throw new SodiumException('Could not read input file');
+        $first32 = fread( $ifp, 32 );
+        if ( ! is_string( $first32 ) ) {
+            throw new SodiumException( 'Could not read input file' );
         }
-        $first32len = self::strlen($first32);
+        $first32len = self::strlen( $first32 );
         fwrite(
             $ofp,
             self::xorStrings(
-                self::substr($block0, 32, $first32len),
-                self::substr($first32, 0, $first32len)
+                self::substr( $block0, 32, $first32len ),
+                self::substr( $first32, 0, $first32len )
             )
         );
         $mlen -= 32;
@@ -1016,13 +1016,13 @@ 
         $incr = self::BUFFER_SIZE >> 6;
 
         /* Decrypts ciphertext, writes to output file. */
-        while ($mlen > 0) {
+        while ( $mlen > 0 ) {
             $blockSize = $mlen > self::BUFFER_SIZE
                 ? self::BUFFER_SIZE
                 : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
+            $ciphertext = fread( $ifp, $blockSize );
+            if ( ! is_string( $ciphertext ) ) {
+                throw new SodiumException( 'Could not read input file' );
             }
             $pBlock = ParagonIE_Sodium_Core_Salsa20::salsa20_xor_ic(
                 $ciphertext,
@@ -1030,7 +1030,7 @@ 
                 $iter,
                 $subkey
             );
-            fwrite($ofp, $pBlock, $blockSize);
+            fwrite( $ofp, $pBlock, $blockSize );
             $mlen -= $blockSize;
             $iter += $incr;
         }
@@ -1053,7 +1053,7 @@ 
         $mlen = 0
     ) {
         /** @var int $pos */
-        $pos = self::ftell($ifp);
+        $pos = self::ftell( $ifp );
 
         /** @var int $iter */
         $iter = 1;
@@ -1061,21 +1061,21 @@ 
         /** @var int $incr */
         $incr = self::BUFFER_SIZE >> 6;
 
-        while ($mlen > 0) {
+        while ( $mlen > 0 ) {
             $blockSize = $mlen > self::BUFFER_SIZE
                 ? self::BUFFER_SIZE
                 : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
+            $ciphertext = fread( $ifp, $blockSize );
+            if ( ! is_string( $ciphertext ) ) {
+                throw new SodiumException( 'Could not read input file' );
             }
-            $state->update($ciphertext);
+            $state->update( $ciphertext );
             $mlen -= $blockSize;
             $iter += $incr;
         }
-        $res = ParagonIE_Sodium_Core_Util::verify_16($tag, $state->finish());
+        $res = ParagonIE_Sodium_Core_Util::verify_16( $tag, $state->finish() );
 
-        fseek($ifp, $pos, SEEK_SET);
+        fseek( $ifp, $pos, SEEK_SET );
         return $res;
     }
 
@@ -1095,48 +1095,48 @@ 
      * @psalm-suppress TypeCoercion
      *                 Ditto.
      */
-    public static function updateHashWithFile($hash, $fp, $size = 0)
+    public static function updateHashWithFile( $hash, $fp, $size = 0 )
     {
         /* Type checks: */
-        if (PHP_VERSION_ID < 70200) {
-            if (!is_resource($hash)) {
-                throw new TypeError('Argument 1 must be a resource, ' . gettype($hash) . ' given.');
+        if ( PHP_VERSION_ID < 70200 ) {
+            if ( ! is_resource( $hash ) ) {
+                throw new TypeError( 'Argument 1 must be a resource, ' . gettype( $hash ) . ' given.' );
             }
         } else {
-            if (!is_object($hash)) {
-                throw new TypeError('Argument 1 must be an object (PHP 7.2+), ' . gettype($hash) . ' given.');
+            if ( ! is_object( $hash ) ) {
+                throw new TypeError( 'Argument 1 must be an object (PHP 7.2+), ' . gettype( $hash ) . ' given.' );
             }
         }
 
-        if (!is_resource($fp)) {
-            throw new TypeError('Argument 2 must be a resource, ' . gettype($fp) . ' given.');
+        if ( ! is_resource( $fp ) ) {
+            throw new TypeError( 'Argument 2 must be a resource, ' . gettype( $fp ) . ' given.' );
         }
-        if (!is_int($size)) {
-            throw new TypeError('Argument 3 must be an integer, ' . gettype($size) . ' given.');
+        if ( ! is_int( $size ) ) {
+            throw new TypeError( 'Argument 3 must be an integer, ' . gettype( $size ) . ' given.' );
         }
 
         /** @var int $originalPosition */
-        $originalPosition = self::ftell($fp);
+        $originalPosition = self::ftell( $fp );
 
         // Move file pointer to beginning of file
-        fseek($fp, 0, SEEK_SET);
-        for ($i = 0; $i < $size; $i += self::BUFFER_SIZE) {
+        fseek( $fp, 0, SEEK_SET );
+        for ( $i = 0; $i < $size; $i += self::BUFFER_SIZE ) {
             /** @var string|bool $message */
             $message = fread(
                 $fp,
-                ($size - $i) > self::BUFFER_SIZE
+                ( $size - $i ) > self::BUFFER_SIZE
                     ? $size - $i
                     : self::BUFFER_SIZE
             );
-            if (!is_string($message)) {
-                throw new SodiumException('Unexpected error reading from file.');
+            if ( ! is_string( $message ) ) {
+                throw new SodiumException( 'Unexpected error reading from file.' );
             }
             /** @var string $message */
             /** @psalm-suppress InvalidArgument */
-            self::hash_update($hash, $message);
+            self::hash_update( $hash, $message );
         }
         // Reset file pointer's position
-        fseek($fp, $originalPosition, SEEK_SET);
+        fseek( $fp, $originalPosition, SEEK_SET );
         return $hash;
     }
 
@@ -1152,71 +1152,71 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    private static function sign_core32($filePath, $secretKey)
+    private static function sign_core32( $filePath, $secretKey )
     {
         /** @var int|bool $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $filePath );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
         /** @var int $size */
 
         /** @var resource|bool $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $fp = fopen( $filePath, 'rb' );
+        if ( ! is_resource( $fp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
         /** @var resource $fp */
 
         /** @var string $az */
-        $az = hash('sha512', self::substr($secretKey, 0, 32), true);
+        $az = hash( 'sha512', self::substr( $secretKey, 0, 32 ), true );
 
-        $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 );
 
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($az, 32, 32));
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $az, 32, 32 ) );
         /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
+        $hs = self::updateHashWithFile( $hs, $fp, $size );
 
         /** @var string $nonceHash */
-        $nonceHash = hash_final($hs, true);
+        $nonceHash = hash_final( $hs, true );
 
         /** @var string $pk */
-        $pk = self::substr($secretKey, 32, 32);
+        $pk = self::substr( $secretKey, 32, 32 );
 
         /** @var string $nonce */
-        $nonce = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($nonceHash) . self::substr($nonceHash, 32);
+        $nonce = ParagonIE_Sodium_Core32_Ed25519::sc_reduce( $nonceHash ) . self::substr( $nonceHash, 32 );
 
         /** @var string $sig */
         $sig = ParagonIE_Sodium_Core32_Ed25519::ge_p3_tobytes(
-            ParagonIE_Sodium_Core32_Ed25519::ge_scalarmult_base($nonce)
+            ParagonIE_Sodium_Core32_Ed25519::ge_scalarmult_base( $nonce )
         );
 
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($pk, 0, 32));
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $sig, 0, 32 ) );
+        self::hash_update( $hs, self::substr( $pk, 0, 32 ) );
         /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
+        $hs = self::updateHashWithFile( $hs, $fp, $size );
 
         /** @var string $hramHash */
-        $hramHash = hash_final($hs, true);
+        $hramHash = hash_final( $hs, true );
 
         /** @var string $hram */
-        $hram = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($hramHash);
+        $hram = ParagonIE_Sodium_Core32_Ed25519::sc_reduce( $hramHash );
 
         /** @var string $sigAfter */
-        $sigAfter = ParagonIE_Sodium_Core32_Ed25519::sc_muladd($hram, $az, $nonce);
+        $sigAfter = ParagonIE_Sodium_Core32_Ed25519::sc_muladd( $hram, $az, $nonce );
 
         /** @var string $sig */
-        $sig = self::substr($sig, 0, 32) . self::substr($sigAfter, 0, 32);
+        $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;
         }
-        fclose($fp);
+        fclose( $fp );
         return $sig;
     }
 
@@ -1234,37 +1234,37 @@ 
      * @throws SodiumException
      * @throws Exception
      */
-    public static function verify_core32($sig, $filePath, $publicKey)
+    public static function verify_core32( $sig, $filePath, $publicKey )
     {
         /* Security checks */
-        if (ParagonIE_Sodium_Core32_Ed25519::check_S_lt_L(self::substr($sig, 32, 32))) {
-            throw new SodiumException('S < L - Invalid signature');
+        if ( ParagonIE_Sodium_Core32_Ed25519::check_S_lt_L( self::substr( $sig, 32, 32 ) ) ) {
+            throw new SodiumException( 'S < L - Invalid signature' );
         }
-        if (ParagonIE_Sodium_Core32_Ed25519::small_order($sig)) {
-            throw new SodiumException('Signature is on too small of an order');
+        if ( ParagonIE_Sodium_Core32_Ed25519::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($publicKey[$i]);
+        for ( $i = 0; $i < 32; ++$i ) {
+            $d |= self::chrToInt( $publicKey[ $i ] );
         }
-        if ($d === 0) {
-            throw new SodiumException('All zero public key');
+        if ( $d === 0 ) {
+            throw new SodiumException( 'All zero public key' );
         }
 
         /** @var int|bool $size */
-        $size = filesize($filePath);
-        if (!is_int($size)) {
-            throw new SodiumException('Could not obtain the file size');
+        $size = filesize( $filePath );
+        if ( ! is_int( $size ) ) {
+            throw new SodiumException( 'Could not obtain the file size' );
         }
         /** @var int $size */
 
         /** @var resource|bool $fp */
-        $fp = fopen($filePath, 'rb');
-        if (!is_resource($fp)) {
-            throw new SodiumException('Could not open input file for reading');
+        $fp = fopen( $filePath, 'rb' );
+        if ( ! is_resource( $fp ) ) {
+            throw new SodiumException( 'Could not open input file for reading' );
         }
         /** @var resource $fp */
 
@@ -1275,35 +1275,35 @@ 
         ParagonIE_Sodium_Compat::$fastMult = true;
 
         /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P3 $A */
-        $A = ParagonIE_Sodium_Core32_Ed25519::ge_frombytes_negate_vartime($publicKey);
+        $A = ParagonIE_Sodium_Core32_Ed25519::ge_frombytes_negate_vartime( $publicKey );
 
-        $hs = hash_init('sha512');
-        self::hash_update($hs, self::substr($sig, 0, 32));
-        self::hash_update($hs, self::substr($publicKey, 0, 32));
+        $hs = hash_init( 'sha512' );
+        self::hash_update( $hs, self::substr( $sig, 0, 32 ) );
+        self::hash_update( $hs, self::substr( $publicKey, 0, 32 ) );
         /** @var resource $hs */
-        $hs = self::updateHashWithFile($hs, $fp, $size);
+        $hs = self::updateHashWithFile( $hs, $fp, $size );
         /** @var string $hDigest */
-        $hDigest = hash_final($hs, true);
+        $hDigest = hash_final( $hs, true );
 
         /** @var string $h */
-        $h = ParagonIE_Sodium_Core32_Ed25519::sc_reduce($hDigest) . self::substr($hDigest, 32);
+        $h = ParagonIE_Sodium_Core32_Ed25519::sc_reduce( $hDigest ) . self::substr( $hDigest, 32 );
 
         /** @var ParagonIE_Sodium_Core32_Curve25519_Ge_P2 $R */
         $R = ParagonIE_Sodium_Core32_Ed25519::ge_double_scalarmult_vartime(
             $h,
             $A,
-            self::substr($sig, 32)
+            self::substr( $sig, 32 )
         );
 
         /** @var string $rcheck */
-        $rcheck = ParagonIE_Sodium_Core32_Ed25519::ge_tobytes($R);
+        $rcheck = ParagonIE_Sodium_Core32_Ed25519::ge_tobytes( $R );
 
         // Close the file handle
-        fclose($fp);
+        fclose( $fp );
 
         // 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 ) );
     }
 
     /**
@@ -1318,29 +1318,29 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
+    protected static function secretbox_encrypt_core32( $ifp, $ofp, $mlen, $nonce, $key )
     {
-        $plaintext = fread($ifp, 32);
-        if (!is_string($plaintext)) {
-            throw new SodiumException('Could not read input file');
+        $plaintext = fread( $ifp, 32 );
+        if ( ! is_string( $plaintext ) ) {
+            throw new SodiumException( 'Could not read input file' );
         }
-        $first32 = self::ftell($ifp);
+        $first32 = self::ftell( $ifp );
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20( $nonce, $key );
 
         /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
+        $realNonce = 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 */
         $mlen0 = $mlen;
-        if ($mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES) {
+        if ( $mlen0 > 64 - ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES ) {
             $mlen0 = 64 - ParagonIE_Sodium_Crypto::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(
@@ -1358,16 +1358,16 @@ 
         );
 
         // Pre-write 16 blank bytes for the Poly1305 tag
-        $start = self::ftell($ofp);
-        fwrite($ofp, str_repeat("\x00", 16));
+        $start = self::ftell( $ofp );
+        fwrite( $ofp, str_repeat( "\x00", 16 ) );
 
         /** @var string $c */
         $cBlock = ParagonIE_Sodium_Core32_Util::substr(
             $block0,
             ParagonIE_Sodium_Crypto::secretbox_xsalsa20poly1305_ZEROBYTES
         );
-        $state->update($cBlock);
-        fwrite($ofp, $cBlock);
+        $state->update( $cBlock );
+        fwrite( $ofp, $cBlock );
         $mlen -= 32;
 
         /** @var int $iter */
@@ -1380,15 +1380,15 @@ 
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        fseek($ifp, $first32, SEEK_SET);
+        fseek( $ifp, $first32, SEEK_SET );
 
-        while ($mlen > 0) {
+        while ( $mlen > 0 ) {
             $blockSize = $mlen > self::BUFFER_SIZE
                 ? self::BUFFER_SIZE
                 : $mlen;
-            $plaintext = fread($ifp, $blockSize);
-            if (!is_string($plaintext)) {
-                throw new SodiumException('Could not read input file');
+            $plaintext = fread( $ifp, $blockSize );
+            if ( ! is_string( $plaintext ) ) {
+                throw new SodiumException( 'Could not read input file' );
             }
             $cBlock = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
                 $plaintext,
@@ -1396,29 +1396,29 @@ 
                 $iter,
                 $subkey
             );
-            fwrite($ofp, $cBlock, $blockSize);
-            $state->update($cBlock);
+            fwrite( $ofp, $cBlock, $blockSize );
+            $state->update( $cBlock );
 
             $mlen -= $blockSize;
             $iter += $incr;
         }
         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;
         }
-        $end = self::ftell($ofp);
+        $end = self::ftell( $ofp );
 
         /*
          * Write the Poly1305 authentication tag that provides integrity
          * over the ciphertext (encrypt-then-MAC)
          */
-        fseek($ofp, $start, SEEK_SET);
-        fwrite($ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES);
-        fseek($ofp, $end, SEEK_SET);
-        unset($state);
+        fseek( $ofp, $start, SEEK_SET );
+        fwrite( $ofp, $state->finish(), ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES );
+        fseek( $ofp, $end, SEEK_SET );
+        unset( $state );
 
         return true;
     }
@@ -1435,46 +1435,46 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
+    protected static function secretbox_decrypt_core32( $ifp, $ofp, $mlen, $nonce, $key )
     {
-        $tag = fread($ifp, 16);
-        if (!is_string($tag)) {
-            throw new SodiumException('Could not read input file');
+        $tag = fread( $ifp, 16 );
+        if ( ! is_string( $tag ) ) {
+            throw new SodiumException( 'Could not read input file' );
         }
 
         /** @var string $subkey */
-        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20($nonce, $key);
+        $subkey = ParagonIE_Sodium_Core32_HSalsa20::hsalsa20( $nonce, $key );
 
         /** @var string $realNonce */
-        $realNonce = ParagonIE_Sodium_Core32_Util::substr($nonce, 16, 8);
+        $realNonce = ParagonIE_Sodium_Core32_Util::substr( $nonce, 16, 8 );
 
         /** @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
         );
 
         /* Verify the Poly1305 MAC -before- attempting to decrypt! */
-        $state = new ParagonIE_Sodium_Core32_Poly1305_State(self::substr($block0, 0, 32));
-        if (!self::onetimeauth_verify_core32($state, $ifp, $tag, $mlen)) {
-            throw new SodiumException('Invalid MAC');
+        $state = new ParagonIE_Sodium_Core32_Poly1305_State( self::substr( $block0, 0, 32 ) );
+        if ( ! self::onetimeauth_verify_core32( $state, $ifp, $tag, $mlen ) ) {
+            throw new SodiumException( 'Invalid MAC' );
         }
 
         /*
          * Set the cursor to the end of the first half-block. All future bytes will
          * generated from salsa20_xor_ic, starting from 1 (second block).
          */
-        $first32 = fread($ifp, 32);
-        if (!is_string($first32)) {
-            throw new SodiumException('Could not read input file');
+        $first32 = fread( $ifp, 32 );
+        if ( ! is_string( $first32 ) ) {
+            throw new SodiumException( 'Could not read input file' );
         }
-        $first32len = self::strlen($first32);
+        $first32len = self::strlen( $first32 );
         fwrite(
             $ofp,
             self::xorStrings(
-                self::substr($block0, 32, $first32len),
-                self::substr($first32, 0, $first32len)
+                self::substr( $block0, 32, $first32len ),
+                self::substr( $first32, 0, $first32len )
             )
         );
         $mlen -= 32;
@@ -1486,13 +1486,13 @@ 
         $incr = self::BUFFER_SIZE >> 6;
 
         /* Decrypts ciphertext, writes to output file. */
-        while ($mlen > 0) {
+        while ( $mlen > 0 ) {
             $blockSize = $mlen > self::BUFFER_SIZE
                 ? self::BUFFER_SIZE
                 : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
+            $ciphertext = fread( $ifp, $blockSize );
+            if ( ! is_string( $ciphertext ) ) {
+                throw new SodiumException( 'Could not read input file' );
             }
             $pBlock = ParagonIE_Sodium_Core32_Salsa20::salsa20_xor_ic(
                 $ciphertext,
@@ -1500,7 +1500,7 @@ 
                 $iter,
                 $subkey
             );
-            fwrite($ofp, $pBlock, $blockSize);
+            fwrite( $ofp, $pBlock, $blockSize );
             $mlen -= $blockSize;
             $iter += $incr;
         }
@@ -1525,22 +1525,22 @@ 
         $mlen = 0
     ) {
         /** @var int $pos */
-        $pos = self::ftell($ifp);
+        $pos = self::ftell( $ifp );
 
-        while ($mlen > 0) {
+        while ( $mlen > 0 ) {
             $blockSize = $mlen > self::BUFFER_SIZE
                 ? self::BUFFER_SIZE
                 : $mlen;
-            $ciphertext = fread($ifp, $blockSize);
-            if (!is_string($ciphertext)) {
-                throw new SodiumException('Could not read input file');
+            $ciphertext = fread( $ifp, $blockSize );
+            if ( ! is_string( $ciphertext ) ) {
+                throw new SodiumException( 'Could not read input file' );
             }
-            $state->update($ciphertext);
+            $state->update( $ciphertext );
             $mlen -= $blockSize;
         }
-        $res = ParagonIE_Sodium_Core32_Util::verify_16($tag, $state->finish());
+        $res = ParagonIE_Sodium_Core32_Util::verify_16( $tag, $state->finish() );
 
-        fseek($ifp, $pos, SEEK_SET);
+        fseek( $ifp, $pos, SEEK_SET );
         return $res;
     }
 
@@ -1549,12 +1549,12 @@ 
      * @return int
      * @throws SodiumException
      */
-    private static function ftell($resource)
+    private static function ftell( $resource )
     {
-        $return = ftell($resource);
-        if (!is_int($return)) {
-            throw new SodiumException('ftell() returned false');
+        $return = ftell( $resource );
+        if ( ! is_int( $return ) ) {
+            throw new SodiumException( 'ftell() returned false' );
         }
-        return (int) $return;
+        return (int)$return;
     }
 }

Braces +20 added lines, -40 removed lines

@@ -6,8 +6,7 @@ 
 /**
  * Class ParagonIE_Sodium_File
  */
-class ParagonIE_Sodium_File extends ParagonIE_Sodium_Core_Util
-{
+class ParagonIE_Sodium_File extends ParagonIE_Sodium_Core_Util {
     /* PHP's default buffer size is 8192 for fread()/fwrite(). */
     const BUFFER_SIZE = 8192;
 
@@ -25,8 +24,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box($inputFile, $outputFile, $nonce, $keyPair)
-    {
+    public static function box($inputFile, $outputFile, $nonce, $keyPair) {
         /* Type checks: */
         if (!is_string($inputFile)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
@@ -91,8 +89,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_open($inputFile, $outputFile, $nonce, $keypair)
-    {
+    public static function box_open($inputFile, $outputFile, $nonce, $keypair) {
         /* Type checks: */
         if (!is_string($inputFile)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
@@ -161,8 +158,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seal($inputFile, $outputFile, $publicKey)
-    {
+    public static function box_seal($inputFile, $outputFile, $publicKey) {
         /* Type checks: */
         if (!is_string($inputFile)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
@@ -265,8 +261,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function box_seal_open($inputFile, $outputFile, $ecdhKeypair)
-    {
+    public static function box_seal_open($inputFile, $outputFile, $ecdhKeypair) {
         /* Type checks: */
         if (!is_string($inputFile)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
@@ -350,8 +345,7 @@ 
      * @throws TypeError
      * @psalm-suppress FailedTypeResolution
      */
-    public static function generichash($filePath, $key = '', $outputLength = 32)
-    {
+    public static function generichash($filePath, $key = '', $outputLength = 32) {
         /* Type checks: */
         if (!is_string($filePath)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
@@ -428,8 +422,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox($inputFile, $outputFile, $nonce, $key)
-    {
+    public static function secretbox($inputFile, $outputFile, $nonce, $key) {
         /* Type checks: */
         if (!is_string($inputFile)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given..');
@@ -493,8 +486,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function secretbox_open($inputFile, $outputFile, $nonce, $key)
-    {
+    public static function secretbox_open($inputFile, $outputFile, $nonce, $key) {
         /* Type checks: */
         if (!is_string($inputFile)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($inputFile) . ' given.');
@@ -560,8 +552,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function sign($filePath, $secretKey)
-    {
+    public static function sign($filePath, $secretKey) {
         /* Type checks: */
         if (!is_string($filePath)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($filePath) . ' given.');
@@ -656,8 +647,7 @@ 
      * @throws TypeError
      * @throws Exception
      */
-    public static function verify($sig, $filePath, $publicKey)
-    {
+    public static function verify($sig, $filePath, $publicKey) {
         /* Type checks: */
         if (!is_string($sig)) {
             throw new TypeError('Argument 1 must be a string, ' . gettype($sig) . ' given.');
@@ -766,8 +756,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function box_encrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
-    {
+    protected static function box_encrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair) {
         if (PHP_INT_SIZE === 4) {
             return self::secretbox_encrypt(
                 $ifp,
@@ -803,8 +792,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function box_decrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair)
-    {
+    protected static function box_decrypt($ifp, $ofp, $mlen, $nonce, $boxKeypair) {
         if (PHP_INT_SIZE === 4) {
             return self::secretbox_decrypt(
                 $ifp,
@@ -841,8 +829,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_encrypt($ifp, $ofp, $mlen, $nonce, $key)
-    {
+    protected static function secretbox_encrypt($ifp, $ofp, $mlen, $nonce, $key) {
         if (PHP_INT_SIZE === 4) {
             return self::secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
         }
@@ -962,8 +949,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_decrypt($ifp, $ofp, $mlen, $nonce, $key)
-    {
+    protected static function secretbox_decrypt($ifp, $ofp, $mlen, $nonce, $key) {
         if (PHP_INT_SIZE === 4) {
             return self::secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key);
         }
@@ -1095,8 +1081,7 @@ 
      * @psalm-suppress TypeCoercion
      *                 Ditto.
      */
-    public static function updateHashWithFile($hash, $fp, $size = 0)
-    {
+    public static function updateHashWithFile($hash, $fp, $size = 0) {
         /* Type checks: */
         if (PHP_VERSION_ID < 70200) {
             if (!is_resource($hash)) {
@@ -1152,8 +1137,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    private static function sign_core32($filePath, $secretKey)
-    {
+    private static function sign_core32($filePath, $secretKey) {
         /** @var int|bool $size */
         $size = filesize($filePath);
         if (!is_int($size)) {
@@ -1234,8 +1218,7 @@ 
      * @throws SodiumException
      * @throws Exception
      */
-    public static function verify_core32($sig, $filePath, $publicKey)
-    {
+    public static function verify_core32($sig, $filePath, $publicKey) {
         /* Security checks */
         if (ParagonIE_Sodium_Core32_Ed25519::check_S_lt_L(self::substr($sig, 32, 32))) {
             throw new SodiumException('S < L - Invalid signature');
@@ -1318,8 +1301,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
-    {
+    protected static function secretbox_encrypt_core32($ifp, $ofp, $mlen, $nonce, $key) {
         $plaintext = fread($ifp, 32);
         if (!is_string($plaintext)) {
             throw new SodiumException('Could not read input file');
@@ -1435,8 +1417,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    protected static function secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key)
-    {
+    protected static function secretbox_decrypt_core32($ifp, $ofp, $mlen, $nonce, $key) {
         $tag = fread($ifp, 16);
         if (!is_string($tag)) {
             throw new SodiumException('Could not read input file');
@@ -1549,8 +1530,7 @@ 
      * @return int
      * @throws SodiumException
      */
-    private static function ftell($resource)
-    {
+    private static function ftell($resource) {
         $return = ftell($resource);
         if (!is_int($return)) {
             throw new SodiumException('ftell() returned false');

vendor/paragonie/sodium_compat/src/PHP52/SplFixedArray.php

Indentation +174 added lines, -174 removed lines

@@ -1,7 +1,7 @@ 
 <?php
 
 if (class_exists('SplFixedArray')) {
-    return;
+	return;
 }
 
 /**
@@ -13,177 +13,177 @@ 
  */
 class SplFixedArray implements Iterator, ArrayAccess, Countable
 {
-    /** @var array<int, mixed> */
-    private $internalArray = array();
-
-    /** @var int $size */
-    private $size = 0;
-
-    /**
-     * SplFixedArray constructor.
-     * @param int $size
-     */
-    public function __construct($size = 0)
-    {
-        $this->size = $size;
-        $this->internalArray = array();
-    }
-
-    /**
-     * @return int
-     */
-    public function count()
-    {
-        return count($this->internalArray);
-    }
-
-    /**
-     * @return array
-     */
-    public function toArray()
-    {
-        ksort($this->internalArray);
-        return (array) $this->internalArray;
-    }
-
-    /**
-     * @param array $array
-     * @param bool $save_indexes
-     * @return SplFixedArray
-     * @psalm-suppress MixedAssignment
-     */
-    public static function fromArray(array $array, $save_indexes = true)
-    {
-        $self = new SplFixedArray(count($array));
-        if($save_indexes) {
-            foreach($array as $key => $value) {
-                $self[(int) $key] = $value;
-            }
-        } else {
-            $i = 0;
-            foreach (array_values($array) as $value) {
-                $self[$i] = $value;
-                $i++;
-            }
-        }
-        return $self;
-    }
-
-    /**
-     * @return int
-     */
-    public function getSize()
-    {
-        return $this->size;
-    }
-
-    /**
-     * @param int $size
-     * @return bool
-     */
-    public function setSize($size)
-    {
-        $this->size = $size;
-        return true;
-    }
-
-    /**
-     * @param string|int $index
-     * @return bool
-     */
-    public function offsetExists($index)
-    {
-        return array_key_exists((int) $index, $this->internalArray);
-    }
-
-    /**
-     * @param string|int $index
-     * @return mixed
-     */
-    public function offsetGet($index)
-    {
-        /** @psalm-suppress MixedReturnStatement */
-        return $this->internalArray[(int) $index];
-    }
-
-    /**
-     * @param string|int $index
-     * @param mixed $newval
-     * @psalm-suppress MixedAssignment
-     */
-    public function offsetSet($index, $newval)
-    {
-        $this->internalArray[(int) $index] = $newval;
-    }
-
-    /**
-     * @param string|int $index
-     */
-    public function offsetUnset($index)
-    {
-        unset($this->internalArray[(int) $index]);
-    }
-
-    /**
-     * Rewind iterator back to the start
-     * @link https://php.net/manual/en/splfixedarray.rewind.php
-     * @return void
-     * @since 5.3.0
-     */
-    public function rewind()
-    {
-        reset($this->internalArray);
-    }
-
-    /**
-     * Return current array entry
-     * @link https://php.net/manual/en/splfixedarray.current.php
-     * @return mixed The current element value.
-     * @since 5.3.0
-     */
-    public function current()
-    {
-        /** @psalm-suppress MixedReturnStatement */
-        return current($this->internalArray);
-    }
-
-    /**
-     * Return current array index
-     * @return int The current array index.
-     */
-    public function key()
-    {
-        return key($this->internalArray);
-    }
-
-    /**
-     * @return void
-     */
-    public function next()
-    {
-        next($this->internalArray);
-    }
-
-    /**
-     * Check whether the array contains more elements
-     * @link https://php.net/manual/en/splfixedarray.valid.php
-     * @return bool true if the array contains any more elements, false otherwise.
-     */
-    public function valid()
-    {
-        if (empty($this->internalArray)) {
-            return false;
-        }
-        $result = next($this->internalArray) !== false;
-        prev($this->internalArray);
-        return $result;
-    }
-
-    /**
-     * Do nothing.
-     */
-    public function __wakeup()
-    {
-        // NOP
-    }
+	/** @var array<int, mixed> */
+	private $internalArray = array();
+
+	/** @var int $size */
+	private $size = 0;
+
+	/**
+	 * SplFixedArray constructor.
+	 * @param int $size
+	 */
+	public function __construct($size = 0)
+	{
+		$this->size = $size;
+		$this->internalArray = array();
+	}
+
+	/**
+	 * @return int
+	 */
+	public function count()
+	{
+		return count($this->internalArray);
+	}
+
+	/**
+	 * @return array
+	 */
+	public function toArray()
+	{
+		ksort($this->internalArray);
+		return (array) $this->internalArray;
+	}
+
+	/**
+	 * @param array $array
+	 * @param bool $save_indexes
+	 * @return SplFixedArray
+	 * @psalm-suppress MixedAssignment
+	 */
+	public static function fromArray(array $array, $save_indexes = true)
+	{
+		$self = new SplFixedArray(count($array));
+		if($save_indexes) {
+			foreach($array as $key => $value) {
+				$self[(int) $key] = $value;
+			}
+		} else {
+			$i = 0;
+			foreach (array_values($array) as $value) {
+				$self[$i] = $value;
+				$i++;
+			}
+		}
+		return $self;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getSize()
+	{
+		return $this->size;
+	}
+
+	/**
+	 * @param int $size
+	 * @return bool
+	 */
+	public function setSize($size)
+	{
+		$this->size = $size;
+		return true;
+	}
+
+	/**
+	 * @param string|int $index
+	 * @return bool
+	 */
+	public function offsetExists($index)
+	{
+		return array_key_exists((int) $index, $this->internalArray);
+	}
+
+	/**
+	 * @param string|int $index
+	 * @return mixed
+	 */
+	public function offsetGet($index)
+	{
+		/** @psalm-suppress MixedReturnStatement */
+		return $this->internalArray[(int) $index];
+	}
+
+	/**
+	 * @param string|int $index
+	 * @param mixed $newval
+	 * @psalm-suppress MixedAssignment
+	 */
+	public function offsetSet($index, $newval)
+	{
+		$this->internalArray[(int) $index] = $newval;
+	}
+
+	/**
+	 * @param string|int $index
+	 */
+	public function offsetUnset($index)
+	{
+		unset($this->internalArray[(int) $index]);
+	}
+
+	/**
+	 * Rewind iterator back to the start
+	 * @link https://php.net/manual/en/splfixedarray.rewind.php
+	 * @return void
+	 * @since 5.3.0
+	 */
+	public function rewind()
+	{
+		reset($this->internalArray);
+	}
+
+	/**
+	 * Return current array entry
+	 * @link https://php.net/manual/en/splfixedarray.current.php
+	 * @return mixed The current element value.
+	 * @since 5.3.0
+	 */
+	public function current()
+	{
+		/** @psalm-suppress MixedReturnStatement */
+		return current($this->internalArray);
+	}
+
+	/**
+	 * Return current array index
+	 * @return int The current array index.
+	 */
+	public function key()
+	{
+		return key($this->internalArray);
+	}
+
+	/**
+	 * @return void
+	 */
+	public function next()
+	{
+		next($this->internalArray);
+	}
+
+	/**
+	 * Check whether the array contains more elements
+	 * @link https://php.net/manual/en/splfixedarray.valid.php
+	 * @return bool true if the array contains any more elements, false otherwise.
+	 */
+	public function valid()
+	{
+		if (empty($this->internalArray)) {
+			return false;
+		}
+		$result = next($this->internalArray) !== false;
+		prev($this->internalArray);
+		return $result;
+	}
+
+	/**
+	 * Do nothing.
+	 */
+	public function __wakeup()
+	{
+		// NOP
+	}
 }
\ No newline at end of file

Spacing +28 added lines, -28 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-if (class_exists('SplFixedArray')) {
+if ( class_exists( 'SplFixedArray' ) ) {
     return;
 }
 
@@ -23,7 +23,7 @@ 
      * SplFixedArray constructor.
      * @param int $size
      */
-    public function __construct($size = 0)
+    public function __construct( $size = 0 )
     {
         $this->size = $size;
         $this->internalArray = array();
@@ -34,7 +34,7 @@ 
      */
     public function count()
     {
-        return count($this->internalArray);
+        return count( $this->internalArray );
     }
 
     /**
@@ -42,8 +42,8 @@ 
      */
     public function toArray()
     {
-        ksort($this->internalArray);
-        return (array) $this->internalArray;
+        ksort( $this->internalArray );
+        return (array)$this->internalArray;
     }
 
     /**
@@ -52,17 +52,17 @@ 
      * @return SplFixedArray
      * @psalm-suppress MixedAssignment
      */
-    public static function fromArray(array $array, $save_indexes = true)
+    public static function fromArray( array $array, $save_indexes = true )
     {
-        $self = new SplFixedArray(count($array));
-        if($save_indexes) {
-            foreach($array as $key => $value) {
-                $self[(int) $key] = $value;
+        $self = new SplFixedArray( count( $array ) );
+        if ( $save_indexes ) {
+            foreach ( $array as $key => $value ) {
+                $self[ (int)$key ] = $value;
             }
         } else {
             $i = 0;
-            foreach (array_values($array) as $value) {
-                $self[$i] = $value;
+            foreach ( array_values( $array ) as $value ) {
+                $self[ $i ] = $value;
                 $i++;
             }
         }
@@ -81,7 +81,7 @@ 
      * @param int $size
      * @return bool
      */
-    public function setSize($size)
+    public function setSize( $size )
     {
         $this->size = $size;
         return true;
@@ -91,19 +91,19 @@ 
      * @param string|int $index
      * @return bool
      */
-    public function offsetExists($index)
+    public function offsetExists( $index )
     {
-        return array_key_exists((int) $index, $this->internalArray);
+        return array_key_exists( (int)$index, $this->internalArray );
     }
 
     /**
      * @param string|int $index
      * @return mixed
      */
-    public function offsetGet($index)
+    public function offsetGet( $index )
     {
         /** @psalm-suppress MixedReturnStatement */
-        return $this->internalArray[(int) $index];
+        return $this->internalArray[ (int)$index ];
     }
 
     /**
@@ -111,17 +111,17 @@ 
      * @param mixed $newval
      * @psalm-suppress MixedAssignment
      */
-    public function offsetSet($index, $newval)
+    public function offsetSet( $index, $newval )
     {
-        $this->internalArray[(int) $index] = $newval;
+        $this->internalArray[ (int)$index ] = $newval;
     }
 
     /**
      * @param string|int $index
      */
-    public function offsetUnset($index)
+    public function offsetUnset( $index )
     {
-        unset($this->internalArray[(int) $index]);
+        unset( $this->internalArray[ (int)$index ] );
     }
 
     /**
@@ -132,7 +132,7 @@ 
      */
     public function rewind()
     {
-        reset($this->internalArray);
+        reset( $this->internalArray );
     }
 
     /**
@@ -144,7 +144,7 @@ 
     public function current()
     {
         /** @psalm-suppress MixedReturnStatement */
-        return current($this->internalArray);
+        return current( $this->internalArray );
     }
 
     /**
@@ -153,7 +153,7 @@ 
      */
     public function key()
     {
-        return key($this->internalArray);
+        return key( $this->internalArray );
     }
 
     /**
@@ -161,7 +161,7 @@ 
      */
     public function next()
     {
-        next($this->internalArray);
+        next( $this->internalArray );
     }
 
     /**
@@ -171,11 +171,11 @@ 
      */
     public function valid()
     {
-        if (empty($this->internalArray)) {
+        if ( empty( $this->internalArray ) ) {
             return false;
         }
-        $result = next($this->internalArray) !== false;
-        prev($this->internalArray);
+        $result = next( $this->internalArray ) !== false;
+        prev( $this->internalArray );
         return $result;
     }
 

Braces +16 added lines, -32 removed lines

@@ -23,8 +23,7 @@ 
      * SplFixedArray constructor.
      * @param int $size
      */
-    public function __construct($size = 0)
-    {
+    public function __construct($size = 0) {
         $this->size = $size;
         $this->internalArray = array();
     }
@@ -32,16 +31,14 @@ 
     /**
      * @return int
      */
-    public function count()
-    {
+    public function count() {
         return count($this->internalArray);
     }
 
     /**
      * @return array
      */
-    public function toArray()
-    {
+    public function toArray() {
         ksort($this->internalArray);
         return (array) $this->internalArray;
     }
@@ -52,8 +49,7 @@ 
      * @return SplFixedArray
      * @psalm-suppress MixedAssignment
      */
-    public static function fromArray(array $array, $save_indexes = true)
-    {
+    public static function fromArray(array $array, $save_indexes = true) {
         $self = new SplFixedArray(count($array));
         if($save_indexes) {
             foreach($array as $key => $value) {
@@ -72,8 +68,7 @@ 
     /**
      * @return int
      */
-    public function getSize()
-    {
+    public function getSize() {
         return $this->size;
     }
 
@@ -81,8 +76,7 @@ 
      * @param int $size
      * @return bool
      */
-    public function setSize($size)
-    {
+    public function setSize($size) {
         $this->size = $size;
         return true;
     }
@@ -91,8 +85,7 @@ 
      * @param string|int $index
      * @return bool
      */
-    public function offsetExists($index)
-    {
+    public function offsetExists($index) {
         return array_key_exists((int) $index, $this->internalArray);
     }
 
@@ -100,8 +93,7 @@ 
      * @param string|int $index
      * @return mixed
      */
-    public function offsetGet($index)
-    {
+    public function offsetGet($index) {
         /** @psalm-suppress MixedReturnStatement */
         return $this->internalArray[(int) $index];
     }
@@ -111,16 +103,14 @@ 
      * @param mixed $newval
      * @psalm-suppress MixedAssignment
      */
-    public function offsetSet($index, $newval)
-    {
+    public function offsetSet($index, $newval) {
         $this->internalArray[(int) $index] = $newval;
     }
 
     /**
      * @param string|int $index
      */
-    public function offsetUnset($index)
-    {
+    public function offsetUnset($index) {
         unset($this->internalArray[(int) $index]);
     }
 
@@ -130,8 +120,7 @@ 
      * @return void
      * @since 5.3.0
      */
-    public function rewind()
-    {
+    public function rewind() {
         reset($this->internalArray);
     }
 
@@ -141,8 +130,7 @@ 
      * @return mixed The current element value.
      * @since 5.3.0
      */
-    public function current()
-    {
+    public function current() {
         /** @psalm-suppress MixedReturnStatement */
         return current($this->internalArray);
     }
@@ -151,16 +139,14 @@ 
      * Return current array index
      * @return int The current array index.
      */
-    public function key()
-    {
+    public function key() {
         return key($this->internalArray);
     }
 
     /**
      * @return void
      */
-    public function next()
-    {
+    public function next() {
         next($this->internalArray);
     }
 
@@ -169,8 +155,7 @@ 
      * @link https://php.net/manual/en/splfixedarray.valid.php
      * @return bool true if the array contains any more elements, false otherwise.
      */
-    public function valid()
-    {
+    public function valid() {
         if (empty($this->internalArray)) {
             return false;
         }
@@ -182,8 +167,7 @@ 
     /**
      * Do nothing.
      */
-    public function __wakeup()
-    {
+    public function __wakeup() {
         // NOP
     }
 }
\ No newline at end of file

vendor/paragonie/sodium_compat/src/Compat.php

Indentation +3914 added lines, -3914 removed lines

@@ -22,3926 +22,3926 @@
  */
 
 if (class_exists('ParagonIE_Sodium_Compat', false)) {
-    return;
+	return;
 }
 
 class ParagonIE_Sodium_Compat
 {
-    /**
-     * This parameter prevents the use of the PECL extension.
-     * It should only be used for unit testing.
-     *
-     * @var bool
-     */
-    public static $disableFallbackForUnitTests = false;
-
-    /**
-     * Use fast multiplication rather than our constant-time multiplication
-     * implementation. Can be enabled at runtime. Only enable this if you
-     * are absolutely certain that there is no timing leak on your platform.
-     *
-     * @var bool
-     */
-    public static $fastMult = false;
-
-    const LIBRARY_MAJOR_VERSION = 9;
-    const LIBRARY_MINOR_VERSION = 1;
-    const LIBRARY_VERSION_MAJOR = 9;
-    const LIBRARY_VERSION_MINOR = 1;
-    const VERSION_STRING = 'polyfill-1.0.8';
-
-    // From libsodium
-    const BASE64_VARIANT_ORIGINAL = 1;
-    const BASE64_VARIANT_ORIGINAL_NO_PADDING = 3;
-    const BASE64_VARIANT_URLSAFE = 5;
-    const BASE64_VARIANT_URLSAFE_NO_PADDING = 7;
-    const CRYPTO_AEAD_AES256GCM_KEYBYTES = 32;
-    const CRYPTO_AEAD_AES256GCM_NSECBYTES = 0;
-    const CRYPTO_AEAD_AES256GCM_NPUBBYTES = 12;
-    const CRYPTO_AEAD_AES256GCM_ABYTES = 16;
-    const CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES = 32;
-    const CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES = 0;
-    const CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES = 8;
-    const CRYPTO_AEAD_CHACHA20POLY1305_ABYTES = 16;
-    const CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES = 32;
-    const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES = 0;
-    const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES = 12;
-    const CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES = 16;
-    const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES = 32;
-    const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES = 0;
-    const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES = 24;
-    const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES = 16;
-    const CRYPTO_AUTH_BYTES = 32;
-    const CRYPTO_AUTH_KEYBYTES = 32;
-    const CRYPTO_BOX_SEALBYTES = 16;
-    const CRYPTO_BOX_SECRETKEYBYTES = 32;
-    const CRYPTO_BOX_PUBLICKEYBYTES = 32;
-    const CRYPTO_BOX_KEYPAIRBYTES = 64;
-    const CRYPTO_BOX_MACBYTES = 16;
-    const CRYPTO_BOX_NONCEBYTES = 24;
-    const CRYPTO_BOX_SEEDBYTES = 32;
-    const CRYPTO_CORE_RISTRETTO255_BYTES = 32;
-    const CRYPTO_CORE_RISTRETTO255_SCALARBYTES = 32;
-    const CRYPTO_CORE_RISTRETTO255_HASHBYTES = 64;
-    const CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES = 64;
-    const CRYPTO_KDF_BYTES_MIN = 16;
-    const CRYPTO_KDF_BYTES_MAX = 64;
-    const CRYPTO_KDF_CONTEXTBYTES = 8;
-    const CRYPTO_KDF_KEYBYTES = 32;
-    const CRYPTO_KX_BYTES = 32;
-    const CRYPTO_KX_PRIMITIVE = 'x25519blake2b';
-    const CRYPTO_KX_SEEDBYTES = 32;
-    const CRYPTO_KX_KEYPAIRBYTES = 64;
-    const CRYPTO_KX_PUBLICKEYBYTES = 32;
-    const CRYPTO_KX_SECRETKEYBYTES = 32;
-    const CRYPTO_KX_SESSIONKEYBYTES = 32;
-    const CRYPTO_GENERICHASH_BYTES = 32;
-    const CRYPTO_GENERICHASH_BYTES_MIN = 16;
-    const CRYPTO_GENERICHASH_BYTES_MAX = 64;
-    const CRYPTO_GENERICHASH_KEYBYTES = 32;
-    const CRYPTO_GENERICHASH_KEYBYTES_MIN = 16;
-    const CRYPTO_GENERICHASH_KEYBYTES_MAX = 64;
-    const CRYPTO_PWHASH_SALTBYTES = 16;
-    const CRYPTO_PWHASH_STRPREFIX = '$argon2id$';
-    const CRYPTO_PWHASH_ALG_ARGON2I13 = 1;
-    const CRYPTO_PWHASH_ALG_ARGON2ID13 = 2;
-    const CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE = 33554432;
-    const CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE = 4;
-    const CRYPTO_PWHASH_MEMLIMIT_MODERATE = 134217728;
-    const CRYPTO_PWHASH_OPSLIMIT_MODERATE = 6;
-    const CRYPTO_PWHASH_MEMLIMIT_SENSITIVE = 536870912;
-    const CRYPTO_PWHASH_OPSLIMIT_SENSITIVE = 8;
-    const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES = 32;
-    const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX = '$7$';
-    const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE = 534288;
-    const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE = 16777216;
-    const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE = 33554432;
-    const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE = 1073741824;
-    const CRYPTO_SCALARMULT_BYTES = 32;
-    const CRYPTO_SCALARMULT_SCALARBYTES = 32;
-    const CRYPTO_SCALARMULT_RISTRETTO255_BYTES = 32;
-    const CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES = 32;
-    const CRYPTO_SHORTHASH_BYTES = 8;
-    const CRYPTO_SHORTHASH_KEYBYTES = 16;
-    const CRYPTO_SECRETBOX_KEYBYTES = 32;
-    const CRYPTO_SECRETBOX_MACBYTES = 16;
-    const CRYPTO_SECRETBOX_NONCEBYTES = 24;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES = 17;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES = 24;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES = 32;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH = 0;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL = 1;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY = 2;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL = 3;
-    const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX = 0x3fffffff80;
-    const CRYPTO_SIGN_BYTES = 64;
-    const CRYPTO_SIGN_SEEDBYTES = 32;
-    const CRYPTO_SIGN_PUBLICKEYBYTES = 32;
-    const CRYPTO_SIGN_SECRETKEYBYTES = 64;
-    const CRYPTO_SIGN_KEYPAIRBYTES = 96;
-    const CRYPTO_STREAM_KEYBYTES = 32;
-    const CRYPTO_STREAM_NONCEBYTES = 24;
-    const CRYPTO_STREAM_XCHACHA20_KEYBYTES = 32;
-    const CRYPTO_STREAM_XCHACHA20_NONCEBYTES = 24;
-
-    /**
-     * Add two numbers (little-endian unsigned), storing the value in the first
-     * parameter.
-     *
-     * This mutates $val.
-     *
-     * @param string $val
-     * @param string $addv
-     * @return void
-     * @throws SodiumException
-     */
-    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');
-        }
-        $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);
-            $c >>= 8;
-        }
-        $val = ParagonIE_Sodium_Core_Util::intArrayToString($A);
-    }
-
-    /**
-     * @param string $encoded
-     * @param int $variant
-     * @param string $ignore
-     * @return string
-     * @throws SodiumException
-     */
-    public static function base642bin($encoded, $variant, $ignore = '')
-    {
-        /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($encoded, 'string', 1);
-
-        /** @var string $encoded */
-        $encoded = (string) $encoded;
-        if (ParagonIE_Sodium_Core_Util::strlen($encoded) === 0) {
-            return '';
-        }
-
-        // Just strip before decoding
-        if (!empty($ignore)) {
-            $encoded = str_replace($ignore, '', $encoded);
-        }
-
-        try {
-            switch ($variant) {
-                case self::BASE64_VARIANT_ORIGINAL:
-                    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);
-                case self::BASE64_VARIANT_URLSAFE:
-                    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);
-                default:
-                    throw new SodiumException('invalid base64 variant identifier');
-            }
-        } catch (Exception $ex) {
-            if ($ex instanceof SodiumException) {
-                throw $ex;
-            }
-            throw new SodiumException('invalid base64 string');
-        }
-    }
-
-    /**
-     * @param string $decoded
-     * @param int $variant
-     * @return string
-     * @throws SodiumException
-     */
-    public static function bin2base64($decoded, $variant)
-    {
-        /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($decoded, 'string', 1);
-        /** @var string $decoded */
-        $decoded = (string) $decoded;
-        if (ParagonIE_Sodium_Core_Util::strlen($decoded) === 0) {
-            return '';
-        }
-
-        switch ($variant) {
-            case self::BASE64_VARIANT_ORIGINAL:
-                return ParagonIE_Sodium_Core_Base64_Original::encode($decoded);
-            case self::BASE64_VARIANT_ORIGINAL_NO_PADDING:
-                return ParagonIE_Sodium_Core_Base64_Original::encodeUnpadded($decoded);
-            case self::BASE64_VARIANT_URLSAFE:
-                return ParagonIE_Sodium_Core_Base64_UrlSafe::encode($decoded);
-            case self::BASE64_VARIANT_URLSAFE_NO_PADDING:
-                return ParagonIE_Sodium_Core_Base64_UrlSafe::encodeUnpadded($decoded);
-            default:
-                throw new SodiumException('invalid base64 variant identifier');
-        }
-    }
-
-    /**
-     * Cache-timing-safe implementation of bin2hex().
-     *
-     * @param string $string A string (probably raw binary)
-     * @return string        A hexadecimal-encoded string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function bin2hex($string)
-    {
-        /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
-
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_bin2hex($string);
-        }
-        if (self::use_fallback('bin2hex')) {
-            return (string) call_user_func('\\Sodium\\bin2hex', $string);
-        }
-        return ParagonIE_Sodium_Core_Util::bin2hex($string);
-    }
-
-    /**
-     * Compare two strings, in constant-time.
-     * Compared to memcmp(), compare() is more useful for sorting.
-     *
-     * @param string $left  The left operand; must be a string
-     * @param string $right The right operand; must be a string
-     * @return int          If < 0 if the left operand is less than the right
-     *                      If = 0 if both strings are equal
-     *                      If > 0 if the right operand is less than the left
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function compare($left, $right)
-    {
-        /* Type checks: */
-        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::use_fallback('compare')) {
-            return (int) call_user_func('\\Sodium\\compare', $left, $right);
-        }
-        return ParagonIE_Sodium_Core_Util::compare($left, $right);
-    }
-
-    /**
-     * Is AES-256-GCM even available to use?
-     *
-     * @return bool
-     * @psalm-suppress UndefinedFunction
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    public static function crypto_aead_aes256gcm_is_available()
-    {
-        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 (PHP_VERSION_ID < 70100) {
-            // OpenSSL doesn't support AEAD before 7.1.0
-            return false;
-        }
-        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());
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data: Decryption
-     *
-     * Algorithm:
-     *     AES-256-GCM
-     *
-     * This mode uses a 64-bit random nonce with a 64-bit counter.
-     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
-     *
-     * @param string $ciphertext Encrypted message (with Poly1305 MAC appended)
-     * @param string $assocData  Authenticated Associated Data (unencrypted)
-     * @param string $nonce      Number to be used only Once; must be 8 bytes
-     * @param string $key        Encryption key
-     *
-     * @return string|bool       The original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    public static function crypto_aead_aes256gcm_decrypt(
-        $ciphertext = '',
-        $assocData = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        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);
-
-        /* 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($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 (!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);
-        /** @var string $authTag */
-        $authTag = ParagonIE_Sodium_Core_Util::substr($ciphertext, -self::CRYPTO_AEAD_AES256GCM_ABYTES, 16);
-        return openssl_decrypt(
-            $ctext,
-            'aes-256-gcm',
-            $key,
-            OPENSSL_RAW_DATA,
-            $nonce,
-            $authTag,
-            $assocData
-        );
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data: Encryption
-     *
-     * Algorithm:
-     *     AES-256-GCM
-     *
-     * @param string $plaintext Message to be encrypted
-     * @param string $assocData Authenticated Associated Data (unencrypted)
-     * @param string $nonce     Number to be used only Once; must be 8 bytes
-     * @param string $key       Encryption key
-     *
-     * @return string           Ciphertext with a 16-byte GCM message
-     *                          authentication code appended
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_aead_aes256gcm_encrypt(
-        $plaintext = '',
-        $assocData = '',
-        $nonce = '',
-        $key = ''
-    ) {
-        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);
-
-        /* 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($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');
-        }
-
-        $authTag = '';
-        $ciphertext = openssl_encrypt(
-            $plaintext,
-            'aes-256-gcm',
-            $key,
-            OPENSSL_RAW_DATA,
-            $nonce,
-            $authTag,
-            $assocData
-        );
-        return $ciphertext . $authTag;
-    }
-
-    /**
-     * Return a secure random key for use with the AES-256-GCM
-     * symmetric AEAD interface.
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_aead_aes256gcm_keygen()
-    {
-        return random_bytes(self::CRYPTO_AEAD_AES256GCM_KEYBYTES);
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data: Decryption
-     *
-     * Algorithm:
-     *     ChaCha20-Poly1305
-     *
-     * This mode uses a 64-bit random nonce with a 64-bit counter.
-     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
-     *
-     * @param string $ciphertext Encrypted message (with Poly1305 MAC appended)
-     * @param string $assocData  Authenticated Associated Data (unencrypted)
-     * @param string $nonce      Number to be used only Once; must be 8 bytes
-     * @param string $key        Encryption key
-     *
-     * @return string            The original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    public static function crypto_aead_chacha20poly1305_decrypt(
-        $ciphertext = '',
-        $assocData = '',
-        $nonce = '',
-        $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);
-
-        /* 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($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 (self::useNewSodiumAPI()) {
-            /**
-             * @psalm-suppress InvalidReturnStatement
-             * @psalm-suppress FalsableReturnStatement
-             */
-            return sodium_crypto_aead_chacha20poly1305_decrypt(
-                $ciphertext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_decrypt')) {
-            return call_user_func(
-                '\\Sodium\\crypto_aead_chacha20poly1305_decrypt',
-                $ciphertext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_decrypt(
-                $ciphertext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_decrypt(
-            $ciphertext,
-            $assocData,
-            $nonce,
-            $key
-        );
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data
-     *
-     * Algorithm:
-     *     ChaCha20-Poly1305
-     *
-     * This mode uses a 64-bit random nonce with a 64-bit counter.
-     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
-     *
-     * @param string $plaintext Message to be encrypted
-     * @param string $assocData Authenticated Associated Data (unencrypted)
-     * @param string $nonce     Number to be used only Once; must be 8 bytes
-     * @param string $key       Encryption key
-     *
-     * @return string           Ciphertext with a 16-byte Poly1305 message
-     *                          authentication code appended
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_aead_chacha20poly1305_encrypt(
-        $plaintext = '',
-        $assocData = '',
-        $nonce = '',
-        $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);
-
-        /* 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($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(
-                $plaintext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_encrypt')) {
-            return (string) call_user_func(
-                '\\Sodium\\crypto_aead_chacha20poly1305_encrypt',
-                $plaintext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_encrypt(
-                $plaintext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_encrypt(
-            $plaintext,
-            $assocData,
-            $nonce,
-            $key
-        );
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data: Decryption
-     *
-     * Algorithm:
-     *     ChaCha20-Poly1305
-     *
-     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
-     * Regular mode uses a 64-bit random nonce with a 64-bit counter.
-     *
-     * @param string $ciphertext Encrypted message (with Poly1305 MAC appended)
-     * @param string $assocData  Authenticated Associated Data (unencrypted)
-     * @param string $nonce      Number to be used only Once; must be 12 bytes
-     * @param string $key        Encryption key
-     *
-     * @return string            The original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    public static function crypto_aead_chacha20poly1305_ietf_decrypt(
-        $ciphertext = '',
-        $assocData = '',
-        $nonce = '',
-        $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);
-
-        /* 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($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 (self::useNewSodiumAPI()) {
-            /**
-             * @psalm-suppress InvalidReturnStatement
-             * @psalm-suppress FalsableReturnStatement
-             */
-            return sodium_crypto_aead_chacha20poly1305_ietf_decrypt(
-                $ciphertext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_ietf_decrypt')) {
-            return call_user_func(
-                '\\Sodium\\crypto_aead_chacha20poly1305_ietf_decrypt',
-                $ciphertext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_ietf_decrypt(
-                $ciphertext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_ietf_decrypt(
-            $ciphertext,
-            $assocData,
-            $nonce,
-            $key
-        );
-    }
-
-    /**
-     * Return a secure random key for use with the ChaCha20-Poly1305
-     * symmetric AEAD interface.
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_aead_chacha20poly1305_keygen()
-    {
-        return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES);
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data
-     *
-     * Algorithm:
-     *     ChaCha20-Poly1305
-     *
-     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
-     * Regular mode uses a 64-bit random nonce with a 64-bit counter.
-     *
-     * @param string $plaintext Message to be encrypted
-     * @param string $assocData Authenticated Associated Data (unencrypted)
-     * @param string $nonce Number to be used only Once; must be 8 bytes
-     * @param string $key Encryption key
-     *
-     * @return string           Ciphertext with a 16-byte Poly1305 message
-     *                          authentication code appended
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_aead_chacha20poly1305_ietf_encrypt(
-        $plaintext = '',
-        $assocData = '',
-        $nonce = '',
-        $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($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($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(
-                $plaintext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (self::use_fallback('crypto_aead_chacha20poly1305_ietf_encrypt')) {
-            return (string) call_user_func(
-                '\\Sodium\\crypto_aead_chacha20poly1305_ietf_encrypt',
-                $plaintext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_ietf_encrypt(
-                $plaintext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_ietf_encrypt(
-            $plaintext,
-            $assocData,
-            $nonce,
-            $key
-        );
-    }
-
-    /**
-     * Return a secure random key for use with the ChaCha20-Poly1305
-     * symmetric AEAD interface. (IETF version)
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_aead_chacha20poly1305_ietf_keygen()
-    {
-        return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES);
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data: Decryption
-     *
-     * Algorithm:
-     *     XChaCha20-Poly1305
-     *
-     * This mode uses a 64-bit random nonce with a 64-bit counter.
-     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
-     *
-     * @param string $ciphertext   Encrypted message (with Poly1305 MAC appended)
-     * @param string $assocData    Authenticated Associated Data (unencrypted)
-     * @param string $nonce        Number to be used only Once; must be 8 bytes
-     * @param string $key          Encryption key
-     * @param bool   $dontFallback Don't fallback to ext/sodium
-     *
-     * @return string|bool         The original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_aead_xchacha20poly1305_ietf_decrypt(
-        $ciphertext = '',
-        $assocData = '',
-        $nonce = '',
-        $key = '',
-        $dontFallback = false
-    ) {
-        /* Type checks: */
-        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);
-
-        /* 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($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 (self::useNewSodiumAPI() && !$dontFallback) {
-            if (is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
-                return sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(
-                    $ciphertext,
-                    $assocData,
-                    $nonce,
-                    $key
-                );
-            }
-        }
-
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_decrypt(
-                $ciphertext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        return ParagonIE_Sodium_Crypto::aead_xchacha20poly1305_ietf_decrypt(
-            $ciphertext,
-            $assocData,
-            $nonce,
-            $key
-        );
-    }
-
-    /**
-     * Authenticated Encryption with Associated Data
-     *
-     * Algorithm:
-     *     XChaCha20-Poly1305
-     *
-     * This mode uses a 64-bit random nonce with a 64-bit counter.
-     * IETF mode uses a 96-bit random nonce with a 32-bit counter.
-     *
-     * @param string $plaintext    Message to be encrypted
-     * @param string $assocData    Authenticated Associated Data (unencrypted)
-     * @param string $nonce        Number to be used only Once; must be 8 bytes
-     * @param string $key          Encryption key
-     * @param bool   $dontFallback Don't fallback to ext/sodium
-     *
-     * @return string           Ciphertext with a 16-byte Poly1305 message
-     *                          authentication code appended
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_aead_xchacha20poly1305_ietf_encrypt(
-        $plaintext = '',
-        $assocData = '',
-        $nonce = '',
-        $key = '',
-        $dontFallback = false
-    ) {
-        /* Type checks: */
-        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);
-
-        /* 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($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')) {
-                return sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
-                    $plaintext,
-                    $assocData,
-                    $nonce,
-                    $key
-                );
-            }
-        }
-
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_encrypt(
-                $plaintext,
-                $assocData,
-                $nonce,
-                $key
-            );
-        }
-        return ParagonIE_Sodium_Crypto::aead_xchacha20poly1305_ietf_encrypt(
-            $plaintext,
-            $assocData,
-            $nonce,
-            $key
-        );
-    }
-
-    /**
-     * Return a secure random key for use with the XChaCha20-Poly1305
-     * symmetric AEAD interface.
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_aead_xchacha20poly1305_ietf_keygen()
-    {
-        return random_bytes(self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES);
-    }
-
-    /**
-     * Authenticate a message. Uses symmetric-key cryptography.
-     *
-     * Algorithm:
-     *     HMAC-SHA512-256. Which is HMAC-SHA-512 truncated to 256 bits.
-     *     Not to be confused with HMAC-SHA-512/256 which would use the
-     *     SHA-512/256 hash function (uses different initial parameters
-     *     but still truncates to 256 bits to sidestep length-extension
-     *     attacks).
-     *
-     * @param string $message Message to be authenticated
-     * @param string $key Symmetric authentication key
-     * @return string         Message authentication code
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::auth($message, $key);
-        }
-        return ParagonIE_Sodium_Crypto::auth($message, $key);
-    }
-
-    /**
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_auth_keygen()
-    {
-        return random_bytes(self::CRYPTO_AUTH_KEYBYTES);
-    }
-
-    /**
-     * Verify the MAC of a message previously authenticated with crypto_auth.
-     *
-     * @param string $mac Message authentication code
-     * @param string $message Message whose authenticity you are attempting to
-     *                        verify (with a given MAC and key)
-     * @param string $key Symmetric authentication key
-     * @return bool           TRUE if authenticated, FALSE otherwise
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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);
-        }
-        return ParagonIE_Sodium_Crypto::auth_verify($mac, $message, $key);
-    }
-
-    /**
-     * Authenticated asymmetric-key encryption. Both the sender and recipient
-     * may decrypt messages.
-     *
-     * Algorithm: X25519-XSalsa20-Poly1305.
-     *     X25519: Elliptic-Curve Diffie Hellman over Curve25519.
-     *     XSalsa20: Extended-nonce variant of salsa20.
-     *     Poyl1305: Polynomial MAC for one-time message authentication.
-     *
-     * @param string $plaintext The message to be encrypted
-     * @param string $nonce A Number to only be used Once; must be 24 bytes
-     * @param string $keypair Your secret key and your recipient's public key
-     * @return string           Ciphertext with 16-byte Poly1305 MAC
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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);
-        }
-        return ParagonIE_Sodium_Crypto::box($plaintext, $nonce, $keypair);
-    }
-
-    /**
-     * Anonymous public-key encryption. Only the recipient may decrypt messages.
-     *
-     * Algorithm: X25519-XSalsa20-Poly1305, as with crypto_box.
-     *     The sender's X25519 keypair is ephemeral.
-     *     Nonce is generated from the BLAKE2b hash of both public keys.
-     *
-     * This provides ciphertext integrity.
-     *
-     * @param string $plaintext Message to be sealed
-     * @param string $publicKey Your recipient's public key
-     * @return string           Sealed message that only your recipient can
-     *                          decrypt
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_seal($plaintext, $publicKey);
-        }
-        return ParagonIE_Sodium_Crypto::box_seal($plaintext, $publicKey);
-    }
-
-    /**
-     * Opens a message encrypted with crypto_box_seal(). Requires
-     * the recipient's keypair (sk || pk) to decrypt successfully.
-     *
-     * This validates ciphertext integrity.
-     *
-     * @param string $ciphertext Sealed message to be opened
-     * @param string $keypair    Your crypto_box keypair
-     * @return string            The original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    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);
-
-        /* 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 (self::useNewSodiumAPI()) {
-            /**
-             * @psalm-suppress InvalidReturnStatement
-             * @psalm-suppress FalsableReturnStatement
-             */
-            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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_seal_open($ciphertext, $keypair);
-        }
-        return ParagonIE_Sodium_Crypto::box_seal_open($ciphertext, $keypair);
-    }
-
-    /**
-     * Generate a new random X25519 keypair.
-     *
-     * @return string A 64-byte string; the first 32 are your secret key, while
-     *                the last 32 are your public key. crypto_box_secretkey()
-     *                and crypto_box_publickey() exist to separate them so you
-     *                don't accidentally get them mixed up!
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function 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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_keypair();
-        }
-        return ParagonIE_Sodium_Crypto::box_keypair();
-    }
-
-    /**
-     * Combine two keys into a keypair for use in library methods that expect
-     * a keypair. This doesn't necessarily have to be the same person's keys.
-     *
-     * @param string $secretKey Secret key
-     * @param string $publicKey Public key
-     * @return string    Keypair
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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);
-        }
-        return ParagonIE_Sodium_Crypto::box_keypair_from_secretkey_and_publickey($secretKey, $publicKey);
-    }
-
-    /**
-     * Decrypt a message previously encrypted with crypto_box().
-     *
-     * @param string $ciphertext Encrypted message
-     * @param string $nonce      Number to only be used Once; must be 24 bytes
-     * @param string $keypair    Your secret key and the sender's public key
-     * @return string            The original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    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);
-
-        /* 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($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 (self::useNewSodiumAPI()) {
-            /**
-             * @psalm-suppress InvalidReturnStatement
-             * @psalm-suppress FalsableReturnStatement
-             */
-            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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_open($ciphertext, $nonce, $keypair);
-        }
-        return ParagonIE_Sodium_Crypto::box_open($ciphertext, $nonce, $keypair);
-    }
-
-    /**
-     * Extract the public key from a crypto_box keypair.
-     *
-     * @param string $keypair Keypair containing secret and public key
-     * @return string         Your crypto_box public key
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_box_publickey($keypair)
-    {
-        /* Type checks: */
-        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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_publickey($keypair);
-        }
-        return ParagonIE_Sodium_Crypto::box_publickey($keypair);
-    }
-
-    /**
-     * Calculate the X25519 public key from a given X25519 secret key.
-     *
-     * @param string $secretKey Any X25519 secret key
-     * @return string           The corresponding X25519 public key
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_box_publickey_from_secretkey($secretKey)
-    {
-        /* Type checks: */
-        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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_publickey_from_secretkey($secretKey);
-        }
-        return ParagonIE_Sodium_Crypto::box_publickey_from_secretkey($secretKey);
-    }
-
-    /**
-     * Extract the secret key from a crypto_box keypair.
-     *
-     * @param string $keypair
-     * @return string         Your crypto_box secret key
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_box_secretkey($keypair)
-    {
-        /* Type checks: */
-        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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_secretkey($keypair);
-        }
-        return ParagonIE_Sodium_Crypto::box_secretkey($keypair);
-    }
-
-    /**
-     * Generate an X25519 keypair from a seed.
-     *
-     * @param string $seed
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress UndefinedFunction
-     */
-    public static function crypto_box_seed_keypair($seed)
-    {
-        /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
-
-        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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::box_seed_keypair($seed);
-        }
-        return ParagonIE_Sodium_Crypto::box_seed_keypair($seed);
-    }
-
-    /**
-     * Calculates a BLAKE2b hash, with an optional key.
-     *
-     * @param string      $message The message to be hashed
-     * @param string|null $key     If specified, must be a string between 16
-     *                             and 64 bytes long
-     * @param int         $length  Output length in bytes; must be between 16
-     *                             and 64 (default = 32)
-     * @return string              Raw binary
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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)) {
-            $key = '';
-        }
-        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 (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::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);
-        }
-        return ParagonIE_Sodium_Crypto::generichash($message, $key, $length);
-    }
-
-    /**
-     * Get the final BLAKE2b hash output for a given context.
-     *
-     * @param string $ctx BLAKE2 hashing context. Generated by crypto_generichash_init().
-     * @param int $length Hash output size.
-     * @return string     Final BLAKE2b hash.
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress ReferenceConstraintViolation
-     * @psalm-suppress ConflictingReferenceConstraint
-     */
-    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);
-
-        if (self::useNewSodiumAPI()) {
-            return sodium_crypto_generichash_final($ctx, $length);
-        }
-        if (self::use_fallback('crypto_generichash_final')) {
-            $func = '\\Sodium\\crypto_generichash_final';
-            return (string) $func($ctx, $length);
-        }
-        if ($length < 1) {
-            try {
-                self::memzero($ctx);
-            } catch (SodiumException $ex) {
-                unset($ctx);
-            }
-            return '';
-        }
-        if (PHP_INT_SIZE === 4) {
-            $result = ParagonIE_Sodium_Crypto32::generichash_final($ctx, $length);
-        } else {
-            $result = ParagonIE_Sodium_Crypto::generichash_final($ctx, $length);
-        }
-        try {
-            self::memzero($ctx);
-        } catch (SodiumException $ex) {
-            unset($ctx);
-        }
-        return $result;
-    }
-
-    /**
-     * Initialize a BLAKE2b hashing context, for use in a streaming interface.
-     *
-     * @param string|null $key If specified must be a string between 16 and 64 bytes
-     * @param int $length      The size of the desired hash output
-     * @return string          A BLAKE2 hashing context, encoded as a string
-     *                         (To be 100% compatible with ext/libsodium)
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_generichash_init($key = '', $length = self::CRYPTO_GENERICHASH_BYTES)
-    {
-        /* Type checks: */
-        if (is_null($key)) {
-            $key = '';
-        }
-        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 (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::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);
-        }
-        return ParagonIE_Sodium_Crypto::generichash_init($key, $length);
-    }
-
-    /**
-     * Initialize a BLAKE2b hashing context, for use in a streaming interface.
-     *
-     * @param string|null $key If specified must be a string between 16 and 64 bytes
-     * @param int $length      The size of the desired hash output
-     * @param string $salt     Salt (up to 16 bytes)
-     * @param string $personal Personalization string (up to 16 bytes)
-     * @return string          A BLAKE2 hashing context, encoded as a string
-     *                         (To be 100% compatible with ext/libsodium)
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_generichash_init_salt_personal(
-        $key = '',
-        $length = self::CRYPTO_GENERICHASH_BYTES,
-        $salt = '',
-        $personal = ''
-    ) {
-        /* Type checks: */
-        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);
-
-        /* Input validation: */
-        if (!empty($key)) {
-            /*
+	/**
+	 * This parameter prevents the use of the PECL extension.
+	 * It should only be used for unit testing.
+	 *
+	 * @var bool
+	 */
+	public static $disableFallbackForUnitTests = false;
+
+	/**
+	 * Use fast multiplication rather than our constant-time multiplication
+	 * implementation. Can be enabled at runtime. Only enable this if you
+	 * are absolutely certain that there is no timing leak on your platform.
+	 *
+	 * @var bool
+	 */
+	public static $fastMult = false;
+
+	const LIBRARY_MAJOR_VERSION = 9;
+	const LIBRARY_MINOR_VERSION = 1;
+	const LIBRARY_VERSION_MAJOR = 9;
+	const LIBRARY_VERSION_MINOR = 1;
+	const VERSION_STRING = 'polyfill-1.0.8';
+
+	// From libsodium
+	const BASE64_VARIANT_ORIGINAL = 1;
+	const BASE64_VARIANT_ORIGINAL_NO_PADDING = 3;
+	const BASE64_VARIANT_URLSAFE = 5;
+	const BASE64_VARIANT_URLSAFE_NO_PADDING = 7;
+	const CRYPTO_AEAD_AES256GCM_KEYBYTES = 32;
+	const CRYPTO_AEAD_AES256GCM_NSECBYTES = 0;
+	const CRYPTO_AEAD_AES256GCM_NPUBBYTES = 12;
+	const CRYPTO_AEAD_AES256GCM_ABYTES = 16;
+	const CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES = 32;
+	const CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES = 0;
+	const CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES = 8;
+	const CRYPTO_AEAD_CHACHA20POLY1305_ABYTES = 16;
+	const CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES = 32;
+	const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES = 0;
+	const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES = 12;
+	const CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES = 16;
+	const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES = 32;
+	const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES = 0;
+	const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES = 24;
+	const CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES = 16;
+	const CRYPTO_AUTH_BYTES = 32;
+	const CRYPTO_AUTH_KEYBYTES = 32;
+	const CRYPTO_BOX_SEALBYTES = 16;
+	const CRYPTO_BOX_SECRETKEYBYTES = 32;
+	const CRYPTO_BOX_PUBLICKEYBYTES = 32;
+	const CRYPTO_BOX_KEYPAIRBYTES = 64;
+	const CRYPTO_BOX_MACBYTES = 16;
+	const CRYPTO_BOX_NONCEBYTES = 24;
+	const CRYPTO_BOX_SEEDBYTES = 32;
+	const CRYPTO_CORE_RISTRETTO255_BYTES = 32;
+	const CRYPTO_CORE_RISTRETTO255_SCALARBYTES = 32;
+	const CRYPTO_CORE_RISTRETTO255_HASHBYTES = 64;
+	const CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES = 64;
+	const CRYPTO_KDF_BYTES_MIN = 16;
+	const CRYPTO_KDF_BYTES_MAX = 64;
+	const CRYPTO_KDF_CONTEXTBYTES = 8;
+	const CRYPTO_KDF_KEYBYTES = 32;
+	const CRYPTO_KX_BYTES = 32;
+	const CRYPTO_KX_PRIMITIVE = 'x25519blake2b';
+	const CRYPTO_KX_SEEDBYTES = 32;
+	const CRYPTO_KX_KEYPAIRBYTES = 64;
+	const CRYPTO_KX_PUBLICKEYBYTES = 32;
+	const CRYPTO_KX_SECRETKEYBYTES = 32;
+	const CRYPTO_KX_SESSIONKEYBYTES = 32;
+	const CRYPTO_GENERICHASH_BYTES = 32;
+	const CRYPTO_GENERICHASH_BYTES_MIN = 16;
+	const CRYPTO_GENERICHASH_BYTES_MAX = 64;
+	const CRYPTO_GENERICHASH_KEYBYTES = 32;
+	const CRYPTO_GENERICHASH_KEYBYTES_MIN = 16;
+	const CRYPTO_GENERICHASH_KEYBYTES_MAX = 64;
+	const CRYPTO_PWHASH_SALTBYTES = 16;
+	const CRYPTO_PWHASH_STRPREFIX = '$argon2id$';
+	const CRYPTO_PWHASH_ALG_ARGON2I13 = 1;
+	const CRYPTO_PWHASH_ALG_ARGON2ID13 = 2;
+	const CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE = 33554432;
+	const CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE = 4;
+	const CRYPTO_PWHASH_MEMLIMIT_MODERATE = 134217728;
+	const CRYPTO_PWHASH_OPSLIMIT_MODERATE = 6;
+	const CRYPTO_PWHASH_MEMLIMIT_SENSITIVE = 536870912;
+	const CRYPTO_PWHASH_OPSLIMIT_SENSITIVE = 8;
+	const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES = 32;
+	const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX = '$7$';
+	const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE = 534288;
+	const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE = 16777216;
+	const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE = 33554432;
+	const CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE = 1073741824;
+	const CRYPTO_SCALARMULT_BYTES = 32;
+	const CRYPTO_SCALARMULT_SCALARBYTES = 32;
+	const CRYPTO_SCALARMULT_RISTRETTO255_BYTES = 32;
+	const CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES = 32;
+	const CRYPTO_SHORTHASH_BYTES = 8;
+	const CRYPTO_SHORTHASH_KEYBYTES = 16;
+	const CRYPTO_SECRETBOX_KEYBYTES = 32;
+	const CRYPTO_SECRETBOX_MACBYTES = 16;
+	const CRYPTO_SECRETBOX_NONCEBYTES = 24;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES = 17;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES = 24;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES = 32;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH = 0;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL = 1;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY = 2;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL = 3;
+	const CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX = 0x3fffffff80;
+	const CRYPTO_SIGN_BYTES = 64;
+	const CRYPTO_SIGN_SEEDBYTES = 32;
+	const CRYPTO_SIGN_PUBLICKEYBYTES = 32;
+	const CRYPTO_SIGN_SECRETKEYBYTES = 64;
+	const CRYPTO_SIGN_KEYPAIRBYTES = 96;
+	const CRYPTO_STREAM_KEYBYTES = 32;
+	const CRYPTO_STREAM_NONCEBYTES = 24;
+	const CRYPTO_STREAM_XCHACHA20_KEYBYTES = 32;
+	const CRYPTO_STREAM_XCHACHA20_NONCEBYTES = 24;
+
+	/**
+	 * Add two numbers (little-endian unsigned), storing the value in the first
+	 * parameter.
+	 *
+	 * This mutates $val.
+	 *
+	 * @param string $val
+	 * @param string $addv
+	 * @return void
+	 * @throws SodiumException
+	 */
+	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');
+		}
+		$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);
+			$c >>= 8;
+		}
+		$val = ParagonIE_Sodium_Core_Util::intArrayToString($A);
+	}
+
+	/**
+	 * @param string $encoded
+	 * @param int $variant
+	 * @param string $ignore
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function base642bin($encoded, $variant, $ignore = '')
+	{
+		/* Type checks: */
+		ParagonIE_Sodium_Core_Util::declareScalarType($encoded, 'string', 1);
+
+		/** @var string $encoded */
+		$encoded = (string) $encoded;
+		if (ParagonIE_Sodium_Core_Util::strlen($encoded) === 0) {
+			return '';
+		}
+
+		// Just strip before decoding
+		if (!empty($ignore)) {
+			$encoded = str_replace($ignore, '', $encoded);
+		}
+
+		try {
+			switch ($variant) {
+				case self::BASE64_VARIANT_ORIGINAL:
+					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);
+				case self::BASE64_VARIANT_URLSAFE:
+					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);
+				default:
+					throw new SodiumException('invalid base64 variant identifier');
+			}
+		} catch (Exception $ex) {
+			if ($ex instanceof SodiumException) {
+				throw $ex;
+			}
+			throw new SodiumException('invalid base64 string');
+		}
+	}
+
+	/**
+	 * @param string $decoded
+	 * @param int $variant
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function bin2base64($decoded, $variant)
+	{
+		/* Type checks: */
+		ParagonIE_Sodium_Core_Util::declareScalarType($decoded, 'string', 1);
+		/** @var string $decoded */
+		$decoded = (string) $decoded;
+		if (ParagonIE_Sodium_Core_Util::strlen($decoded) === 0) {
+			return '';
+		}
+
+		switch ($variant) {
+			case self::BASE64_VARIANT_ORIGINAL:
+				return ParagonIE_Sodium_Core_Base64_Original::encode($decoded);
+			case self::BASE64_VARIANT_ORIGINAL_NO_PADDING:
+				return ParagonIE_Sodium_Core_Base64_Original::encodeUnpadded($decoded);
+			case self::BASE64_VARIANT_URLSAFE:
+				return ParagonIE_Sodium_Core_Base64_UrlSafe::encode($decoded);
+			case self::BASE64_VARIANT_URLSAFE_NO_PADDING:
+				return ParagonIE_Sodium_Core_Base64_UrlSafe::encodeUnpadded($decoded);
+			default:
+				throw new SodiumException('invalid base64 variant identifier');
+		}
+	}
+
+	/**
+	 * Cache-timing-safe implementation of bin2hex().
+	 *
+	 * @param string $string A string (probably raw binary)
+	 * @return string        A hexadecimal-encoded string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function bin2hex($string)
+	{
+		/* Type checks: */
+		ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
+
+		if (self::useNewSodiumAPI()) {
+			return (string) sodium_bin2hex($string);
+		}
+		if (self::use_fallback('bin2hex')) {
+			return (string) call_user_func('\\Sodium\\bin2hex', $string);
+		}
+		return ParagonIE_Sodium_Core_Util::bin2hex($string);
+	}
+
+	/**
+	 * Compare two strings, in constant-time.
+	 * Compared to memcmp(), compare() is more useful for sorting.
+	 *
+	 * @param string $left  The left operand; must be a string
+	 * @param string $right The right operand; must be a string
+	 * @return int          If < 0 if the left operand is less than the right
+	 *                      If = 0 if both strings are equal
+	 *                      If > 0 if the right operand is less than the left
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function compare($left, $right)
+	{
+		/* Type checks: */
+		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::use_fallback('compare')) {
+			return (int) call_user_func('\\Sodium\\compare', $left, $right);
+		}
+		return ParagonIE_Sodium_Core_Util::compare($left, $right);
+	}
+
+	/**
+	 * Is AES-256-GCM even available to use?
+	 *
+	 * @return bool
+	 * @psalm-suppress UndefinedFunction
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	public static function crypto_aead_aes256gcm_is_available()
+	{
+		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 (PHP_VERSION_ID < 70100) {
+			// OpenSSL doesn't support AEAD before 7.1.0
+			return false;
+		}
+		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());
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data: Decryption
+	 *
+	 * Algorithm:
+	 *     AES-256-GCM
+	 *
+	 * This mode uses a 64-bit random nonce with a 64-bit counter.
+	 * IETF mode uses a 96-bit random nonce with a 32-bit counter.
+	 *
+	 * @param string $ciphertext Encrypted message (with Poly1305 MAC appended)
+	 * @param string $assocData  Authenticated Associated Data (unencrypted)
+	 * @param string $nonce      Number to be used only Once; must be 8 bytes
+	 * @param string $key        Encryption key
+	 *
+	 * @return string|bool       The original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	public static function crypto_aead_aes256gcm_decrypt(
+		$ciphertext = '',
+		$assocData = '',
+		$nonce = '',
+		$key = ''
+	) {
+		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);
+
+		/* 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($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 (!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);
+		/** @var string $authTag */
+		$authTag = ParagonIE_Sodium_Core_Util::substr($ciphertext, -self::CRYPTO_AEAD_AES256GCM_ABYTES, 16);
+		return openssl_decrypt(
+			$ctext,
+			'aes-256-gcm',
+			$key,
+			OPENSSL_RAW_DATA,
+			$nonce,
+			$authTag,
+			$assocData
+		);
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data: Encryption
+	 *
+	 * Algorithm:
+	 *     AES-256-GCM
+	 *
+	 * @param string $plaintext Message to be encrypted
+	 * @param string $assocData Authenticated Associated Data (unencrypted)
+	 * @param string $nonce     Number to be used only Once; must be 8 bytes
+	 * @param string $key       Encryption key
+	 *
+	 * @return string           Ciphertext with a 16-byte GCM message
+	 *                          authentication code appended
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_aead_aes256gcm_encrypt(
+		$plaintext = '',
+		$assocData = '',
+		$nonce = '',
+		$key = ''
+	) {
+		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);
+
+		/* 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($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');
+		}
+
+		$authTag = '';
+		$ciphertext = openssl_encrypt(
+			$plaintext,
+			'aes-256-gcm',
+			$key,
+			OPENSSL_RAW_DATA,
+			$nonce,
+			$authTag,
+			$assocData
+		);
+		return $ciphertext . $authTag;
+	}
+
+	/**
+	 * Return a secure random key for use with the AES-256-GCM
+	 * symmetric AEAD interface.
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_aead_aes256gcm_keygen()
+	{
+		return random_bytes(self::CRYPTO_AEAD_AES256GCM_KEYBYTES);
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data: Decryption
+	 *
+	 * Algorithm:
+	 *     ChaCha20-Poly1305
+	 *
+	 * This mode uses a 64-bit random nonce with a 64-bit counter.
+	 * IETF mode uses a 96-bit random nonce with a 32-bit counter.
+	 *
+	 * @param string $ciphertext Encrypted message (with Poly1305 MAC appended)
+	 * @param string $assocData  Authenticated Associated Data (unencrypted)
+	 * @param string $nonce      Number to be used only Once; must be 8 bytes
+	 * @param string $key        Encryption key
+	 *
+	 * @return string            The original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	public static function crypto_aead_chacha20poly1305_decrypt(
+		$ciphertext = '',
+		$assocData = '',
+		$nonce = '',
+		$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);
+
+		/* 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($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 (self::useNewSodiumAPI()) {
+			/**
+			 * @psalm-suppress InvalidReturnStatement
+			 * @psalm-suppress FalsableReturnStatement
+			 */
+			return sodium_crypto_aead_chacha20poly1305_decrypt(
+				$ciphertext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (self::use_fallback('crypto_aead_chacha20poly1305_decrypt')) {
+			return call_user_func(
+				'\\Sodium\\crypto_aead_chacha20poly1305_decrypt',
+				$ciphertext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_decrypt(
+				$ciphertext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_decrypt(
+			$ciphertext,
+			$assocData,
+			$nonce,
+			$key
+		);
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data
+	 *
+	 * Algorithm:
+	 *     ChaCha20-Poly1305
+	 *
+	 * This mode uses a 64-bit random nonce with a 64-bit counter.
+	 * IETF mode uses a 96-bit random nonce with a 32-bit counter.
+	 *
+	 * @param string $plaintext Message to be encrypted
+	 * @param string $assocData Authenticated Associated Data (unencrypted)
+	 * @param string $nonce     Number to be used only Once; must be 8 bytes
+	 * @param string $key       Encryption key
+	 *
+	 * @return string           Ciphertext with a 16-byte Poly1305 message
+	 *                          authentication code appended
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_aead_chacha20poly1305_encrypt(
+		$plaintext = '',
+		$assocData = '',
+		$nonce = '',
+		$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);
+
+		/* 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($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(
+				$plaintext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (self::use_fallback('crypto_aead_chacha20poly1305_encrypt')) {
+			return (string) call_user_func(
+				'\\Sodium\\crypto_aead_chacha20poly1305_encrypt',
+				$plaintext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_encrypt(
+				$plaintext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_encrypt(
+			$plaintext,
+			$assocData,
+			$nonce,
+			$key
+		);
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data: Decryption
+	 *
+	 * Algorithm:
+	 *     ChaCha20-Poly1305
+	 *
+	 * IETF mode uses a 96-bit random nonce with a 32-bit counter.
+	 * Regular mode uses a 64-bit random nonce with a 64-bit counter.
+	 *
+	 * @param string $ciphertext Encrypted message (with Poly1305 MAC appended)
+	 * @param string $assocData  Authenticated Associated Data (unencrypted)
+	 * @param string $nonce      Number to be used only Once; must be 12 bytes
+	 * @param string $key        Encryption key
+	 *
+	 * @return string            The original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	public static function crypto_aead_chacha20poly1305_ietf_decrypt(
+		$ciphertext = '',
+		$assocData = '',
+		$nonce = '',
+		$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);
+
+		/* 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($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 (self::useNewSodiumAPI()) {
+			/**
+			 * @psalm-suppress InvalidReturnStatement
+			 * @psalm-suppress FalsableReturnStatement
+			 */
+			return sodium_crypto_aead_chacha20poly1305_ietf_decrypt(
+				$ciphertext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (self::use_fallback('crypto_aead_chacha20poly1305_ietf_decrypt')) {
+			return call_user_func(
+				'\\Sodium\\crypto_aead_chacha20poly1305_ietf_decrypt',
+				$ciphertext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_ietf_decrypt(
+				$ciphertext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_ietf_decrypt(
+			$ciphertext,
+			$assocData,
+			$nonce,
+			$key
+		);
+	}
+
+	/**
+	 * Return a secure random key for use with the ChaCha20-Poly1305
+	 * symmetric AEAD interface.
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_aead_chacha20poly1305_keygen()
+	{
+		return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES);
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data
+	 *
+	 * Algorithm:
+	 *     ChaCha20-Poly1305
+	 *
+	 * IETF mode uses a 96-bit random nonce with a 32-bit counter.
+	 * Regular mode uses a 64-bit random nonce with a 64-bit counter.
+	 *
+	 * @param string $plaintext Message to be encrypted
+	 * @param string $assocData Authenticated Associated Data (unencrypted)
+	 * @param string $nonce Number to be used only Once; must be 8 bytes
+	 * @param string $key Encryption key
+	 *
+	 * @return string           Ciphertext with a 16-byte Poly1305 message
+	 *                          authentication code appended
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_aead_chacha20poly1305_ietf_encrypt(
+		$plaintext = '',
+		$assocData = '',
+		$nonce = '',
+		$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($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($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(
+				$plaintext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (self::use_fallback('crypto_aead_chacha20poly1305_ietf_encrypt')) {
+			return (string) call_user_func(
+				'\\Sodium\\crypto_aead_chacha20poly1305_ietf_encrypt',
+				$plaintext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::aead_chacha20poly1305_ietf_encrypt(
+				$plaintext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		return ParagonIE_Sodium_Crypto::aead_chacha20poly1305_ietf_encrypt(
+			$plaintext,
+			$assocData,
+			$nonce,
+			$key
+		);
+	}
+
+	/**
+	 * Return a secure random key for use with the ChaCha20-Poly1305
+	 * symmetric AEAD interface. (IETF version)
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_aead_chacha20poly1305_ietf_keygen()
+	{
+		return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES);
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data: Decryption
+	 *
+	 * Algorithm:
+	 *     XChaCha20-Poly1305
+	 *
+	 * This mode uses a 64-bit random nonce with a 64-bit counter.
+	 * IETF mode uses a 96-bit random nonce with a 32-bit counter.
+	 *
+	 * @param string $ciphertext   Encrypted message (with Poly1305 MAC appended)
+	 * @param string $assocData    Authenticated Associated Data (unencrypted)
+	 * @param string $nonce        Number to be used only Once; must be 8 bytes
+	 * @param string $key          Encryption key
+	 * @param bool   $dontFallback Don't fallback to ext/sodium
+	 *
+	 * @return string|bool         The original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_aead_xchacha20poly1305_ietf_decrypt(
+		$ciphertext = '',
+		$assocData = '',
+		$nonce = '',
+		$key = '',
+		$dontFallback = false
+	) {
+		/* Type checks: */
+		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);
+
+		/* 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($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 (self::useNewSodiumAPI() && !$dontFallback) {
+			if (is_callable('sodium_crypto_aead_xchacha20poly1305_ietf_decrypt')) {
+				return sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(
+					$ciphertext,
+					$assocData,
+					$nonce,
+					$key
+				);
+			}
+		}
+
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_decrypt(
+				$ciphertext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		return ParagonIE_Sodium_Crypto::aead_xchacha20poly1305_ietf_decrypt(
+			$ciphertext,
+			$assocData,
+			$nonce,
+			$key
+		);
+	}
+
+	/**
+	 * Authenticated Encryption with Associated Data
+	 *
+	 * Algorithm:
+	 *     XChaCha20-Poly1305
+	 *
+	 * This mode uses a 64-bit random nonce with a 64-bit counter.
+	 * IETF mode uses a 96-bit random nonce with a 32-bit counter.
+	 *
+	 * @param string $plaintext    Message to be encrypted
+	 * @param string $assocData    Authenticated Associated Data (unencrypted)
+	 * @param string $nonce        Number to be used only Once; must be 8 bytes
+	 * @param string $key          Encryption key
+	 * @param bool   $dontFallback Don't fallback to ext/sodium
+	 *
+	 * @return string           Ciphertext with a 16-byte Poly1305 message
+	 *                          authentication code appended
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_aead_xchacha20poly1305_ietf_encrypt(
+		$plaintext = '',
+		$assocData = '',
+		$nonce = '',
+		$key = '',
+		$dontFallback = false
+	) {
+		/* Type checks: */
+		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);
+
+		/* 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($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')) {
+				return sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
+					$plaintext,
+					$assocData,
+					$nonce,
+					$key
+				);
+			}
+		}
+
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::aead_xchacha20poly1305_ietf_encrypt(
+				$plaintext,
+				$assocData,
+				$nonce,
+				$key
+			);
+		}
+		return ParagonIE_Sodium_Crypto::aead_xchacha20poly1305_ietf_encrypt(
+			$plaintext,
+			$assocData,
+			$nonce,
+			$key
+		);
+	}
+
+	/**
+	 * Return a secure random key for use with the XChaCha20-Poly1305
+	 * symmetric AEAD interface.
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_aead_xchacha20poly1305_ietf_keygen()
+	{
+		return random_bytes(self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES);
+	}
+
+	/**
+	 * Authenticate a message. Uses symmetric-key cryptography.
+	 *
+	 * Algorithm:
+	 *     HMAC-SHA512-256. Which is HMAC-SHA-512 truncated to 256 bits.
+	 *     Not to be confused with HMAC-SHA-512/256 which would use the
+	 *     SHA-512/256 hash function (uses different initial parameters
+	 *     but still truncates to 256 bits to sidestep length-extension
+	 *     attacks).
+	 *
+	 * @param string $message Message to be authenticated
+	 * @param string $key Symmetric authentication key
+	 * @return string         Message authentication code
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::auth($message, $key);
+		}
+		return ParagonIE_Sodium_Crypto::auth($message, $key);
+	}
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_auth_keygen()
+	{
+		return random_bytes(self::CRYPTO_AUTH_KEYBYTES);
+	}
+
+	/**
+	 * Verify the MAC of a message previously authenticated with crypto_auth.
+	 *
+	 * @param string $mac Message authentication code
+	 * @param string $message Message whose authenticity you are attempting to
+	 *                        verify (with a given MAC and key)
+	 * @param string $key Symmetric authentication key
+	 * @return bool           TRUE if authenticated, FALSE otherwise
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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);
+		}
+		return ParagonIE_Sodium_Crypto::auth_verify($mac, $message, $key);
+	}
+
+	/**
+	 * Authenticated asymmetric-key encryption. Both the sender and recipient
+	 * may decrypt messages.
+	 *
+	 * Algorithm: X25519-XSalsa20-Poly1305.
+	 *     X25519: Elliptic-Curve Diffie Hellman over Curve25519.
+	 *     XSalsa20: Extended-nonce variant of salsa20.
+	 *     Poyl1305: Polynomial MAC for one-time message authentication.
+	 *
+	 * @param string $plaintext The message to be encrypted
+	 * @param string $nonce A Number to only be used Once; must be 24 bytes
+	 * @param string $keypair Your secret key and your recipient's public key
+	 * @return string           Ciphertext with 16-byte Poly1305 MAC
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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);
+		}
+		return ParagonIE_Sodium_Crypto::box($plaintext, $nonce, $keypair);
+	}
+
+	/**
+	 * Anonymous public-key encryption. Only the recipient may decrypt messages.
+	 *
+	 * Algorithm: X25519-XSalsa20-Poly1305, as with crypto_box.
+	 *     The sender's X25519 keypair is ephemeral.
+	 *     Nonce is generated from the BLAKE2b hash of both public keys.
+	 *
+	 * This provides ciphertext integrity.
+	 *
+	 * @param string $plaintext Message to be sealed
+	 * @param string $publicKey Your recipient's public key
+	 * @return string           Sealed message that only your recipient can
+	 *                          decrypt
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_seal($plaintext, $publicKey);
+		}
+		return ParagonIE_Sodium_Crypto::box_seal($plaintext, $publicKey);
+	}
+
+	/**
+	 * Opens a message encrypted with crypto_box_seal(). Requires
+	 * the recipient's keypair (sk || pk) to decrypt successfully.
+	 *
+	 * This validates ciphertext integrity.
+	 *
+	 * @param string $ciphertext Sealed message to be opened
+	 * @param string $keypair    Your crypto_box keypair
+	 * @return string            The original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	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);
+
+		/* 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 (self::useNewSodiumAPI()) {
+			/**
+			 * @psalm-suppress InvalidReturnStatement
+			 * @psalm-suppress FalsableReturnStatement
+			 */
+			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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_seal_open($ciphertext, $keypair);
+		}
+		return ParagonIE_Sodium_Crypto::box_seal_open($ciphertext, $keypair);
+	}
+
+	/**
+	 * Generate a new random X25519 keypair.
+	 *
+	 * @return string A 64-byte string; the first 32 are your secret key, while
+	 *                the last 32 are your public key. crypto_box_secretkey()
+	 *                and crypto_box_publickey() exist to separate them so you
+	 *                don't accidentally get them mixed up!
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function 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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_keypair();
+		}
+		return ParagonIE_Sodium_Crypto::box_keypair();
+	}
+
+	/**
+	 * Combine two keys into a keypair for use in library methods that expect
+	 * a keypair. This doesn't necessarily have to be the same person's keys.
+	 *
+	 * @param string $secretKey Secret key
+	 * @param string $publicKey Public key
+	 * @return string    Keypair
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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);
+		}
+		return ParagonIE_Sodium_Crypto::box_keypair_from_secretkey_and_publickey($secretKey, $publicKey);
+	}
+
+	/**
+	 * Decrypt a message previously encrypted with crypto_box().
+	 *
+	 * @param string $ciphertext Encrypted message
+	 * @param string $nonce      Number to only be used Once; must be 24 bytes
+	 * @param string $keypair    Your secret key and the sender's public key
+	 * @return string            The original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	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);
+
+		/* 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($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 (self::useNewSodiumAPI()) {
+			/**
+			 * @psalm-suppress InvalidReturnStatement
+			 * @psalm-suppress FalsableReturnStatement
+			 */
+			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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_open($ciphertext, $nonce, $keypair);
+		}
+		return ParagonIE_Sodium_Crypto::box_open($ciphertext, $nonce, $keypair);
+	}
+
+	/**
+	 * Extract the public key from a crypto_box keypair.
+	 *
+	 * @param string $keypair Keypair containing secret and public key
+	 * @return string         Your crypto_box public key
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_box_publickey($keypair)
+	{
+		/* Type checks: */
+		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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_publickey($keypair);
+		}
+		return ParagonIE_Sodium_Crypto::box_publickey($keypair);
+	}
+
+	/**
+	 * Calculate the X25519 public key from a given X25519 secret key.
+	 *
+	 * @param string $secretKey Any X25519 secret key
+	 * @return string           The corresponding X25519 public key
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_box_publickey_from_secretkey($secretKey)
+	{
+		/* Type checks: */
+		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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_publickey_from_secretkey($secretKey);
+		}
+		return ParagonIE_Sodium_Crypto::box_publickey_from_secretkey($secretKey);
+	}
+
+	/**
+	 * Extract the secret key from a crypto_box keypair.
+	 *
+	 * @param string $keypair
+	 * @return string         Your crypto_box secret key
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_box_secretkey($keypair)
+	{
+		/* Type checks: */
+		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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_secretkey($keypair);
+		}
+		return ParagonIE_Sodium_Crypto::box_secretkey($keypair);
+	}
+
+	/**
+	 * Generate an X25519 keypair from a seed.
+	 *
+	 * @param string $seed
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress UndefinedFunction
+	 */
+	public static function crypto_box_seed_keypair($seed)
+	{
+		/* Type checks: */
+		ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
+
+		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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::box_seed_keypair($seed);
+		}
+		return ParagonIE_Sodium_Crypto::box_seed_keypair($seed);
+	}
+
+	/**
+	 * Calculates a BLAKE2b hash, with an optional key.
+	 *
+	 * @param string      $message The message to be hashed
+	 * @param string|null $key     If specified, must be a string between 16
+	 *                             and 64 bytes long
+	 * @param int         $length  Output length in bytes; must be between 16
+	 *                             and 64 (default = 32)
+	 * @return string              Raw binary
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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)) {
+			$key = '';
+		}
+		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 (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::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);
+		}
+		return ParagonIE_Sodium_Crypto::generichash($message, $key, $length);
+	}
+
+	/**
+	 * Get the final BLAKE2b hash output for a given context.
+	 *
+	 * @param string $ctx BLAKE2 hashing context. Generated by crypto_generichash_init().
+	 * @param int $length Hash output size.
+	 * @return string     Final BLAKE2b hash.
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress ReferenceConstraintViolation
+	 * @psalm-suppress ConflictingReferenceConstraint
+	 */
+	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);
+
+		if (self::useNewSodiumAPI()) {
+			return sodium_crypto_generichash_final($ctx, $length);
+		}
+		if (self::use_fallback('crypto_generichash_final')) {
+			$func = '\\Sodium\\crypto_generichash_final';
+			return (string) $func($ctx, $length);
+		}
+		if ($length < 1) {
+			try {
+				self::memzero($ctx);
+			} catch (SodiumException $ex) {
+				unset($ctx);
+			}
+			return '';
+		}
+		if (PHP_INT_SIZE === 4) {
+			$result = ParagonIE_Sodium_Crypto32::generichash_final($ctx, $length);
+		} else {
+			$result = ParagonIE_Sodium_Crypto::generichash_final($ctx, $length);
+		}
+		try {
+			self::memzero($ctx);
+		} catch (SodiumException $ex) {
+			unset($ctx);
+		}
+		return $result;
+	}
+
+	/**
+	 * Initialize a BLAKE2b hashing context, for use in a streaming interface.
+	 *
+	 * @param string|null $key If specified must be a string between 16 and 64 bytes
+	 * @param int $length      The size of the desired hash output
+	 * @return string          A BLAKE2 hashing context, encoded as a string
+	 *                         (To be 100% compatible with ext/libsodium)
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_generichash_init($key = '', $length = self::CRYPTO_GENERICHASH_BYTES)
+	{
+		/* Type checks: */
+		if (is_null($key)) {
+			$key = '';
+		}
+		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 (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::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);
+		}
+		return ParagonIE_Sodium_Crypto::generichash_init($key, $length);
+	}
+
+	/**
+	 * Initialize a BLAKE2b hashing context, for use in a streaming interface.
+	 *
+	 * @param string|null $key If specified must be a string between 16 and 64 bytes
+	 * @param int $length      The size of the desired hash output
+	 * @param string $salt     Salt (up to 16 bytes)
+	 * @param string $personal Personalization string (up to 16 bytes)
+	 * @return string          A BLAKE2 hashing context, encoded as a string
+	 *                         (To be 100% compatible with ext/libsodium)
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_generichash_init_salt_personal(
+		$key = '',
+		$length = self::CRYPTO_GENERICHASH_BYTES,
+		$salt = '',
+		$personal = ''
+	) {
+		/* Type checks: */
+		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);
+
+		/* 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 (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);
-        }
-        return ParagonIE_Sodium_Crypto::generichash_init_salt_personal($key, $length, $salt, $personal);
-    }
-
-    /**
-     * Update a BLAKE2b hashing context with additional data.
-     *
-     * @param string $ctx    BLAKE2 hashing context. Generated by crypto_generichash_init().
-     *                       $ctx is passed by reference and gets updated in-place.
-     * @param-out string $ctx
-     * @param string $message The message to append to the existing hash state.
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress ReferenceConstraintViolation
-     */
-    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);
-
-        if (self::useNewSodiumAPI()) {
-            sodium_crypto_generichash_update($ctx, $message);
-            return;
-        }
-        if (self::use_fallback('crypto_generichash_update')) {
-            $func = '\\Sodium\\crypto_generichash_update';
-            $func($ctx, $message);
-            return;
-        }
-        if (PHP_INT_SIZE === 4) {
-            $ctx = ParagonIE_Sodium_Crypto32::generichash_update($ctx, $message);
-        } else {
-            $ctx = ParagonIE_Sodium_Crypto::generichash_update($ctx, $message);
-        }
-    }
-
-    /**
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_generichash_keygen()
-    {
-        return random_bytes(self::CRYPTO_GENERICHASH_KEYBYTES);
-    }
-
-    /**
-     * @param int $subkey_len
-     * @param int $subkey_id
-     * @param string $context
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     */
-    public static function crypto_kdf_derive_from_key(
-        $subkey_len,
-        $subkey_id,
-        $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;
-
-        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_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($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);
-        $state = self::crypto_generichash_init_salt_personal(
-            $key,
-            $subkey_len,
-            $salt,
-            $context
-        );
-        return self::crypto_generichash_final($state, $subkey_len);
-    }
-
-    /**
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_kdf_keygen()
-    {
-        return random_bytes(self::CRYPTO_KDF_KEYBYTES);
-    }
-
-    /**
-     * Perform a key exchange, between a designated client and a server.
-     *
-     * Typically, you would designate one machine to be the client and the
-     * other to be the server. The first two keys are what you'd expect for
-     * scalarmult() below, but the latter two public keys don't swap places.
-     *
-     * | ALICE                          | BOB                                 |
-     * | Client                         | Server                              |
-     * |--------------------------------|-------------------------------------|
-     * | shared = crypto_kx(            | shared = crypto_kx(                 |
-     * |     alice_sk,                  |     bob_sk,                         | <- contextual
-     * |     bob_pk,                    |     alice_pk,                       | <- contextual
-     * |     alice_pk,                  |     alice_pk,                       | <----- static
-     * |     bob_pk                     |     bob_pk                          | <----- static
-     * | )                              | )                                   |
-     *
-     * They are used along with the scalarmult product to generate a 256-bit
-     * BLAKE2b hash unique to the client and server keys.
-     *
-     * @param string $my_secret
-     * @param string $their_public
-     * @param string $client_public
-     * @param string $server_public
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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($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(
-                    $my_secret,
-                    $their_public,
-                    $client_public,
-                    $server_public
-                );
-            }
-        }
-        if (self::use_fallback('crypto_kx')) {
-            return (string) call_user_func(
-                '\\Sodium\\crypto_kx',
-                $my_secret,
-                $their_public,
-                $client_public,
-                $server_public
-            );
-        }
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::keyExchange(
-                $my_secret,
-                $their_public,
-                $client_public,
-                $server_public
-            );
-        }
-        return ParagonIE_Sodium_Crypto::keyExchange(
-            $my_secret,
-            $their_public,
-            $client_public,
-            $server_public
-        );
-    }
-
-    /**
-     * @param string $seed
-     * @return string
-     * @throws SodiumException
-     */
-    public static function crypto_kx_seed_keypair($seed)
-    {
-        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
-
-        $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');
-        }
-
-        $sk = self::crypto_generichash($seed, '', self::CRYPTO_KX_SECRETKEYBYTES);
-        $pk = self::crypto_scalarmult_base($sk);
-        return $sk . $pk;
-    }
-
-    /**
-     * @return string
-     * @throws Exception
-     */
-    public static function crypto_kx_keypair()
-    {
-        $sk = self::randombytes_buf(self::CRYPTO_KX_SECRETKEYBYTES);
-        $pk = self::crypto_scalarmult_base($sk);
-        return $sk . $pk;
-    }
-
-    /**
-     * @param string $keypair
-     * @param string $serverPublicKey
-     * @return array{0: string, 1: string}
-     * @throws SodiumException
-     */
-    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);
-
-        $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($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);
-        return array(
-            ParagonIE_Sodium_Core_Util::substr(
-                $sessionKeys,
-                0,
-                self::CRYPTO_KX_SESSIONKEYBYTES
-            ),
-            ParagonIE_Sodium_Core_Util::substr(
-                $sessionKeys,
-                self::CRYPTO_KX_SESSIONKEYBYTES,
-                self::CRYPTO_KX_SESSIONKEYBYTES
-            )
-        );
-    }
-
-    /**
-     * @param string $keypair
-     * @param string $clientPublicKey
-     * @return array{0: string, 1: string}
-     * @throws SodiumException
-     */
-    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);
-
-        $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($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);
-        return array(
-            ParagonIE_Sodium_Core_Util::substr(
-                $sessionKeys,
-                self::CRYPTO_KX_SESSIONKEYBYTES,
-                self::CRYPTO_KX_SESSIONKEYBYTES
-            ),
-            ParagonIE_Sodium_Core_Util::substr(
-                $sessionKeys,
-                0,
-                self::CRYPTO_KX_SESSIONKEYBYTES
-            )
-        );
-    }
-
-    /**
-     * @param string $kp
-     * @return string
-     * @throws SodiumException
-     */
-    public static function crypto_kx_secretkey($kp)
-    {
-        return ParagonIE_Sodium_Core_Util::substr(
-            $kp,
-            0,
-            self::CRYPTO_KX_SECRETKEYBYTES
-        );
-    }
-
-    /**
-     * @param string $kp
-     * @return string
-     * @throws SodiumException
-     */
-    public static function crypto_kx_publickey($kp)
-    {
-        return ParagonIE_Sodium_Core_Util::substr(
-            $kp,
-            self::CRYPTO_KX_SECRETKEYBYTES,
-            self::CRYPTO_KX_PUBLICKEYBYTES
-        );
-    }
-
-    /**
-     * @param int $outlen
-     * @param string $passwd
-     * @param string $salt
-     * @param int $opslimit
-     * @param int $memlimit
-     * @param int|null $alg
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        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);
-        }
-        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(
-            'This is not implemented, as it is not possible to implement Argon2i with acceptable performance in pure-PHP'
-        );
-    }
-
-    /**
-     * !Exclusive to sodium_compat!
-     *
-     * This returns TRUE if the native crypto_pwhash API is available by libsodium.
-     * This returns FALSE if only sodium_compat is available.
-     *
-     * @return bool
-     */
-    public static function crypto_pwhash_is_available()
-    {
-        if (self::useNewSodiumAPI()) {
-            return true;
-        }
-        if (self::use_fallback('crypto_pwhash')) {
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * @param string $passwd
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        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);
-        }
-        // This is the best we can do.
-        throw new SodiumException(
-            'This is not implemented, as it is not possible to implement Argon2i with acceptable performance in pure-PHP'
-        );
-    }
-
-    /**
-     * Do we need to rehash this password?
-     *
-     * @param string $hash
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return bool
-     * @throws SodiumException
-     */
-    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);
-
-        // Just grab the first 4 pieces.
-        $pieces = explode('$', (string) $hash);
-        $prefix = implode('$', array_slice($pieces, 0, 4));
-
-        // Rebuild the expected header.
-        /** @var int $ops */
-        $ops = (int) $opslimit;
-        /** @var int $mem */
-        $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);
-    }
-
-    /**
-     * @param string $passwd
-     * @param string $hash
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        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);
-        }
-        // This is the best we can do.
-        throw new SodiumException(
-            'This is not implemented, as it is not possible to implement Argon2i with acceptable performance in pure-PHP'
-        );
-    }
-
-    /**
-     * @param int $outlen
-     * @param string $passwd
-     * @param string $salt
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return string
-     * @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
-            );
-        }
-        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
-            );
-        }
-        // This is the best we can do.
-        throw new SodiumException(
-            'This is not implemented, as it is not possible to implement Scrypt with acceptable performance in pure-PHP'
-        );
-    }
-
-    /**
-     * !Exclusive to sodium_compat!
-     *
-     * This returns TRUE if the native crypto_pwhash API is available by libsodium.
-     * This returns FALSE if only sodium_compat is available.
-     *
-     * @return bool
-     */
-    public static function crypto_pwhash_scryptsalsa208sha256_is_available()
-    {
-        if (self::useNewSodiumAPI()) {
-            return true;
-        }
-        if (self::use_fallback('crypto_pwhash_scryptsalsa208sha256')) {
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * @param string $passwd
-     * @param int $opslimit
-     * @param int $memlimit
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    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);
-
-        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(
-                '\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str',
-                (string) $passwd,
-                (int) $opslimit,
-                (int) $memlimit
-            );
-        }
-        // This is the best we can do.
-        throw new SodiumException(
-            'This is not implemented, as it is not possible to implement Scrypt with acceptable performance in pure-PHP'
-        );
-    }
-
-    /**
-     * @param string $passwd
-     * @param string $hash
-     * @return bool
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    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);
-
-        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(
-                '\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str_verify',
-                (string) $passwd,
-                (string) $hash
-            );
-        }
-        // This is the best we can do.
-        throw new SodiumException(
-            'This is not implemented, as it is not possible to implement Scrypt with acceptable performance in pure-PHP'
-        );
-    }
-
-    /**
-     * Calculate the shared secret between your secret key and your
-     * recipient's public key.
-     *
-     * Algorithm: X25519 (ECDH over Curve25519)
-     *
-     * @param string $secretKey
-     * @param string $publicKey
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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($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);
-        }
-        return ParagonIE_Sodium_Crypto::scalarmult($secretKey, $publicKey);
-    }
-
-    /**
-     * Calculate an X25519 public key from an X25519 secret key.
-     *
-     * @param string $secretKey
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress TooFewArguments
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_scalarmult_base($secretKey)
-    {
-        /* Type checks: */
-        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 (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 (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);
-        }
-        return ParagonIE_Sodium_Crypto::scalarmult_base($secretKey);
-    }
-
-    /**
-     * Authenticated symmetric-key encryption.
-     *
-     * Algorithm: XSalsa20-Poly1305
-     *
-     * @param string $plaintext The message you're encrypting
-     * @param string $nonce A Number to be used Once; must be 24 bytes
-     * @param string $key Symmetric encryption key
-     * @return string           Ciphertext with Poly1305 MAC
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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);
-        }
-        return ParagonIE_Sodium_Crypto::secretbox($plaintext, $nonce, $key);
-    }
-
-    /**
-     * Decrypts a message previously encrypted with crypto_secretbox().
-     *
-     * @param string $ciphertext Ciphertext with Poly1305 MAC
-     * @param string $nonce      A Number to be used Once; must be 24 bytes
-     * @param string $key        Symmetric encryption key
-     * @return string            Original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    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);
-
-        /* 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($key) !== self::CRYPTO_SECRETBOX_KEYBYTES) {
-            throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.');
-        }
-
-        if (self::useNewSodiumAPI()) {
-            /**
-             * @psalm-suppress InvalidReturnStatement
-             * @psalm-suppress FalsableReturnStatement
-             */
-            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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretbox_open($ciphertext, $nonce, $key);
-        }
-        return ParagonIE_Sodium_Crypto::secretbox_open($ciphertext, $nonce, $key);
-    }
-
-    /**
-     * Return a secure random key for use with crypto_secretbox
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_secretbox_keygen()
-    {
-        return random_bytes(self::CRYPTO_SECRETBOX_KEYBYTES);
-    }
-
-    /**
-     * Authenticated symmetric-key encryption.
-     *
-     * Algorithm: XChaCha20-Poly1305
-     *
-     * @param string $plaintext The message you're encrypting
-     * @param string $nonce     A Number to be used Once; must be 24 bytes
-     * @param string $key       Symmetric encryption key
-     * @return string           Ciphertext with Poly1305 MAC
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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);
-        }
-        return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305($plaintext, $nonce, $key);
-    }
-    /**
-     * Decrypts a message previously encrypted with crypto_secretbox_xchacha20poly1305().
-     *
-     * @param string $ciphertext Ciphertext with Poly1305 MAC
-     * @param string $nonce      A Number to be used Once; must be 24 bytes
-     * @param string $key        Symmetric encryption key
-     * @return string            Original plaintext message
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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);
-        }
-        return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key);
-    }
-
-    /**
-     * @param string $key
-     * @return array<int, string> Returns a state and a header.
-     * @throws Exception
-     * @throws SodiumException
-     */
-    public static function crypto_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);
-    }
-
-    /**
-     * @param string $header
-     * @param string $key
-     * @return string Returns a state.
-     * @throws Exception
-     */
-    public static function crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
-    {
-        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);
-        }
-        return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_init_pull($key, $header);
-    }
-
-    /**
-     * @param string $state
-     * @param string $msg
-     * @param string $aad
-     * @param int $tag
-     * @return string
-     * @throws SodiumException
-     */
-    public static function crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
-    {
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_push(
-                $state,
-                $msg,
-                $aad,
-                $tag
-            );
-        }
-        return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_push(
-            $state,
-            $msg,
-            $aad,
-            $tag
-        );
-    }
-
-    /**
-     * @param string $state
-     * @param string $msg
-     * @param string $aad
-     * @return bool|array{0: string, 1: int}
-     * @throws SodiumException
-     */
-    public static function crypto_secretstream_xchacha20poly1305_pull(&$state, $msg, $aad = '')
-    {
-        if (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_pull(
-                $state,
-                $msg,
-                $aad
-            );
-        }
-        return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_pull(
-            $state,
-            $msg,
-            $aad
-        );
-    }
-
-    /**
-     * @return string
-     * @throws Exception
-     */
-    public static function crypto_secretstream_xchacha20poly1305_keygen()
-    {
-        return random_bytes(self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES);
-    }
-
-    /**
-     * @param string $state
-     * @return void
-     * @throws SodiumException
-     */
-    public static function crypto_secretstream_xchacha20poly1305_rekey(&$state)
-    {
-        if (PHP_INT_SIZE === 4) {
-            ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_rekey($state);
-        } else {
-            ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_rekey($state);
-        }
-    }
-
-    /**
-     * Calculates a SipHash-2-4 hash of a message for a given key.
-     *
-     * @param string $message Input message
-     * @param string $key SipHash-2-4 key
-     * @return string         Hash
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    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);
-
-        /* 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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_SipHash::sipHash24($message, $key);
-        }
-        return ParagonIE_Sodium_Core_SipHash::sipHash24($message, $key);
-    }
-
-    /**
-     * Return a secure random key for use with crypto_shorthash
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_shorthash_keygen()
-    {
-        return random_bytes(self::CRYPTO_SHORTHASH_KEYBYTES);
-    }
-
-    /**
-     * Returns a signed message. You probably want crypto_sign_detached()
-     * instead, which only returns the signature.
-     *
-     * Algorithm: Ed25519 (EdDSA over Curve25519)
-     *
-     * @param string $message Message to be signed.
-     * @param string $secretKey Secret signing key.
-     * @return string           Signed message (signature is prefixed).
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    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);
-
-        /* 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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::sign($message, $secretKey);
-        }
-        return ParagonIE_Sodium_Crypto::sign($message, $secretKey);
-    }
-
-    /**
-     * Validates a signed message then returns the message.
-     *
-     * @param string $signedMessage A signed message
-     * @param string $publicKey A public key
-     * @return string               The original message (if the signature is
-     *                              valid for this public key)
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress MixedReturnStatement
-     */
-    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);
-
-        /* 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($publicKey) !== self::CRYPTO_SIGN_PUBLICKEYBYTES) {
-            throw new SodiumException('Argument 2 must be CRYPTO_SIGN_PUBLICKEYBYTES long.');
-        }
-
-        if (self::useNewSodiumAPI()) {
-            /**
-             * @psalm-suppress InvalidReturnStatement
-             * @psalm-suppress FalsableReturnStatement
-             */
-            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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::sign_open($signedMessage, $publicKey);
-        }
-        return ParagonIE_Sodium_Crypto::sign_open($signedMessage, $publicKey);
-    }
-
-    /**
-     * Generate a new random Ed25519 keypair.
-     *
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    public static function crypto_sign_keypair()
-    {
-        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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::keypair();
-        }
-        return ParagonIE_Sodium_Core_Ed25519::keypair();
-    }
-
-    /**
-     * @param string $sk
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     */
-    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;
-
-        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 (self::useNewSodiumAPI()) {
-            return sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
-        }
-        return $sk . $pk;
-    }
-
-    /**
-     * Generate an Ed25519 keypair from a seed.
-     *
-     * @param string $seed Input seed
-     * @return string      Keypair
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_sign_seed_keypair($seed)
-    {
-        ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
-
-        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);
-        }
-        $publicKey = '';
-        $secretKey = '';
-        if (PHP_INT_SIZE === 4) {
-            ParagonIE_Sodium_Core32_Ed25519::seed_keypair($publicKey, $secretKey, $seed);
-        } else {
-            ParagonIE_Sodium_Core_Ed25519::seed_keypair($publicKey, $secretKey, $seed);
-        }
-        return $secretKey . $publicKey;
-    }
-
-    /**
-     * Extract an Ed25519 public key from an Ed25519 keypair.
-     *
-     * @param string $keypair Keypair
-     * @return string         Public key
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_sign_publickey($keypair)
-    {
-        /* Type checks: */
-        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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::publickey($keypair);
-        }
-        return ParagonIE_Sodium_Core_Ed25519::publickey($keypair);
-    }
-
-    /**
-     * Calculate an Ed25519 public key from an Ed25519 secret key.
-     *
-     * @param string $secretKey Your Ed25519 secret key
-     * @return string           The corresponding Ed25519 public key
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_sign_publickey_from_secretkey($secretKey)
-    {
-        /* Type checks: */
-        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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::publickey_from_secretkey($secretKey);
-        }
-        return ParagonIE_Sodium_Core_Ed25519::publickey_from_secretkey($secretKey);
-    }
-
-    /**
-     * Extract an Ed25519 secret key from an Ed25519 keypair.
-     *
-     * @param string $keypair Keypair
-     * @return string         Secret key
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_sign_secretkey($keypair)
-    {
-        /* Type checks: */
-        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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::secretkey($keypair);
-        }
-        return ParagonIE_Sodium_Core_Ed25519::secretkey($keypair);
-    }
-
-    /**
-     * Calculate the Ed25519 signature of a message and return ONLY the signature.
-     *
-     * Algorithm: Ed25519 (EdDSA over Curve25519)
-     *
-     * @param string $message Message to be signed
-     * @param string $secretKey Secret signing key
-     * @return string           Digital signature
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Crypto32::sign_detached($message, $secretKey);
-        }
-        return ParagonIE_Sodium_Crypto::sign_detached($message, $secretKey);
-    }
-
-    /**
-     * Verify the Ed25519 signature of a message.
-     *
-     * @param string $signature Digital sginature
-     * @param string $message Message to be verified
-     * @param string $publicKey Public key
-     * @return bool             TRUE if this signature is good for this public key;
-     *                          FALSE otherwise
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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);
-        }
-        return ParagonIE_Sodium_Crypto::sign_verify_detached($signature, $message, $publicKey);
-    }
-
-    /**
-     * Convert an Ed25519 public key to a Curve25519 public key
-     *
-     * @param string $pk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_sign_ed25519_pk_to_curve25519($pk)
-    {
-        /* Type checks: */
-        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 (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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_Ed25519::pk_to_curve25519($pk);
-        }
-        return ParagonIE_Sodium_Core_Ed25519::pk_to_curve25519($pk);
-    }
-
-    /**
-     * Convert an Ed25519 secret key to a Curve25519 secret key
-     *
-     * @param string $sk
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function crypto_sign_ed25519_sk_to_curve25519($sk)
-    {
-        /* Type checks: */
-        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 (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);
-        }
-
-        $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
-        );
-        return ParagonIE_Sodium_Core_Util::substr($h, 0, 32);
-    }
-
-    /**
-     * Expand a key and nonce into a keystream of pseudorandom bytes.
-     *
-     * @param int $len Number of bytes desired
-     * @param string $nonce Number to be used Once; must be 24 bytes
-     * @param string $key XSalsa20 key
-     * @return string       Pseudorandom stream that can be XORed with messages
-     *                      to provide encryption (but not authentication; see
-     *                      Poly1305 or crypto_auth() for that, which is not
-     *                      optional for security)
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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);
-        }
-        return ParagonIE_Sodium_Core_XSalsa20::xsalsa20($len, $nonce, $key);
-    }
-
-    /**
-     * DANGER! UNAUTHENTICATED ENCRYPTION!
-     *
-     * Unless you are following expert advice, do not use this feature.
-     *
-     * Algorithm: XSalsa20
-     *
-     * This DOES NOT provide ciphertext integrity.
-     *
-     * @param string $message Plaintext message
-     * @param string $nonce Number to be used Once; must be 24 bytes
-     * @param string $key Encryption key
-     * @return string         Encrypted text which is vulnerable to chosen-
-     *                        ciphertext attacks unless you implement some
-     *                        other mitigation to the ciphertext (i.e.
-     *                        Encrypt then MAC)
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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::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);
-        }
-        return ParagonIE_Sodium_Core_XSalsa20::xsalsa20_xor($message, $nonce, $key);
-    }
-
-    /**
-     * Return a secure random key for use with crypto_stream
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_stream_keygen()
-    {
-        return random_bytes(self::CRYPTO_STREAM_KEYBYTES);
-    }
-
-
-    /**
-     * Expand a key and nonce into a keystream of pseudorandom bytes.
-     *
-     * @param int $len Number of bytes desired
-     * @param string $nonce Number to be used Once; must be 24 bytes
-     * @param string $key XChaCha20 key
-     * @param bool $dontFallback
-     * @return string       Pseudorandom stream that can be XORed with messages
-     *                      to provide encryption (but not authentication; see
-     *                      Poly1305 or crypto_auth() for that, which is not
-     *                      optional for security)
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_XChaCha20::stream($len, $nonce, $key);
-        }
-        return ParagonIE_Sodium_Core_XChaCha20::stream($len, $nonce, $key);
-    }
-
-    /**
-     * DANGER! UNAUTHENTICATED ENCRYPTION!
-     *
-     * Unless you are following expert advice, do not use this feature.
-     *
-     * Algorithm: XChaCha20
-     *
-     * This DOES NOT provide ciphertext integrity.
-     *
-     * @param string $message Plaintext message
-     * @param string $nonce Number to be used Once; must be 24 bytes
-     * @param string $key Encryption key
-     * @return string         Encrypted text which is vulnerable to chosen-
-     *                        ciphertext attacks unless you implement some
-     *                        other mitigation to the ciphertext (i.e.
-     *                        Encrypt then MAC)
-     * @param bool $dontFallback
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    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);
-
-        /* 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($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 (PHP_INT_SIZE === 4) {
-            return ParagonIE_Sodium_Core32_XChaCha20::streamXorIc($message, $nonce, $key);
-        }
-        return ParagonIE_Sodium_Core_XChaCha20::streamXorIc($message, $nonce, $key);
-    }
-
-    /**
-     * Return a secure random key for use with crypto_stream_xchacha20
-     *
-     * @return string
-     * @throws Exception
-     * @throws Error
-     */
-    public static function crypto_stream_xchacha20_keygen()
-    {
-        return random_bytes(self::CRYPTO_STREAM_XCHACHA20_KEYBYTES);
-    }
-
-    /**
-     * Cache-timing-safe implementation of hex2bin().
-     *
-     * @param string $string Hexadecimal string
-     * @return string        Raw binary string
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress TooFewArguments
-     * @psalm-suppress MixedArgument
-     */
-    public static function hex2bin($string)
-    {
-        /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
-
-        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);
-        }
-        return ParagonIE_Sodium_Core_Util::hex2bin($string);
-    }
-
-    /**
-     * Increase a string (little endian)
-     *
-     * @param string $var
-     *
-     * @return void
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function increment(&$var)
-    {
-        /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
-
-        if (self::useNewSodiumAPI()) {
-            sodium_increment($var);
-            return;
-        }
-        if (self::use_fallback('increment')) {
-            $func = '\\Sodium\\increment';
-            $func($var);
-            return;
-        }
-
-        $len = ParagonIE_Sodium_Core_Util::strlen($var);
-        $c = 1;
-        $copy = '';
-        for ($i = 0; $i < $len; ++$i) {
-            $c += ParagonIE_Sodium_Core_Util::chrToInt(
-                ParagonIE_Sodium_Core_Util::substr($var, $i, 1)
-            );
-            $copy .= ParagonIE_Sodium_Core_Util::intToChr($c);
-            $c >>= 8;
-        }
-        $var = $copy;
-    }
-
-    /**
-     * @param string $str
-     * @return bool
-     *
-     * @throws SodiumException
-     */
-    public static function is_zero($str)
-    {
-        $d = 0;
-        for ($i = 0; $i < 32; ++$i) {
-            $d |= ParagonIE_Sodium_Core_Util::chrToInt($str[$i]);
-        }
-        return ((($d - 1) >> 31) & 1) === 1;
-    }
-
-    /**
-     * The equivalent to the libsodium minor version we aim to be compatible
-     * with (sans pwhash and memzero).
-     *
-     * @return int
-     */
-    public static function library_version_major()
-    {
-        if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MAJOR_VERSION')) {
-            return SODIUM_LIBRARY_MAJOR_VERSION;
-        }
-        if (self::use_fallback('library_version_major')) {
-            /** @psalm-suppress UndefinedFunction */
-            return (int) call_user_func('\\Sodium\\library_version_major');
-        }
-        return self::LIBRARY_VERSION_MAJOR;
-    }
-
-    /**
-     * The equivalent to the libsodium minor version we aim to be compatible
-     * with (sans pwhash and memzero).
-     *
-     * @return int
-     */
-    public static function library_version_minor()
-    {
-        if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MINOR_VERSION')) {
-            return SODIUM_LIBRARY_MINOR_VERSION;
-        }
-        if (self::use_fallback('library_version_minor')) {
-            /** @psalm-suppress UndefinedFunction */
-            return (int) call_user_func('\\Sodium\\library_version_minor');
-        }
-        return self::LIBRARY_VERSION_MINOR;
-    }
-
-    /**
-     * Compare two strings.
-     *
-     * @param string $left
-     * @param string $right
-     * @return int
-     * @throws SodiumException
-     * @throws TypeError
-     * @psalm-suppress MixedArgument
-     */
-    public static function memcmp($left, $right)
-    {
-        /* Type checks: */
-        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::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);
-    }
-
-    /**
-     * It's actually not possible to zero memory buffers in PHP. You need the
-     * native library for that.
-     *
-     * @param string|null $var
-     * @param-out string|null $var
-     *
-     * @return void
-     * @throws SodiumException (Unless libsodium is installed)
-     * @throws TypeError
-     * @psalm-suppress TooFewArguments
-     */
-    public static function memzero(&$var)
-    {
-        /* Type checks: */
-        ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
-
-        if (self::useNewSodiumAPI()) {
-            /** @psalm-suppress MixedArgument */
-            sodium_memzero($var);
-            return;
-        }
-        if (self::use_fallback('memzero')) {
-            $func = '\\Sodium\\memzero';
-            $func($var);
-            if ($var === null) {
-                return;
-            }
-        }
-        // This is the best we can do.
-        throw new SodiumException(
-            'This is not implemented in sodium_compat, as it is not possible to securely wipe memory from PHP. ' .
-            'To fix this error, make sure libsodium is installed and the PHP extension is enabled.'
-        );
-    }
-
-    /**
-     * @param string $unpadded
-     * @param int $blockSize
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    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);
-
-        $unpadded = (string) $unpadded;
-        $blockSize = (int) $blockSize;
-
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return (string) sodium_pad($unpadded, $blockSize);
-        }
-
-        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);
-        } else {
-            $xpadlen -= $unpadded_len % $blockSize;
-        }
-
-        $xpadded_len = $unpadded_len + $xpadlen;
-        $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";
-                } else {
-                    $padded[$j] = $unpadded[$j];
-                }
-                /** @var int $k */
-                $k -= $st;
-                $st = (int) (~(
-                            (
-                                (
-                                    ($k >> 48)
-                                        |
-                                    ($k >> 32)
-                                        |
-                                    ($k >> 16)
-                                        |
-                                    $k
-                                ) - 1
-                            ) >> 16
-                        )
-                    ) & 1;
-                $i += $st;
-            }
-        }
-
-        $mask = 0;
-        $tail = $xpadded_len;
-        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);
-            # 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)
-                    |
-                (0x80 & $barrier_mask)
-            );
-            # mask |= barrier_mask;
-            $mask |= $barrier_mask;
-        }
-        return $padded;
-    }
-
-    /**
-     * @param string $padded
-     * @param int $blockSize
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    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);
-
-        $padded = (string) $padded;
-        $blockSize = (int) $blockSize;
-
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return (string) sodium_unpad($padded, $blockSize);
-        }
-        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');
-        }
-
-        # tail = &padded[padded_len - 1U];
-        $tail = $padded_len - 1;
-
-        $acc = 0;
-        $valid = 0;
-        $pad_len = 0;
-
-        $found = 0;
-        for ($i = 0; $i < $blockSize; ++$i) {
-            # c = 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)
-                ) >> 7
-            ) & 1;
-            $is_barrier &= ~$found;
-            $found |= $is_barrier;
-
-            # acc |= c;
-            $acc |= $c;
-
-            # pad_len |= i & (1U + ~is_barrier);
-            $pad_len |= $i & (1 + ~$is_barrier);
-
-            # valid |= (unsigned char) is_barrier;
-            $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');
-        }
-        return ParagonIE_Sodium_Core_Util::substr($padded, 0, $unpadded_len);
-    }
-
-    /**
-     * Will sodium_compat run fast on the current hardware and PHP configuration?
-     *
-     * @return bool
-     */
-    public static function polyfill_is_fast()
-    {
-        if (extension_loaded('sodium')) {
-            return true;
-        }
-        if (extension_loaded('libsodium')) {
-            return true;
-        }
-        return PHP_INT_SIZE === 8;
-    }
-
-    /**
-     * Generate a string of bytes from the kernel's CSPRNG.
-     * Proudly uses /dev/urandom (if getrandom(2) is not available).
-     *
-     * @param int $numBytes
-     * @return string
-     * @throws Exception
-     * @throws TypeError
-     */
-    public static function randombytes_buf($numBytes)
-    {
-        /* Type checks: */
-        if (!is_int($numBytes)) {
-            if (is_numeric($numBytes)) {
-                $numBytes = (int) $numBytes;
-            } else {
-                throw new TypeError(
-                    'Argument 1 must be an integer, ' . gettype($numBytes) . ' given.'
-                );
-            }
-        }
-        if (self::use_fallback('randombytes_buf')) {
-            return (string) call_user_func('\\Sodium\\randombytes_buf', $numBytes);
-        }
-        return random_bytes($numBytes);
-    }
-
-    /**
-     * Generate an integer between 0 and $range (non-inclusive).
-     *
-     * @param int $range
-     * @return int
-     * @throws Exception
-     * @throws Error
-     * @throws TypeError
-     */
-    public static function randombytes_uniform($range)
-    {
-        /* Type checks: */
-        if (!is_int($range)) {
-            if (is_numeric($range)) {
-                $range = (int) $range;
-            } else {
-                throw new TypeError(
-                    'Argument 1 must be an integer, ' . gettype($range) . ' given.'
-                );
-            }
-        }
-        if (self::use_fallback('randombytes_uniform')) {
-            return (int) call_user_func('\\Sodium\\randombytes_uniform', $range);
-        }
-        return random_int(0, $range - 1);
-    }
-
-    /**
-     * Generate a random 16-bit integer.
-     *
-     * @return int
-     * @throws Exception
-     * @throws Error
-     * @throws TypeError
-     */
-    public static function randombytes_random16()
-    {
-        if (self::use_fallback('randombytes_random16')) {
-            return (int) call_user_func('\\Sodium\\randombytes_random16');
-        }
-        return random_int(0, 65535);
-    }
-
-    /**
-     * @param string $p
-     * @param bool $dontFallback
-     * @return bool
-     * @throws SodiumException
-     */
-    public static function ristretto255_is_valid_point($p, $dontFallback = false)
-    {
-        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') {
-                return false;
-            }
-            throw $ex;
-        }
-    }
-
-    /**
-     * @param string $p
-     * @param string $q
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_add($p, $q, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_add($p, $q);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_add($p, $q);
-    }
-
-    /**
-     * @param string $p
-     * @param string $q
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_sub($p, $q, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_sub($p, $q);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_sub($p, $q);
-    }
-
-    /**
-     * @param string $r
-     * @param bool $dontFallback
-     * @return string
-     *
-     * @throws SodiumException
-     */
-    public static function ristretto255_from_hash($r, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_from_hash($r);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_from_hash($r);
-    }
-
-    /**
-     * @param bool $dontFallback
-     * @return string
-     *
-     * @throws SodiumException
-     */
-    public static function ristretto255_random($dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_random();
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_random();
-    }
-
-    /**
-     * @param bool $dontFallback
-     * @return string
-     *
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_random($dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_random();
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_random();
-    }
-
-    /**
-     * @param string $s
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_invert($s, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_invert($s);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_invert($s);
-    }
-    /**
-     * @param string $s
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_negate($s, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_negate($s);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_negate($s);
-    }
-
-    /**
-     * @param string $s
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_complement($s, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_complement($s);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_complement($s);
-    }
-
-    /**
-     * @param string $x
-     * @param string $y
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_add($x, $y, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_add($x, $y);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_add($x, $y);
-    }
-
-    /**
-     * @param string $x
-     * @param string $y
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_sub($x, $y, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_sub($x, $y);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_sub($x, $y);
-    }
-
-    /**
-     * @param string $x
-     * @param string $y
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_mul($x, $y, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_mul($x, $y);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_mul($x, $y);
-    }
-
-    /**
-     * @param string $n
-     * @param string $p
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalarmult_ristretto255($n, $p, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_scalarmult_ristretto255($n, $p);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255($n, $p);
-    }
-
-    /**
-     * @param string $n
-     * @param string $p
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function scalarmult_ristretto255_base($n, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_scalarmult_ristretto255_base($n);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255_base($n);
-    }
-
-    /**
-     * @param string $s
-     * @param bool $dontFallback
-     * @return string
-     * @throws SodiumException
-     */
-    public static function ristretto255_scalar_reduce($s, $dontFallback = false)
-    {
-        if (self::useNewSodiumAPI() && !$dontFallback) {
-            return sodium_crypto_core_ristretto255_scalar_reduce($s);
-        }
-        return ParagonIE_Sodium_Core_Ristretto255::sc_reduce($s);
-    }
-
-    /**
-     * Runtime testing method for 32-bit platforms.
-     *
-     * Usage: If runtime_speed_test() returns FALSE, then our 32-bit
-     *        implementation is to slow to use safely without risking timeouts.
-     *        If this happens, install sodium from PECL to get acceptable
-     *        performance.
-     *
-     * @param int $iterations Number of multiplications to attempt
-     * @param int $maxTimeout Milliseconds
-     * @return bool           TRUE if we're fast enough, FALSE is not
-     * @throws SodiumException
-     */
-    public static function runtime_speed_test($iterations, $maxTimeout)
-    {
-        if (self::polyfill_is_fast()) {
-            return true;
-        }
-        /** @var float $end */
-        $end = 0.0;
-        /** @var float $start */
-        $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) {
-            /** @var ParagonIE_Sodium_Core32_Int64 $b */
-            $b = ParagonIE_Sodium_Core32_Int64::fromInt(random_int(3, 1 << 16));
-            $a->mulInt64($b);
-        }
-        /** @var float $end */
-        $end = microtime(true);
-        /** @var int $diff */
-        $diff = (int) ceil(($end - $start) * 1000);
-        return $diff < $maxTimeout;
-    }
-
-    /**
-     * Add two numbers (little-endian unsigned), storing the value in the first
-     * parameter.
-     *
-     * This mutates $val.
-     *
-     * @param string $val
-     * @param string $addv
-     * @return void
-     * @throws SodiumException
-     */
-    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');
-        }
-        $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;
-        }
-        $val = ParagonIE_Sodium_Core_Util::intArrayToString($A);
-    }
-
-    /**
-     * This emulates libsodium's version_string() function, except ours is
-     * prefixed with 'polyfill-'.
-     *
-     * @return string
-     * @psalm-suppress MixedInferredReturnType
-     * @psalm-suppress UndefinedFunction
-     */
-    public static function version_string()
-    {
-        if (self::useNewSodiumAPI()) {
-            return (string) sodium_version_string();
-        }
-        if (self::use_fallback('version_string')) {
-            return (string) call_user_func('\\Sodium\\version_string');
-        }
-        return (string) self::VERSION_STRING;
-    }
-
-    /**
-     * Should we use the libsodium core function instead?
-     * This is always a good idea, if it's available. (Unless we're in the
-     * middle of running our unit test suite.)
-     *
-     * If ext/libsodium is available, use it. Return TRUE.
-     * Otherwise, we have to use the code provided herein. Return FALSE.
-     *
-     * @param string $sodium_func_name
-     *
-     * @return bool
-     */
-    protected static function use_fallback($sodium_func_name = '')
-    {
-        static $res = null;
-        if ($res === null) {
-            $res = extension_loaded('libsodium') && PHP_VERSION_ID >= 50300;
-        }
-        if ($res === false) {
-            // No libsodium installed
-            return false;
-        }
-        if (self::$disableFallbackForUnitTests) {
-            // Don't fallback. Use the PHP implementation.
-            return false;
-        }
-        if (!empty($sodium_func_name)) {
-            return is_callable('\\Sodium\\' . $sodium_func_name);
-        }
-        return true;
-    }
-
-    /**
-     * Libsodium as implemented in PHP 7.2
-     * and/or ext/sodium (via PECL)
-     *
-     * @ref https://wiki.php.net/rfc/libsodium
-     * @return bool
-     */
-    protected static function useNewSodiumAPI()
-    {
-        static $res = null;
-        if ($res === null) {
-            $res = PHP_VERSION_ID >= 70000 && extension_loaded('sodium');
-        }
-        if (self::$disableFallbackForUnitTests) {
-            // Don't fallback. Use the PHP implementation.
-            return false;
-        }
-        return (bool) $res;
-    }
+			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);
+		}
+		return ParagonIE_Sodium_Crypto::generichash_init_salt_personal($key, $length, $salt, $personal);
+	}
+
+	/**
+	 * Update a BLAKE2b hashing context with additional data.
+	 *
+	 * @param string $ctx    BLAKE2 hashing context. Generated by crypto_generichash_init().
+	 *                       $ctx is passed by reference and gets updated in-place.
+	 * @param-out string $ctx
+	 * @param string $message The message to append to the existing hash state.
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress ReferenceConstraintViolation
+	 */
+	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);
+
+		if (self::useNewSodiumAPI()) {
+			sodium_crypto_generichash_update($ctx, $message);
+			return;
+		}
+		if (self::use_fallback('crypto_generichash_update')) {
+			$func = '\\Sodium\\crypto_generichash_update';
+			$func($ctx, $message);
+			return;
+		}
+		if (PHP_INT_SIZE === 4) {
+			$ctx = ParagonIE_Sodium_Crypto32::generichash_update($ctx, $message);
+		} else {
+			$ctx = ParagonIE_Sodium_Crypto::generichash_update($ctx, $message);
+		}
+	}
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_generichash_keygen()
+	{
+		return random_bytes(self::CRYPTO_GENERICHASH_KEYBYTES);
+	}
+
+	/**
+	 * @param int $subkey_len
+	 * @param int $subkey_id
+	 * @param string $context
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function crypto_kdf_derive_from_key(
+		$subkey_len,
+		$subkey_id,
+		$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;
+
+		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_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($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);
+		$state = self::crypto_generichash_init_salt_personal(
+			$key,
+			$subkey_len,
+			$salt,
+			$context
+		);
+		return self::crypto_generichash_final($state, $subkey_len);
+	}
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_kdf_keygen()
+	{
+		return random_bytes(self::CRYPTO_KDF_KEYBYTES);
+	}
+
+	/**
+	 * Perform a key exchange, between a designated client and a server.
+	 *
+	 * Typically, you would designate one machine to be the client and the
+	 * other to be the server. The first two keys are what you'd expect for
+	 * scalarmult() below, but the latter two public keys don't swap places.
+	 *
+	 * | ALICE                          | BOB                                 |
+	 * | Client                         | Server                              |
+	 * |--------------------------------|-------------------------------------|
+	 * | shared = crypto_kx(            | shared = crypto_kx(                 |
+	 * |     alice_sk,                  |     bob_sk,                         | <- contextual
+	 * |     bob_pk,                    |     alice_pk,                       | <- contextual
+	 * |     alice_pk,                  |     alice_pk,                       | <----- static
+	 * |     bob_pk                     |     bob_pk                          | <----- static
+	 * | )                              | )                                   |
+	 *
+	 * They are used along with the scalarmult product to generate a 256-bit
+	 * BLAKE2b hash unique to the client and server keys.
+	 *
+	 * @param string $my_secret
+	 * @param string $their_public
+	 * @param string $client_public
+	 * @param string $server_public
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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($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(
+					$my_secret,
+					$their_public,
+					$client_public,
+					$server_public
+				);
+			}
+		}
+		if (self::use_fallback('crypto_kx')) {
+			return (string) call_user_func(
+				'\\Sodium\\crypto_kx',
+				$my_secret,
+				$their_public,
+				$client_public,
+				$server_public
+			);
+		}
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::keyExchange(
+				$my_secret,
+				$their_public,
+				$client_public,
+				$server_public
+			);
+		}
+		return ParagonIE_Sodium_Crypto::keyExchange(
+			$my_secret,
+			$their_public,
+			$client_public,
+			$server_public
+		);
+	}
+
+	/**
+	 * @param string $seed
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function crypto_kx_seed_keypair($seed)
+	{
+		ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
+
+		$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');
+		}
+
+		$sk = self::crypto_generichash($seed, '', self::CRYPTO_KX_SECRETKEYBYTES);
+		$pk = self::crypto_scalarmult_base($sk);
+		return $sk . $pk;
+	}
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public static function crypto_kx_keypair()
+	{
+		$sk = self::randombytes_buf(self::CRYPTO_KX_SECRETKEYBYTES);
+		$pk = self::crypto_scalarmult_base($sk);
+		return $sk . $pk;
+	}
+
+	/**
+	 * @param string $keypair
+	 * @param string $serverPublicKey
+	 * @return array{0: string, 1: string}
+	 * @throws SodiumException
+	 */
+	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);
+
+		$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($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);
+		return array(
+			ParagonIE_Sodium_Core_Util::substr(
+				$sessionKeys,
+				0,
+				self::CRYPTO_KX_SESSIONKEYBYTES
+			),
+			ParagonIE_Sodium_Core_Util::substr(
+				$sessionKeys,
+				self::CRYPTO_KX_SESSIONKEYBYTES,
+				self::CRYPTO_KX_SESSIONKEYBYTES
+			)
+		);
+	}
+
+	/**
+	 * @param string $keypair
+	 * @param string $clientPublicKey
+	 * @return array{0: string, 1: string}
+	 * @throws SodiumException
+	 */
+	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);
+
+		$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($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);
+		return array(
+			ParagonIE_Sodium_Core_Util::substr(
+				$sessionKeys,
+				self::CRYPTO_KX_SESSIONKEYBYTES,
+				self::CRYPTO_KX_SESSIONKEYBYTES
+			),
+			ParagonIE_Sodium_Core_Util::substr(
+				$sessionKeys,
+				0,
+				self::CRYPTO_KX_SESSIONKEYBYTES
+			)
+		);
+	}
+
+	/**
+	 * @param string $kp
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function crypto_kx_secretkey($kp)
+	{
+		return ParagonIE_Sodium_Core_Util::substr(
+			$kp,
+			0,
+			self::CRYPTO_KX_SECRETKEYBYTES
+		);
+	}
+
+	/**
+	 * @param string $kp
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function crypto_kx_publickey($kp)
+	{
+		return ParagonIE_Sodium_Core_Util::substr(
+			$kp,
+			self::CRYPTO_KX_SECRETKEYBYTES,
+			self::CRYPTO_KX_PUBLICKEYBYTES
+		);
+	}
+
+	/**
+	 * @param int $outlen
+	 * @param string $passwd
+	 * @param string $salt
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @param int|null $alg
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		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);
+		}
+		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(
+			'This is not implemented, as it is not possible to implement Argon2i with acceptable performance in pure-PHP'
+		);
+	}
+
+	/**
+	 * !Exclusive to sodium_compat!
+	 *
+	 * This returns TRUE if the native crypto_pwhash API is available by libsodium.
+	 * This returns FALSE if only sodium_compat is available.
+	 *
+	 * @return bool
+	 */
+	public static function crypto_pwhash_is_available()
+	{
+		if (self::useNewSodiumAPI()) {
+			return true;
+		}
+		if (self::use_fallback('crypto_pwhash')) {
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @param string $passwd
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		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);
+		}
+		// This is the best we can do.
+		throw new SodiumException(
+			'This is not implemented, as it is not possible to implement Argon2i with acceptable performance in pure-PHP'
+		);
+	}
+
+	/**
+	 * Do we need to rehash this password?
+	 *
+	 * @param string $hash
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return bool
+	 * @throws SodiumException
+	 */
+	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);
+
+		// Just grab the first 4 pieces.
+		$pieces = explode('$', (string) $hash);
+		$prefix = implode('$', array_slice($pieces, 0, 4));
+
+		// Rebuild the expected header.
+		/** @var int $ops */
+		$ops = (int) $opslimit;
+		/** @var int $mem */
+		$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);
+	}
+
+	/**
+	 * @param string $passwd
+	 * @param string $hash
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		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);
+		}
+		// This is the best we can do.
+		throw new SodiumException(
+			'This is not implemented, as it is not possible to implement Argon2i with acceptable performance in pure-PHP'
+		);
+	}
+
+	/**
+	 * @param int $outlen
+	 * @param string $passwd
+	 * @param string $salt
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return string
+	 * @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
+			);
+		}
+		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
+			);
+		}
+		// This is the best we can do.
+		throw new SodiumException(
+			'This is not implemented, as it is not possible to implement Scrypt with acceptable performance in pure-PHP'
+		);
+	}
+
+	/**
+	 * !Exclusive to sodium_compat!
+	 *
+	 * This returns TRUE if the native crypto_pwhash API is available by libsodium.
+	 * This returns FALSE if only sodium_compat is available.
+	 *
+	 * @return bool
+	 */
+	public static function crypto_pwhash_scryptsalsa208sha256_is_available()
+	{
+		if (self::useNewSodiumAPI()) {
+			return true;
+		}
+		if (self::use_fallback('crypto_pwhash_scryptsalsa208sha256')) {
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @param string $passwd
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	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);
+
+		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(
+				'\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str',
+				(string) $passwd,
+				(int) $opslimit,
+				(int) $memlimit
+			);
+		}
+		// This is the best we can do.
+		throw new SodiumException(
+			'This is not implemented, as it is not possible to implement Scrypt with acceptable performance in pure-PHP'
+		);
+	}
+
+	/**
+	 * @param string $passwd
+	 * @param string $hash
+	 * @return bool
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	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);
+
+		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(
+				'\\Sodium\\crypto_pwhash_scryptsalsa208sha256_str_verify',
+				(string) $passwd,
+				(string) $hash
+			);
+		}
+		// This is the best we can do.
+		throw new SodiumException(
+			'This is not implemented, as it is not possible to implement Scrypt with acceptable performance in pure-PHP'
+		);
+	}
+
+	/**
+	 * Calculate the shared secret between your secret key and your
+	 * recipient's public key.
+	 *
+	 * Algorithm: X25519 (ECDH over Curve25519)
+	 *
+	 * @param string $secretKey
+	 * @param string $publicKey
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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($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);
+		}
+		return ParagonIE_Sodium_Crypto::scalarmult($secretKey, $publicKey);
+	}
+
+	/**
+	 * Calculate an X25519 public key from an X25519 secret key.
+	 *
+	 * @param string $secretKey
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress TooFewArguments
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_scalarmult_base($secretKey)
+	{
+		/* Type checks: */
+		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 (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 (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);
+		}
+		return ParagonIE_Sodium_Crypto::scalarmult_base($secretKey);
+	}
+
+	/**
+	 * Authenticated symmetric-key encryption.
+	 *
+	 * Algorithm: XSalsa20-Poly1305
+	 *
+	 * @param string $plaintext The message you're encrypting
+	 * @param string $nonce A Number to be used Once; must be 24 bytes
+	 * @param string $key Symmetric encryption key
+	 * @return string           Ciphertext with Poly1305 MAC
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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);
+		}
+		return ParagonIE_Sodium_Crypto::secretbox($plaintext, $nonce, $key);
+	}
+
+	/**
+	 * Decrypts a message previously encrypted with crypto_secretbox().
+	 *
+	 * @param string $ciphertext Ciphertext with Poly1305 MAC
+	 * @param string $nonce      A Number to be used Once; must be 24 bytes
+	 * @param string $key        Symmetric encryption key
+	 * @return string            Original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	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);
+
+		/* 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($key) !== self::CRYPTO_SECRETBOX_KEYBYTES) {
+			throw new SodiumException('Argument 3 must be CRYPTO_SECRETBOX_KEYBYTES long.');
+		}
+
+		if (self::useNewSodiumAPI()) {
+			/**
+			 * @psalm-suppress InvalidReturnStatement
+			 * @psalm-suppress FalsableReturnStatement
+			 */
+			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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::secretbox_open($ciphertext, $nonce, $key);
+		}
+		return ParagonIE_Sodium_Crypto::secretbox_open($ciphertext, $nonce, $key);
+	}
+
+	/**
+	 * Return a secure random key for use with crypto_secretbox
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_secretbox_keygen()
+	{
+		return random_bytes(self::CRYPTO_SECRETBOX_KEYBYTES);
+	}
+
+	/**
+	 * Authenticated symmetric-key encryption.
+	 *
+	 * Algorithm: XChaCha20-Poly1305
+	 *
+	 * @param string $plaintext The message you're encrypting
+	 * @param string $nonce     A Number to be used Once; must be 24 bytes
+	 * @param string $key       Symmetric encryption key
+	 * @return string           Ciphertext with Poly1305 MAC
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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);
+		}
+		return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305($plaintext, $nonce, $key);
+	}
+	/**
+	 * Decrypts a message previously encrypted with crypto_secretbox_xchacha20poly1305().
+	 *
+	 * @param string $ciphertext Ciphertext with Poly1305 MAC
+	 * @param string $nonce      A Number to be used Once; must be 24 bytes
+	 * @param string $key        Symmetric encryption key
+	 * @return string            Original plaintext message
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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);
+		}
+		return ParagonIE_Sodium_Crypto::secretbox_xchacha20poly1305_open($ciphertext, $nonce, $key);
+	}
+
+	/**
+	 * @param string $key
+	 * @return array<int, string> Returns a state and a header.
+	 * @throws Exception
+	 * @throws SodiumException
+	 */
+	public static function crypto_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);
+	}
+
+	/**
+	 * @param string $header
+	 * @param string $key
+	 * @return string Returns a state.
+	 * @throws Exception
+	 */
+	public static function crypto_secretstream_xchacha20poly1305_init_pull($header, $key)
+	{
+		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);
+		}
+		return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_init_pull($key, $header);
+	}
+
+	/**
+	 * @param string $state
+	 * @param string $msg
+	 * @param string $aad
+	 * @param int $tag
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function crypto_secretstream_xchacha20poly1305_push(&$state, $msg, $aad = '', $tag = 0)
+	{
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_push(
+				$state,
+				$msg,
+				$aad,
+				$tag
+			);
+		}
+		return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_push(
+			$state,
+			$msg,
+			$aad,
+			$tag
+		);
+	}
+
+	/**
+	 * @param string $state
+	 * @param string $msg
+	 * @param string $aad
+	 * @return bool|array{0: string, 1: int}
+	 * @throws SodiumException
+	 */
+	public static function crypto_secretstream_xchacha20poly1305_pull(&$state, $msg, $aad = '')
+	{
+		if (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_pull(
+				$state,
+				$msg,
+				$aad
+			);
+		}
+		return ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_pull(
+			$state,
+			$msg,
+			$aad
+		);
+	}
+
+	/**
+	 * @return string
+	 * @throws Exception
+	 */
+	public static function crypto_secretstream_xchacha20poly1305_keygen()
+	{
+		return random_bytes(self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES);
+	}
+
+	/**
+	 * @param string $state
+	 * @return void
+	 * @throws SodiumException
+	 */
+	public static function crypto_secretstream_xchacha20poly1305_rekey(&$state)
+	{
+		if (PHP_INT_SIZE === 4) {
+			ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_rekey($state);
+		} else {
+			ParagonIE_Sodium_Crypto::secretstream_xchacha20poly1305_rekey($state);
+		}
+	}
+
+	/**
+	 * Calculates a SipHash-2-4 hash of a message for a given key.
+	 *
+	 * @param string $message Input message
+	 * @param string $key SipHash-2-4 key
+	 * @return string         Hash
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	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);
+
+		/* 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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_SipHash::sipHash24($message, $key);
+		}
+		return ParagonIE_Sodium_Core_SipHash::sipHash24($message, $key);
+	}
+
+	/**
+	 * Return a secure random key for use with crypto_shorthash
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_shorthash_keygen()
+	{
+		return random_bytes(self::CRYPTO_SHORTHASH_KEYBYTES);
+	}
+
+	/**
+	 * Returns a signed message. You probably want crypto_sign_detached()
+	 * instead, which only returns the signature.
+	 *
+	 * Algorithm: Ed25519 (EdDSA over Curve25519)
+	 *
+	 * @param string $message Message to be signed.
+	 * @param string $secretKey Secret signing key.
+	 * @return string           Signed message (signature is prefixed).
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	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);
+
+		/* 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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::sign($message, $secretKey);
+		}
+		return ParagonIE_Sodium_Crypto::sign($message, $secretKey);
+	}
+
+	/**
+	 * Validates a signed message then returns the message.
+	 *
+	 * @param string $signedMessage A signed message
+	 * @param string $publicKey A public key
+	 * @return string               The original message (if the signature is
+	 *                              valid for this public key)
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress MixedReturnStatement
+	 */
+	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);
+
+		/* 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($publicKey) !== self::CRYPTO_SIGN_PUBLICKEYBYTES) {
+			throw new SodiumException('Argument 2 must be CRYPTO_SIGN_PUBLICKEYBYTES long.');
+		}
+
+		if (self::useNewSodiumAPI()) {
+			/**
+			 * @psalm-suppress InvalidReturnStatement
+			 * @psalm-suppress FalsableReturnStatement
+			 */
+			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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::sign_open($signedMessage, $publicKey);
+		}
+		return ParagonIE_Sodium_Crypto::sign_open($signedMessage, $publicKey);
+	}
+
+	/**
+	 * Generate a new random Ed25519 keypair.
+	 *
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	public static function crypto_sign_keypair()
+	{
+		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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_Ed25519::keypair();
+		}
+		return ParagonIE_Sodium_Core_Ed25519::keypair();
+	}
+
+	/**
+	 * @param string $sk
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 */
+	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;
+
+		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 (self::useNewSodiumAPI()) {
+			return sodium_crypto_sign_keypair_from_secretkey_and_publickey($sk, $pk);
+		}
+		return $sk . $pk;
+	}
+
+	/**
+	 * Generate an Ed25519 keypair from a seed.
+	 *
+	 * @param string $seed Input seed
+	 * @return string      Keypair
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_sign_seed_keypair($seed)
+	{
+		ParagonIE_Sodium_Core_Util::declareScalarType($seed, 'string', 1);
+
+		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);
+		}
+		$publicKey = '';
+		$secretKey = '';
+		if (PHP_INT_SIZE === 4) {
+			ParagonIE_Sodium_Core32_Ed25519::seed_keypair($publicKey, $secretKey, $seed);
+		} else {
+			ParagonIE_Sodium_Core_Ed25519::seed_keypair($publicKey, $secretKey, $seed);
+		}
+		return $secretKey . $publicKey;
+	}
+
+	/**
+	 * Extract an Ed25519 public key from an Ed25519 keypair.
+	 *
+	 * @param string $keypair Keypair
+	 * @return string         Public key
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_sign_publickey($keypair)
+	{
+		/* Type checks: */
+		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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_Ed25519::publickey($keypair);
+		}
+		return ParagonIE_Sodium_Core_Ed25519::publickey($keypair);
+	}
+
+	/**
+	 * Calculate an Ed25519 public key from an Ed25519 secret key.
+	 *
+	 * @param string $secretKey Your Ed25519 secret key
+	 * @return string           The corresponding Ed25519 public key
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_sign_publickey_from_secretkey($secretKey)
+	{
+		/* Type checks: */
+		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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_Ed25519::publickey_from_secretkey($secretKey);
+		}
+		return ParagonIE_Sodium_Core_Ed25519::publickey_from_secretkey($secretKey);
+	}
+
+	/**
+	 * Extract an Ed25519 secret key from an Ed25519 keypair.
+	 *
+	 * @param string $keypair Keypair
+	 * @return string         Secret key
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_sign_secretkey($keypair)
+	{
+		/* Type checks: */
+		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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_Ed25519::secretkey($keypair);
+		}
+		return ParagonIE_Sodium_Core_Ed25519::secretkey($keypair);
+	}
+
+	/**
+	 * Calculate the Ed25519 signature of a message and return ONLY the signature.
+	 *
+	 * Algorithm: Ed25519 (EdDSA over Curve25519)
+	 *
+	 * @param string $message Message to be signed
+	 * @param string $secretKey Secret signing key
+	 * @return string           Digital signature
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Crypto32::sign_detached($message, $secretKey);
+		}
+		return ParagonIE_Sodium_Crypto::sign_detached($message, $secretKey);
+	}
+
+	/**
+	 * Verify the Ed25519 signature of a message.
+	 *
+	 * @param string $signature Digital sginature
+	 * @param string $message Message to be verified
+	 * @param string $publicKey Public key
+	 * @return bool             TRUE if this signature is good for this public key;
+	 *                          FALSE otherwise
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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);
+		}
+		return ParagonIE_Sodium_Crypto::sign_verify_detached($signature, $message, $publicKey);
+	}
+
+	/**
+	 * Convert an Ed25519 public key to a Curve25519 public key
+	 *
+	 * @param string $pk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_sign_ed25519_pk_to_curve25519($pk)
+	{
+		/* Type checks: */
+		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 (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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_Ed25519::pk_to_curve25519($pk);
+		}
+		return ParagonIE_Sodium_Core_Ed25519::pk_to_curve25519($pk);
+	}
+
+	/**
+	 * Convert an Ed25519 secret key to a Curve25519 secret key
+	 *
+	 * @param string $sk
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function crypto_sign_ed25519_sk_to_curve25519($sk)
+	{
+		/* Type checks: */
+		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 (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);
+		}
+
+		$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
+		);
+		return ParagonIE_Sodium_Core_Util::substr($h, 0, 32);
+	}
+
+	/**
+	 * Expand a key and nonce into a keystream of pseudorandom bytes.
+	 *
+	 * @param int $len Number of bytes desired
+	 * @param string $nonce Number to be used Once; must be 24 bytes
+	 * @param string $key XSalsa20 key
+	 * @return string       Pseudorandom stream that can be XORed with messages
+	 *                      to provide encryption (but not authentication; see
+	 *                      Poly1305 or crypto_auth() for that, which is not
+	 *                      optional for security)
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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);
+		}
+		return ParagonIE_Sodium_Core_XSalsa20::xsalsa20($len, $nonce, $key);
+	}
+
+	/**
+	 * DANGER! UNAUTHENTICATED ENCRYPTION!
+	 *
+	 * Unless you are following expert advice, do not use this feature.
+	 *
+	 * Algorithm: XSalsa20
+	 *
+	 * This DOES NOT provide ciphertext integrity.
+	 *
+	 * @param string $message Plaintext message
+	 * @param string $nonce Number to be used Once; must be 24 bytes
+	 * @param string $key Encryption key
+	 * @return string         Encrypted text which is vulnerable to chosen-
+	 *                        ciphertext attacks unless you implement some
+	 *                        other mitigation to the ciphertext (i.e.
+	 *                        Encrypt then MAC)
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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::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);
+		}
+		return ParagonIE_Sodium_Core_XSalsa20::xsalsa20_xor($message, $nonce, $key);
+	}
+
+	/**
+	 * Return a secure random key for use with crypto_stream
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_stream_keygen()
+	{
+		return random_bytes(self::CRYPTO_STREAM_KEYBYTES);
+	}
+
+
+	/**
+	 * Expand a key and nonce into a keystream of pseudorandom bytes.
+	 *
+	 * @param int $len Number of bytes desired
+	 * @param string $nonce Number to be used Once; must be 24 bytes
+	 * @param string $key XChaCha20 key
+	 * @param bool $dontFallback
+	 * @return string       Pseudorandom stream that can be XORed with messages
+	 *                      to provide encryption (but not authentication; see
+	 *                      Poly1305 or crypto_auth() for that, which is not
+	 *                      optional for security)
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_XChaCha20::stream($len, $nonce, $key);
+		}
+		return ParagonIE_Sodium_Core_XChaCha20::stream($len, $nonce, $key);
+	}
+
+	/**
+	 * DANGER! UNAUTHENTICATED ENCRYPTION!
+	 *
+	 * Unless you are following expert advice, do not use this feature.
+	 *
+	 * Algorithm: XChaCha20
+	 *
+	 * This DOES NOT provide ciphertext integrity.
+	 *
+	 * @param string $message Plaintext message
+	 * @param string $nonce Number to be used Once; must be 24 bytes
+	 * @param string $key Encryption key
+	 * @return string         Encrypted text which is vulnerable to chosen-
+	 *                        ciphertext attacks unless you implement some
+	 *                        other mitigation to the ciphertext (i.e.
+	 *                        Encrypt then MAC)
+	 * @param bool $dontFallback
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	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);
+
+		/* 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($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 (PHP_INT_SIZE === 4) {
+			return ParagonIE_Sodium_Core32_XChaCha20::streamXorIc($message, $nonce, $key);
+		}
+		return ParagonIE_Sodium_Core_XChaCha20::streamXorIc($message, $nonce, $key);
+	}
+
+	/**
+	 * Return a secure random key for use with crypto_stream_xchacha20
+	 *
+	 * @return string
+	 * @throws Exception
+	 * @throws Error
+	 */
+	public static function crypto_stream_xchacha20_keygen()
+	{
+		return random_bytes(self::CRYPTO_STREAM_XCHACHA20_KEYBYTES);
+	}
+
+	/**
+	 * Cache-timing-safe implementation of hex2bin().
+	 *
+	 * @param string $string Hexadecimal string
+	 * @return string        Raw binary string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress TooFewArguments
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function hex2bin($string)
+	{
+		/* Type checks: */
+		ParagonIE_Sodium_Core_Util::declareScalarType($string, 'string', 1);
+
+		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);
+		}
+		return ParagonIE_Sodium_Core_Util::hex2bin($string);
+	}
+
+	/**
+	 * Increase a string (little endian)
+	 *
+	 * @param string $var
+	 *
+	 * @return void
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function increment(&$var)
+	{
+		/* Type checks: */
+		ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
+
+		if (self::useNewSodiumAPI()) {
+			sodium_increment($var);
+			return;
+		}
+		if (self::use_fallback('increment')) {
+			$func = '\\Sodium\\increment';
+			$func($var);
+			return;
+		}
+
+		$len = ParagonIE_Sodium_Core_Util::strlen($var);
+		$c = 1;
+		$copy = '';
+		for ($i = 0; $i < $len; ++$i) {
+			$c += ParagonIE_Sodium_Core_Util::chrToInt(
+				ParagonIE_Sodium_Core_Util::substr($var, $i, 1)
+			);
+			$copy .= ParagonIE_Sodium_Core_Util::intToChr($c);
+			$c >>= 8;
+		}
+		$var = $copy;
+	}
+
+	/**
+	 * @param string $str
+	 * @return bool
+	 *
+	 * @throws SodiumException
+	 */
+	public static function is_zero($str)
+	{
+		$d = 0;
+		for ($i = 0; $i < 32; ++$i) {
+			$d |= ParagonIE_Sodium_Core_Util::chrToInt($str[$i]);
+		}
+		return ((($d - 1) >> 31) & 1) === 1;
+	}
+
+	/**
+	 * The equivalent to the libsodium minor version we aim to be compatible
+	 * with (sans pwhash and memzero).
+	 *
+	 * @return int
+	 */
+	public static function library_version_major()
+	{
+		if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MAJOR_VERSION')) {
+			return SODIUM_LIBRARY_MAJOR_VERSION;
+		}
+		if (self::use_fallback('library_version_major')) {
+			/** @psalm-suppress UndefinedFunction */
+			return (int) call_user_func('\\Sodium\\library_version_major');
+		}
+		return self::LIBRARY_VERSION_MAJOR;
+	}
+
+	/**
+	 * The equivalent to the libsodium minor version we aim to be compatible
+	 * with (sans pwhash and memzero).
+	 *
+	 * @return int
+	 */
+	public static function library_version_minor()
+	{
+		if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MINOR_VERSION')) {
+			return SODIUM_LIBRARY_MINOR_VERSION;
+		}
+		if (self::use_fallback('library_version_minor')) {
+			/** @psalm-suppress UndefinedFunction */
+			return (int) call_user_func('\\Sodium\\library_version_minor');
+		}
+		return self::LIBRARY_VERSION_MINOR;
+	}
+
+	/**
+	 * Compare two strings.
+	 *
+	 * @param string $left
+	 * @param string $right
+	 * @return int
+	 * @throws SodiumException
+	 * @throws TypeError
+	 * @psalm-suppress MixedArgument
+	 */
+	public static function memcmp($left, $right)
+	{
+		/* Type checks: */
+		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::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);
+	}
+
+	/**
+	 * It's actually not possible to zero memory buffers in PHP. You need the
+	 * native library for that.
+	 *
+	 * @param string|null $var
+	 * @param-out string|null $var
+	 *
+	 * @return void
+	 * @throws SodiumException (Unless libsodium is installed)
+	 * @throws TypeError
+	 * @psalm-suppress TooFewArguments
+	 */
+	public static function memzero(&$var)
+	{
+		/* Type checks: */
+		ParagonIE_Sodium_Core_Util::declareScalarType($var, 'string', 1);
+
+		if (self::useNewSodiumAPI()) {
+			/** @psalm-suppress MixedArgument */
+			sodium_memzero($var);
+			return;
+		}
+		if (self::use_fallback('memzero')) {
+			$func = '\\Sodium\\memzero';
+			$func($var);
+			if ($var === null) {
+				return;
+			}
+		}
+		// This is the best we can do.
+		throw new SodiumException(
+			'This is not implemented in sodium_compat, as it is not possible to securely wipe memory from PHP. ' .
+			'To fix this error, make sure libsodium is installed and the PHP extension is enabled.'
+		);
+	}
+
+	/**
+	 * @param string $unpadded
+	 * @param int $blockSize
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	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);
+
+		$unpadded = (string) $unpadded;
+		$blockSize = (int) $blockSize;
+
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return (string) sodium_pad($unpadded, $blockSize);
+		}
+
+		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);
+		} else {
+			$xpadlen -= $unpadded_len % $blockSize;
+		}
+
+		$xpadded_len = $unpadded_len + $xpadlen;
+		$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";
+				} else {
+					$padded[$j] = $unpadded[$j];
+				}
+				/** @var int $k */
+				$k -= $st;
+				$st = (int) (~(
+							(
+								(
+									($k >> 48)
+										|
+									($k >> 32)
+										|
+									($k >> 16)
+										|
+									$k
+								) - 1
+							) >> 16
+						)
+					) & 1;
+				$i += $st;
+			}
+		}
+
+		$mask = 0;
+		$tail = $xpadded_len;
+		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);
+			# 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)
+					|
+				(0x80 & $barrier_mask)
+			);
+			# mask |= barrier_mask;
+			$mask |= $barrier_mask;
+		}
+		return $padded;
+	}
+
+	/**
+	 * @param string $padded
+	 * @param int $blockSize
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	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);
+
+		$padded = (string) $padded;
+		$blockSize = (int) $blockSize;
+
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return (string) sodium_unpad($padded, $blockSize);
+		}
+		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');
+		}
+
+		# tail = &padded[padded_len - 1U];
+		$tail = $padded_len - 1;
+
+		$acc = 0;
+		$valid = 0;
+		$pad_len = 0;
+
+		$found = 0;
+		for ($i = 0; $i < $blockSize; ++$i) {
+			# c = 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)
+				) >> 7
+			) & 1;
+			$is_barrier &= ~$found;
+			$found |= $is_barrier;
+
+			# acc |= c;
+			$acc |= $c;
+
+			# pad_len |= i & (1U + ~is_barrier);
+			$pad_len |= $i & (1 + ~$is_barrier);
+
+			# valid |= (unsigned char) is_barrier;
+			$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');
+		}
+		return ParagonIE_Sodium_Core_Util::substr($padded, 0, $unpadded_len);
+	}
+
+	/**
+	 * Will sodium_compat run fast on the current hardware and PHP configuration?
+	 *
+	 * @return bool
+	 */
+	public static function polyfill_is_fast()
+	{
+		if (extension_loaded('sodium')) {
+			return true;
+		}
+		if (extension_loaded('libsodium')) {
+			return true;
+		}
+		return PHP_INT_SIZE === 8;
+	}
+
+	/**
+	 * Generate a string of bytes from the kernel's CSPRNG.
+	 * Proudly uses /dev/urandom (if getrandom(2) is not available).
+	 *
+	 * @param int $numBytes
+	 * @return string
+	 * @throws Exception
+	 * @throws TypeError
+	 */
+	public static function randombytes_buf($numBytes)
+	{
+		/* Type checks: */
+		if (!is_int($numBytes)) {
+			if (is_numeric($numBytes)) {
+				$numBytes = (int) $numBytes;
+			} else {
+				throw new TypeError(
+					'Argument 1 must be an integer, ' . gettype($numBytes) . ' given.'
+				);
+			}
+		}
+		if (self::use_fallback('randombytes_buf')) {
+			return (string) call_user_func('\\Sodium\\randombytes_buf', $numBytes);
+		}
+		return random_bytes($numBytes);
+	}
+
+	/**
+	 * Generate an integer between 0 and $range (non-inclusive).
+	 *
+	 * @param int $range
+	 * @return int
+	 * @throws Exception
+	 * @throws Error
+	 * @throws TypeError
+	 */
+	public static function randombytes_uniform($range)
+	{
+		/* Type checks: */
+		if (!is_int($range)) {
+			if (is_numeric($range)) {
+				$range = (int) $range;
+			} else {
+				throw new TypeError(
+					'Argument 1 must be an integer, ' . gettype($range) . ' given.'
+				);
+			}
+		}
+		if (self::use_fallback('randombytes_uniform')) {
+			return (int) call_user_func('\\Sodium\\randombytes_uniform', $range);
+		}
+		return random_int(0, $range - 1);
+	}
+
+	/**
+	 * Generate a random 16-bit integer.
+	 *
+	 * @return int
+	 * @throws Exception
+	 * @throws Error
+	 * @throws TypeError
+	 */
+	public static function randombytes_random16()
+	{
+		if (self::use_fallback('randombytes_random16')) {
+			return (int) call_user_func('\\Sodium\\randombytes_random16');
+		}
+		return random_int(0, 65535);
+	}
+
+	/**
+	 * @param string $p
+	 * @param bool $dontFallback
+	 * @return bool
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_is_valid_point($p, $dontFallback = false)
+	{
+		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') {
+				return false;
+			}
+			throw $ex;
+		}
+	}
+
+	/**
+	 * @param string $p
+	 * @param string $q
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_add($p, $q, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_add($p, $q);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_add($p, $q);
+	}
+
+	/**
+	 * @param string $p
+	 * @param string $q
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_sub($p, $q, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_sub($p, $q);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_sub($p, $q);
+	}
+
+	/**
+	 * @param string $r
+	 * @param bool $dontFallback
+	 * @return string
+	 *
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_from_hash($r, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_from_hash($r);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_from_hash($r);
+	}
+
+	/**
+	 * @param bool $dontFallback
+	 * @return string
+	 *
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_random($dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_random();
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_random();
+	}
+
+	/**
+	 * @param bool $dontFallback
+	 * @return string
+	 *
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_random($dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_random();
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_random();
+	}
+
+	/**
+	 * @param string $s
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_invert($s, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_invert($s);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_invert($s);
+	}
+	/**
+	 * @param string $s
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_negate($s, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_negate($s);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_negate($s);
+	}
+
+	/**
+	 * @param string $s
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_complement($s, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_complement($s);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_complement($s);
+	}
+
+	/**
+	 * @param string $x
+	 * @param string $y
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_add($x, $y, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_add($x, $y);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_add($x, $y);
+	}
+
+	/**
+	 * @param string $x
+	 * @param string $y
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_sub($x, $y, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_sub($x, $y);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_sub($x, $y);
+	}
+
+	/**
+	 * @param string $x
+	 * @param string $y
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_mul($x, $y, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_mul($x, $y);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::ristretto255_scalar_mul($x, $y);
+	}
+
+	/**
+	 * @param string $n
+	 * @param string $p
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalarmult_ristretto255($n, $p, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_scalarmult_ristretto255($n, $p);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255($n, $p);
+	}
+
+	/**
+	 * @param string $n
+	 * @param string $p
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function scalarmult_ristretto255_base($n, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_scalarmult_ristretto255_base($n);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::scalarmult_ristretto255_base($n);
+	}
+
+	/**
+	 * @param string $s
+	 * @param bool $dontFallback
+	 * @return string
+	 * @throws SodiumException
+	 */
+	public static function ristretto255_scalar_reduce($s, $dontFallback = false)
+	{
+		if (self::useNewSodiumAPI() && !$dontFallback) {
+			return sodium_crypto_core_ristretto255_scalar_reduce($s);
+		}
+		return ParagonIE_Sodium_Core_Ristretto255::sc_reduce($s);
+	}
+
+	/**
+	 * Runtime testing method for 32-bit platforms.
+	 *
+	 * Usage: If runtime_speed_test() returns FALSE, then our 32-bit
+	 *        implementation is to slow to use safely without risking timeouts.
+	 *        If this happens, install sodium from PECL to get acceptable
+	 *        performance.
+	 *
+	 * @param int $iterations Number of multiplications to attempt
+	 * @param int $maxTimeout Milliseconds
+	 * @return bool           TRUE if we're fast enough, FALSE is not
+	 * @throws SodiumException
+	 */
+	public static function runtime_speed_test($iterations, $maxTimeout)
+	{
+		if (self::polyfill_is_fast()) {
+			return true;
+		}
+		/** @var float $end */
+		$end = 0.0;
+		/** @var float $start */
+		$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) {
+			/** @var ParagonIE_Sodium_Core32_Int64 $b */
+			$b = ParagonIE_Sodium_Core32_Int64::fromInt(random_int(3, 1 << 16));
+			$a->mulInt64($b);
+		}
+		/** @var float $end */
+		$end = microtime(true);
+		/** @var int $diff */
+		$diff = (int) ceil(($end - $start) * 1000);
+		return $diff < $maxTimeout;
+	}
+
+	/**
+	 * Add two numbers (little-endian unsigned), storing the value in the first
+	 * parameter.
+	 *
+	 * This mutates $val.
+	 *
+	 * @param string $val
+	 * @param string $addv
+	 * @return void
+	 * @throws SodiumException
+	 */
+	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');
+		}
+		$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;
+		}
+		$val = ParagonIE_Sodium_Core_Util::intArrayToString($A);
+	}
+
+	/**
+	 * This emulates libsodium's version_string() function, except ours is
+	 * prefixed with 'polyfill-'.
+	 *
+	 * @return string
+	 * @psalm-suppress MixedInferredReturnType
+	 * @psalm-suppress UndefinedFunction
+	 */
+	public static function version_string()
+	{
+		if (self::useNewSodiumAPI()) {
+			return (string) sodium_version_string();
+		}
+		if (self::use_fallback('version_string')) {
+			return (string) call_user_func('\\Sodium\\version_string');
+		}
+		return (string) self::VERSION_STRING;
+	}
+
+	/**
+	 * Should we use the libsodium core function instead?
+	 * This is always a good idea, if it's available. (Unless we're in the
+	 * middle of running our unit test suite.)
+	 *
+	 * If ext/libsodium is available, use it. Return TRUE.
+	 * Otherwise, we have to use the code provided herein. Return FALSE.
+	 *
+	 * @param string $sodium_func_name
+	 *
+	 * @return bool
+	 */
+	protected static function use_fallback($sodium_func_name = '')
+	{
+		static $res = null;
+		if ($res === null) {
+			$res = extension_loaded('libsodium') && PHP_VERSION_ID >= 50300;
+		}
+		if ($res === false) {
+			// No libsodium installed
+			return false;
+		}
+		if (self::$disableFallbackForUnitTests) {
+			// Don't fallback. Use the PHP implementation.
+			return false;
+		}
+		if (!empty($sodium_func_name)) {
+			return is_callable('\\Sodium\\' . $sodium_func_name);
+		}
+		return true;
+	}
+
+	/**
+	 * Libsodium as implemented in PHP 7.2
+	 * and/or ext/sodium (via PECL)
+	 *
+	 * @ref https://wiki.php.net/rfc/libsodium
+	 * @return bool
+	 */
+	protected static function useNewSodiumAPI()
+	{
+		static $res = null;
+		if ($res === null) {
+			$res = PHP_VERSION_ID >= 70000 && extension_loaded('sodium');
+		}
+		if (self::$disableFallbackForUnitTests) {
+			// Don't fallback. Use the PHP implementation.
+			return false;
+		}
+		return (bool) $res;
+	}
 }

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;
     }
 }

Braces +112 added lines, -224 removed lines

@@ -25,8 +25,7 @@ 
     return;
 }
 
-class ParagonIE_Sodium_Compat
-{
+class ParagonIE_Sodium_Compat {
     /**
      * This parameter prevents the use of the PECL extension.
      * It should only be used for unit testing.
@@ -155,8 +154,7 @@ 
      * @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) {
@@ -181,8 +179,7 @@ 
      * @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);
 
@@ -224,8 +221,7 @@ 
      * @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);
         /** @var string $decoded */
@@ -257,8 +253,7 @@ 
      * @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);
 
@@ -284,8 +279,7 @@ 
      * @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);
@@ -307,8 +301,7 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress MixedReturnStatement
      */
-    public static function crypto_aead_aes256gcm_is_available()
-    {
+    public static function crypto_aead_aes256gcm_is_available() {
         if (self::useNewSodiumAPI()) {
             return sodium_crypto_aead_aes256gcm_is_available();
         }
@@ -454,8 +447,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_aead_aes256gcm_keygen()
-    {
+    public static function crypto_aead_aes256gcm_keygen() {
         return random_bytes(self::CRYPTO_AEAD_AES256GCM_KEYBYTES);
     }
 
@@ -702,8 +694,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_aead_chacha20poly1305_keygen()
-    {
+    public static function crypto_aead_chacha20poly1305_keygen() {
         return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES);
     }
 
@@ -790,8 +781,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_aead_chacha20poly1305_ietf_keygen()
-    {
+    public static function crypto_aead_chacha20poly1305_ietf_keygen() {
         return random_bytes(self::CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES);
     }
 
@@ -949,8 +939,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_aead_xchacha20poly1305_ietf_keygen()
-    {
+    public static function crypto_aead_xchacha20poly1305_ietf_keygen() {
         return random_bytes(self::CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES);
     }
 
@@ -971,8 +960,7 @@ 
      * @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);
@@ -999,8 +987,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_auth_keygen()
-    {
+    public static function crypto_auth_keygen() {
         return random_bytes(self::CRYPTO_AUTH_KEYBYTES);
     }
 
@@ -1016,8 +1003,7 @@ 
      * @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);
@@ -1060,8 +1046,7 @@ 
      * @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);
@@ -1104,8 +1089,7 @@ 
      * @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);
@@ -1142,8 +1126,7 @@ 
      * @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);
@@ -1180,8 +1163,7 @@ 
      * @throws TypeError
      * @psalm-suppress MixedArgument
      */
-    public static function crypto_box_keypair()
-    {
+    public static function crypto_box_keypair() {
         if (self::useNewSodiumAPI()) {
             return (string) sodium_crypto_box_keypair();
         }
@@ -1205,8 +1187,7 @@ 
      * @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);
@@ -1244,8 +1225,7 @@ 
      * @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);
@@ -1287,8 +1267,7 @@ 
      * @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);
 
@@ -1318,8 +1297,7 @@ 
      * @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);
 
@@ -1349,8 +1327,7 @@ 
      * @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);
 
@@ -1381,8 +1358,7 @@ 
      * @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);
 
@@ -1411,8 +1387,7 @@ 
      * @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)) {
@@ -1455,8 +1430,7 @@ 
      * @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);
@@ -1500,8 +1474,7 @@ 
      * @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)) {
             $key = '';
@@ -1591,8 +1564,7 @@ 
      * @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);
@@ -1618,8 +1590,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_generichash_keygen()
-    {
+    public static function crypto_generichash_keygen() {
         return random_bytes(self::CRYPTO_GENERICHASH_KEYBYTES);
     }
 
@@ -1677,8 +1648,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_kdf_keygen()
-    {
+    public static function crypto_kdf_keygen() {
         return random_bytes(self::CRYPTO_KDF_KEYBYTES);
     }
 
@@ -1712,8 +1682,7 @@ 
      * @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);
@@ -1774,8 +1743,7 @@ 
      * @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);
 
         $seed = (string) $seed;
@@ -1793,8 +1761,7 @@ 
      * @return string
      * @throws Exception
      */
-    public static function crypto_kx_keypair()
-    {
+    public static function crypto_kx_keypair() {
         $sk = self::randombytes_buf(self::CRYPTO_KX_SECRETKEYBYTES);
         $pk = self::crypto_scalarmult_base($sk);
         return $sk . $pk;
@@ -1806,8 +1773,7 @@ 
      * @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);
 
@@ -1848,8 +1814,7 @@ 
      * @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);
 
@@ -1889,8 +1854,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,
             0,
@@ -1903,8 +1867,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,
             self::CRYPTO_KX_SECRETKEYBYTES,
@@ -1924,8 +1887,7 @@ 
      * @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);
@@ -1956,8 +1918,7 @@ 
      *
      * @return bool
      */
-    public static function crypto_pwhash_is_available()
-    {
+    public static function crypto_pwhash_is_available() {
         if (self::useNewSodiumAPI()) {
             return true;
         }
@@ -1976,8 +1937,7 @@ 
      * @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);
@@ -2003,8 +1963,7 @@ 
      * @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);
@@ -2032,8 +1991,7 @@ 
      * @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);
 
@@ -2059,8 +2017,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_pwhash_scryptsalsa208sha256($outlen, $passwd, $salt, $opslimit, $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);
@@ -2100,8 +2057,7 @@ 
      *
      * @return bool
      */
-    public static function crypto_pwhash_scryptsalsa208sha256_is_available()
-    {
+    public static function crypto_pwhash_scryptsalsa208sha256_is_available() {
         if (self::useNewSodiumAPI()) {
             return true;
         }
@@ -2119,8 +2075,7 @@ 
      * @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);
@@ -2153,8 +2108,7 @@ 
      * @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);
 
@@ -2190,8 +2144,7 @@ 
      * @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);
@@ -2234,8 +2187,7 @@ 
      * @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);
 
@@ -2272,8 +2224,7 @@ 
      * @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);
@@ -2312,8 +2263,7 @@ 
      * @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);
@@ -2350,8 +2300,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_secretbox_keygen()
-    {
+    public static function crypto_secretbox_keygen() {
         return random_bytes(self::CRYPTO_SECRETBOX_KEYBYTES);
     }
 
@@ -2368,8 +2317,7 @@ 
      * @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);
@@ -2398,8 +2346,7 @@ 
      * @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);
@@ -2425,8 +2372,7 @@ 
      * @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);
         }
@@ -2439,8 +2385,7 @@ 
      * @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) {
             throw new SodiumException(
                 'header size should be SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES bytes'
@@ -2460,8 +2405,7 @@ 
      * @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) {
             return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_push(
                 $state,
@@ -2485,8 +2429,7 @@ 
      * @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) {
             return ParagonIE_Sodium_Crypto32::secretstream_xchacha20poly1305_pull(
                 $state,
@@ -2505,8 +2448,7 @@ 
      * @return string
      * @throws Exception
      */
-    public static function crypto_secretstream_xchacha20poly1305_keygen()
-    {
+    public static function crypto_secretstream_xchacha20poly1305_keygen() {
         return random_bytes(self::CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES);
     }
 
@@ -2515,8 +2457,7 @@ 
      * @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);
         } else {
@@ -2536,8 +2477,7 @@ 
      * @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);
@@ -2566,8 +2506,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_shorthash_keygen()
-    {
+    public static function crypto_shorthash_keygen() {
         return random_bytes(self::CRYPTO_SHORTHASH_KEYBYTES);
     }
 
@@ -2586,8 +2525,7 @@ 
      * @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);
@@ -2622,8 +2560,7 @@ 
      * @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);
@@ -2659,8 +2596,7 @@ 
      * @throws SodiumException
      * @throws TypeError
      */
-    public static function crypto_sign_keypair()
-    {
+    public static function crypto_sign_keypair() {
         if (self::useNewSodiumAPI()) {
             return sodium_crypto_sign_keypair();
         }
@@ -2679,8 +2615,7 @@ 
      * @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;
@@ -2708,8 +2643,7 @@ 
      * @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);
 
         if (self::useNewSodiumAPI()) {
@@ -2737,8 +2671,7 @@ 
      * @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);
 
@@ -2768,8 +2701,7 @@ 
      * @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);
 
@@ -2799,8 +2731,7 @@ 
      * @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);
 
@@ -2833,8 +2764,7 @@ 
      * @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);
@@ -2868,8 +2798,7 @@ 
      * @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);
@@ -2909,8 +2838,7 @@ 
      * @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);
 
@@ -2941,8 +2869,7 @@ 
      * @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);
 
@@ -2983,8 +2910,7 @@ 
      * @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);
@@ -3030,8 +2956,7 @@ 
      * @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);
@@ -3064,8 +2989,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_stream_keygen()
-    {
+    public static function crypto_stream_keygen() {
         return random_bytes(self::CRYPTO_STREAM_KEYBYTES);
     }
 
@@ -3085,8 +3009,7 @@ 
      * @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);
@@ -3130,8 +3053,7 @@ 
      * @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);
@@ -3161,8 +3083,7 @@ 
      * @throws Exception
      * @throws Error
      */
-    public static function crypto_stream_xchacha20_keygen()
-    {
+    public static function crypto_stream_xchacha20_keygen() {
         return random_bytes(self::CRYPTO_STREAM_XCHACHA20_KEYBYTES);
     }
 
@@ -3176,8 +3097,7 @@ 
      * @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);
 
@@ -3202,8 +3122,7 @@ 
      * @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);
 
@@ -3236,8 +3155,7 @@ 
      *
      * @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]);
@@ -3251,8 +3169,7 @@ 
      *
      * @return int
      */
-    public static function library_version_major()
-    {
+    public static function library_version_major() {
         if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MAJOR_VERSION')) {
             return SODIUM_LIBRARY_MAJOR_VERSION;
         }
@@ -3269,8 +3186,7 @@ 
      *
      * @return int
      */
-    public static function library_version_minor()
-    {
+    public static function library_version_minor() {
         if (self::useNewSodiumAPI() && defined('SODIUM_LIBRARY_MINOR_VERSION')) {
             return SODIUM_LIBRARY_MINOR_VERSION;
         }
@@ -3291,8 +3207,7 @@ 
      * @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);
@@ -3320,8 +3235,7 @@ 
      * @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);
 
@@ -3351,8 +3265,7 @@ 
      * @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);
@@ -3437,8 +3350,7 @@ 
      * @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);
@@ -3501,8 +3413,7 @@ 
      *
      * @return bool
      */
-    public static function polyfill_is_fast()
-    {
+    public static function polyfill_is_fast() {
         if (extension_loaded('sodium')) {
             return true;
         }
@@ -3521,8 +3432,7 @@ 
      * @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)) {
@@ -3548,8 +3458,7 @@ 
      * @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)) {
@@ -3574,8 +3483,7 @@ 
      * @throws Error
      * @throws TypeError
      */
-    public static function randombytes_random16()
-    {
+    public static function randombytes_random16() {
         if (self::use_fallback('randombytes_random16')) {
             return (int) call_user_func('\\Sodium\\randombytes_random16');
         }
@@ -3588,8 +3496,7 @@ 
      * @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);
         }
@@ -3612,8 +3519,7 @@ 
      * @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);
         }
@@ -3627,8 +3533,7 @@ 
      * @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);
         }
@@ -3642,8 +3547,7 @@ 
      *
      * @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);
         }
@@ -3656,8 +3560,7 @@ 
      *
      * @throws SodiumException
      */
-    public static function ristretto255_random($dontFallback = false)
-    {
+    public static function ristretto255_random($dontFallback = false) {
         if (self::useNewSodiumAPI() && !$dontFallback) {
             return sodium_crypto_core_ristretto255_random();
         }
@@ -3670,8 +3573,7 @@ 
      *
      * @throws SodiumException
      */
-    public static function ristretto255_scalar_random($dontFallback = false)
-    {
+    public static function ristretto255_scalar_random($dontFallback = false) {
         if (self::useNewSodiumAPI() && !$dontFallback) {
             return sodium_crypto_core_ristretto255_scalar_random();
         }
@@ -3684,8 +3586,7 @@ 
      * @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);
         }
@@ -3697,8 +3598,7 @@ 
      * @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);
         }
@@ -3711,8 +3611,7 @@ 
      * @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);
         }
@@ -3726,8 +3625,7 @@ 
      * @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);
         }
@@ -3741,8 +3639,7 @@ 
      * @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);
         }
@@ -3756,8 +3653,7 @@ 
      * @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);
         }
@@ -3771,8 +3667,7 @@ 
      * @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);
         }
@@ -3786,8 +3681,7 @@ 
      * @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);
         }
@@ -3800,8 +3694,7 @@ 
      * @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);
         }
@@ -3821,8 +3714,7 @@ 
      * @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()) {
             return true;
         }
@@ -3855,8 +3747,7 @@ 
      * @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) {
@@ -3882,8 +3773,7 @@ 
      * @psalm-suppress MixedInferredReturnType
      * @psalm-suppress UndefinedFunction
      */
-    public static function version_string()
-    {
+    public static function version_string() {
         if (self::useNewSodiumAPI()) {
             return (string) sodium_version_string();
         }
@@ -3905,8 +3795,7 @@ 
      *
      * @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;
@@ -3932,8 +3821,7 @@ 
      * @ref https://wiki.php.net/rfc/libsodium
      * @return bool
      */
-    protected static function useNewSodiumAPI()
-    {
+    protected static function useNewSodiumAPI() {
         static $res = null;
         if ($res === null) {
             $res = PHP_VERSION_ID >= 70000 && extension_loaded('sodium');