gravityview / GravityView

vendor/paragonie/sodium_compat/lib/sodium_compat.php

Indentation +698 added lines, -698 removed lines

@@ -13,815 +13,815 @@
  * method.
  */
 if (!is_callable('\\Sodium\\bin2hex')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::bin2hex()
-     * @param string $string
-     * @return string
-     * @throws \SodiumException
-     * @throws \TypeError
-     */
-    function bin2hex($string)
-    {
-        return ParagonIE_Sodium_Compat::bin2hex($string);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::bin2hex()
+	 * @param string $string
+	 * @return string
+	 * @throws \SodiumException
+	 * @throws \TypeError
+	 */
+	function 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 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 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 crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
-        } catch (\TypeError $ex) {
-            return false;
-        } catch (\SodiumException $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 crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_aead_aes256gcm_decrypt($message, $assocData, $nonce, $key);
+		} catch (\TypeError $ex) {
+			return false;
+		} catch (\SodiumException $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 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 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 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 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 crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
-        } catch (\TypeError $ex) {
-            return false;
-        } catch (\SodiumException $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 crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_decrypt($message, $assocData, $nonce, $key);
+		} catch (\TypeError $ex) {
+			return false;
+		} catch (\SodiumException $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 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 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_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 crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
-        } catch (\TypeError $ex) {
-            return false;
-        } catch (\SodiumException $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 crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_aead_chacha20poly1305_ietf_decrypt($message, $assocData, $nonce, $key);
+		} catch (\TypeError $ex) {
+			return false;
+		} catch (\SodiumException $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 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 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_auth')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_auth()
-     * @param string $message
-     * @param string $key
-     * @return string
-     * @throws \SodiumException
-     * @throws \TypeError
-     */
-    function 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 crypto_auth($message, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_auth($message, $key);
+	}
 }
 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 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 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 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 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 crypto_box_keypair()
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_keypair();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_keypair()
+	 * @return string
+	 * @throws \SodiumException
+	 * @throws \TypeError
+	 */
+	function 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 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 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 crypto_box_open($message, $nonce, $kp)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
-        } catch (\TypeError $ex) {
-            return false;
-        } catch (\SodiumException $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_open()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $kp
+	 * @return string|bool
+	 */
+	function crypto_box_open($message, $nonce, $kp)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_box_open($message, $nonce, $kp);
+		} catch (\TypeError $ex) {
+			return false;
+		} catch (\SodiumException $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 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 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 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 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_open()
-     * @param string $message
-     * @param string $publicKey
-     * @return string
-     * @throws \SodiumException
-     * @throws \TypeError
-     */
-    function crypto_box_seal($message, $publicKey)
-    {
-        return ParagonIE_Sodium_Compat::crypto_box_seal($message, $publicKey);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
+	 * @param string $message
+	 * @param string $publicKey
+	 * @return string
+	 * @throws \SodiumException
+	 * @throws \TypeError
+	 */
+	function 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
-     */
-    function crypto_box_seal_open($message, $kp)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
-        } catch (\TypeError $ex) {
-            return false;
-        } catch (\SodiumException $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_box_seal_open()
+	 * @param string $message
+	 * @param string $kp
+	 * @return string|bool
+	 */
+	function crypto_box_seal_open($message, $kp)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_box_seal_open($message, $kp);
+		} catch (\TypeError $ex) {
+			return false;
+		} catch (\SodiumException $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 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 crypto_box_secretkey($keypair)
+	{
+		return ParagonIE_Sodium_Compat::crypto_box_secretkey($keypair);
+	}
 }
 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 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 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 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 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 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 crypto_generichash_init($key = null, $outLen = 32)
+	{
+		return ParagonIE_Sodium_Compat::crypto_generichash_init($key, $outLen);
+	}
 }
 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 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 crypto_generichash_update(&$ctx, $message = '')
+	{
+		ParagonIE_Sodium_Compat::crypto_generichash_update($ctx, $message);
+	}
 }
 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 crypto_kx($my_secret, $their_public, $client_public, $server_public)
-    {
-        return ParagonIE_Sodium_Compat::crypto_kx(
-            $my_secret,
-            $their_public,
-            $client_public,
-            $server_public,
-            true
-        );
-    }
+	/**
+	 * @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 crypto_kx($my_secret, $their_public, $client_public, $server_public)
+	{
+		return ParagonIE_Sodium_Compat::crypto_kx(
+			$my_secret,
+			$their_public,
+			$client_public,
+			$server_public,
+			true
+		);
+	}
 }
 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
-     * @return string
-     * @throws \SodiumException
-     * @throws \TypeError
-     */
-    function crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit)
-    {
-        return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_pwhash()
+	 * @param int $outlen
+	 * @param string $passwd
+	 * @param string $salt
+	 * @param int $opslimit
+	 * @param int $memlimit
+	 * @return string
+	 * @throws \SodiumException
+	 * @throws \TypeError
+	 */
+	function crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash($outlen, $passwd, $salt, $opslimit, $memlimit);
+	}
 }
 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 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 crypto_pwhash_str($passwd, $opslimit, $memlimit)
+	{
+		return ParagonIE_Sodium_Compat::crypto_pwhash_str($passwd, $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 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 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 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 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 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 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 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 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 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 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 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 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 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 crypto_secretbox($message, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_secretbox($message, $nonce, $key);
+	}
 }
 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 crypto_secretbox_open($message, $nonce, $key)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
-        } catch (\TypeError $ex) {
-            return false;
-        } catch (\SodiumException $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_secretbox_open()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string|bool
+	 */
+	function crypto_secretbox_open($message, $nonce, $key)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_secretbox_open($message, $nonce, $key);
+		} catch (\TypeError $ex) {
+			return false;
+		} catch (\SodiumException $ex) {
+			return false;
+		}
+	}
 }
 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 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 crypto_shorthash($message, $key = '')
+	{
+		return ParagonIE_Sodium_Compat::crypto_shorthash($message, $key);
+	}
 }
 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 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 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 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 crypto_sign_detached($message, $sk)
+	{
+		return ParagonIE_Sodium_Compat::crypto_sign_detached($message, $sk);
+	}
 }
 if (!is_callable('\\Sodium\\crypto_sign_keypair')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
-     * @return string
-     * @throws \SodiumException
-     * @throws \TypeError
-     */
-    function crypto_sign_keypair()
-    {
-        return ParagonIE_Sodium_Compat::crypto_sign_keypair();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_keypair()
+	 * @return string
+	 * @throws \SodiumException
+	 * @throws \TypeError
+	 */
+	function 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 crypto_sign_open($signedMessage, $pk)
-    {
-        try {
-            return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
-        } catch (\TypeError $ex) {
-            return false;
-        } catch (\SodiumException $ex) {
-            return false;
-        }
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_sign_open()
+	 * @param string $signedMessage
+	 * @param string $pk
+	 * @return string|bool
+	 */
+	function crypto_sign_open($signedMessage, $pk)
+	{
+		try {
+			return ParagonIE_Sodium_Compat::crypto_sign_open($signedMessage, $pk);
+		} catch (\TypeError $ex) {
+			return false;
+		} catch (\SodiumException $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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 crypto_stream($len, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream($len, $nonce, $key);
+	}
 }
 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 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 crypto_stream_xor($message, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream_xor($message, $nonce, $key);
+	}
 }
 if (!is_callable('\\Sodium\\hex2bin')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::hex2bin()
-     * @param string $string
-     * @return string
-     * @throws \SodiumException
-     * @throws \TypeError
-     */
-    function hex2bin($string)
-    {
-        return ParagonIE_Sodium_Compat::hex2bin($string);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::hex2bin()
+	 * @param string $string
+	 * @return string
+	 * @throws \SodiumException
+	 * @throws \TypeError
+	 */
+	function hex2bin($string)
+	{
+		return ParagonIE_Sodium_Compat::hex2bin($string);
+	}
 }
 if (!is_callable('\\Sodium\\memcmp')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::memcmp()
-     * @param string $a
-     * @param string $b
-     * @return int
-     * @throws \SodiumException
-     * @throws \TypeError
-     */
-    function 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 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 memzero(&$str)
-    {
-        ParagonIE_Sodium_Compat::memzero($str);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::memzero()
+	 * @param string $str
+	 * @return void
+	 * @throws \SodiumException
+	 * @throws \TypeError
+	 */
+	function memzero(&$str)
+	{
+		ParagonIE_Sodium_Compat::memzero($str);
+	}
 }
 if (!is_callable('\\Sodium\\randombytes_buf')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::randombytes_buf()
-     * @param int $amount
-     * @return string
-     * @throws \TypeError
-     */
-    function randombytes_buf($amount)
-    {
-        return ParagonIE_Sodium_Compat::randombytes_buf($amount);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::randombytes_buf()
+	 * @param int $amount
+	 * @return string
+	 * @throws \TypeError
+	 */
+	function 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 \SodiumException
-     * @throws \Error
-     */
-    function randombytes_uniform($upperLimit)
-    {
-        return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::randombytes_uniform()
+	 * @param int $upperLimit
+	 * @return int
+	 * @throws \SodiumException
+	 * @throws \Error
+	 */
+	function randombytes_uniform($upperLimit)
+	{
+		return ParagonIE_Sodium_Compat::randombytes_uniform($upperLimit);
+	}
 }
 
 if (!is_callable('\\Sodium\\randombytes_random16')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::randombytes_random16()
-     * @return int
-     */
-    function randombytes_random16()
-    {
-        return ParagonIE_Sodium_Compat::randombytes_random16();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::randombytes_random16()
+	 * @return int
+	 */
+	function randombytes_random16()
+	{
+		return ParagonIE_Sodium_Compat::randombytes_random16();
+	}
 }
 
 if (!defined('\\Sodium\\CRYPTO_AUTH_BYTES')) {
-    require_once dirname(__FILE__) . '/constants.php';
+	require_once dirname(__FILE__) . '/constants.php';
 }

vendor/paragonie/sodium_compat/lib/ristretto255.php

Indentation +194 added lines, -194 removed lines

@@ -1,239 +1,239 @@
 <?php
 
 if (!defined('SODIUM_CRYPTO_CORE_RISTRETTO255_BYTES')) {
-    define(
-        'SODIUM_CRYPTO_CORE_RISTRETTO255_BYTES',
-        ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_BYTES
-    );
-    define('SODIUM_COMPAT_POLYFILLED_RISTRETTO255', true);
+	define(
+		'SODIUM_CRYPTO_CORE_RISTRETTO255_BYTES',
+		ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_BYTES
+	);
+	define('SODIUM_COMPAT_POLYFILLED_RISTRETTO255', true);
 }
 if (!defined('SODIUM_CRYPTO_CORE_RISTRETTO255_HASHBYTES')) {
-    define(
-        'SODIUM_CRYPTO_CORE_RISTRETTO255_HASHBYTES',
-        ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_HASHBYTES
-    );
+	define(
+		'SODIUM_CRYPTO_CORE_RISTRETTO255_HASHBYTES',
+		ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_HASHBYTES
+	);
 }
 if (!defined('SODIUM_CRYPTO_CORE_RISTRETTO255_SCALARBYTES')) {
-    define(
-        'SODIUM_CRYPTO_CORE_RISTRETTO255_SCALARBYTES',
-        ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_SCALARBYTES
-    );
+	define(
+		'SODIUM_CRYPTO_CORE_RISTRETTO255_SCALARBYTES',
+		ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_SCALARBYTES
+	);
 }
 if (!defined('SODIUM_CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES')) {
-    define(
-        'SODIUM_CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES',
-        ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES
-    );
+	define(
+		'SODIUM_CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES',
+		ParagonIE_Sodium_Compat::CRYPTO_CORE_RISTRETTO255_NONREDUCEDSCALARBYTES
+	);
 }
 if (!defined('SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES')) {
-    define(
-        'SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES',
-        ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES
-    );
+	define(
+		'SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES',
+		ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_RISTRETTO255_SCALARBYTES
+	);
 }
 if (!defined('SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_BYTES')) {
-    define(
-        'SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_BYTES',
-        ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_RISTRETTO255_BYTES
-    );
+	define(
+		'SODIUM_CRYPTO_SCALARMULT_RISTRETTO255_BYTES',
+		ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_RISTRETTO255_BYTES
+	);
 }
 
 if (!is_callable('sodium_crypto_core_ristretto255_add')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_add()
-     *
-     * @param string $p
-     * @param string $q
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_add($p, $q)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_add($p, $q, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_add()
+	 *
+	 * @param string $p
+	 * @param string $q
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_add($p, $q)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_add($p, $q, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_from_hash')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_from_hash()
-     *
-     * @param string $r
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_from_hash($r)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_from_hash($r, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_from_hash()
+	 *
+	 * @param string $r
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_from_hash($r)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_from_hash($r, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_is_valid_point')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_is_valid_point()
-     *
-     * @param string $p
-     * @return bool
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_is_valid_point($p)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_is_valid_point($p, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_is_valid_point()
+	 *
+	 * @param string $p
+	 * @return bool
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_is_valid_point($p)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_is_valid_point($p, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_random')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_random()
-     *
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_random()
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_random(true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_random()
+	 *
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_random()
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_random(true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_add')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_add()
-     *
-     * @param string $p
-     * @param string $q
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_add($p, $q)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_add($p, $q, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_add()
+	 *
+	 * @param string $p
+	 * @param string $q
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_add($p, $q)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_add($p, $q, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_complement')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_complement()
-     *
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_complement($p)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_complement($p, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_complement()
+	 *
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_complement($p)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_complement($p, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_invert')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_invert()
-     *
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_invert($p)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_invert($p, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_invert()
+	 *
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_invert($p)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_invert($p, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_mul')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_mul()
-     *
-     * @param string $p
-     * @param string $q
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_mul($p, $q)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_mul($p, $q, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_mul()
+	 *
+	 * @param string $p
+	 * @param string $q
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_mul($p, $q)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_mul($p, $q, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_negate')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_negate()
-     *
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_negate($p)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_negate($p, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_negate()
+	 *
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_negate($p)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_negate($p, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_random')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_random()
-     *
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_random()
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_random(true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_random()
+	 *
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_random()
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_random(true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_reduce')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_reduce()
-     *
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_reduce($p)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_reduce($p, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_reduce()
+	 *
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_reduce($p)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_reduce($p, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_scalar_sub')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_scalar_sub()
-     *
-     * @param string $p
-     * @param string $q
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_scalar_sub($p, $q)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_scalar_sub($p, $q, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_scalar_sub()
+	 *
+	 * @param string $p
+	 * @param string $q
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_scalar_sub($p, $q)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_scalar_sub($p, $q, true);
+	}
 }
 if (!is_callable('sodium_crypto_core_ristretto255_sub')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::ristretto255_sub()
-     *
-     * @param string $p
-     * @param string $q
-     * @return string
-     * @throws SodiumException
-     */
-    function sodium_crypto_core_ristretto255_sub($p, $q)
-    {
-        return ParagonIE_Sodium_Compat::ristretto255_sub($p, $q, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::ristretto255_sub()
+	 *
+	 * @param string $p
+	 * @param string $q
+	 * @return string
+	 * @throws SodiumException
+	 */
+	function sodium_crypto_core_ristretto255_sub($p, $q)
+	{
+		return ParagonIE_Sodium_Compat::ristretto255_sub($p, $q, true);
+	}
 }
 if (!is_callable('sodium_crypto_scalarmult_ristretto255')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_scalarmult_ristretto255()
-     * @param string $n
-     * @param string $p
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_scalarmult_ristretto255($n, $p)
-    {
-        return ParagonIE_Sodium_Compat::scalarmult_ristretto255($n, $p, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_scalarmult_ristretto255()
+	 * @param string $n
+	 * @param string $p
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_scalarmult_ristretto255($n, $p)
+	{
+		return ParagonIE_Sodium_Compat::scalarmult_ristretto255($n, $p, true);
+	}
 }
 if (!is_callable('sodium_crypto_scalarmult_ristretto255_base')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_scalarmult_ristretto255_base()
-     * @param string $n
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_scalarmult_ristretto255_base($n)
-    {
-        return ParagonIE_Sodium_Compat::scalarmult_ristretto255_base($n, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_scalarmult_ristretto255_base()
+	 * @param string $n
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_scalarmult_ristretto255_base($n)
+	{
+		return ParagonIE_Sodium_Compat::scalarmult_ristretto255_base($n, true);
+	}
 }
\ No newline at end of file

vendor/paragonie/sodium_compat/lib/namespaced.php

Indentation +23 added lines, -23 removed lines

@@ -3,7 +3,7 @@ 
 require_once dirname(dirname(__FILE__)) . '/autoload.php';
 
 if (PHP_VERSION_ID < 50300) {
-    return;
+	return;
 }
 
 /*
@@ -21,28 +21,28 @@ 
  * $x = Compat::crypto_aead_xchacha20poly1305_encrypt(...$args);
  */
 spl_autoload_register(function ($class) {
-    if ($class[0] === '\\') {
-        $class = substr($class, 1);
-    }
-    $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 ($class[0] === '\\') {
+		$class = substr($class, 1);
+	}
+	$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(dirname(__FILE__)) . '/namespaced/' . 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(dirname(__FILE__)) . '/namespaced/' . str_replace('\\', '/', $relative_class) . '.php';
+	// if the file exists, require it
+	if (file_exists($file)) {
+		require_once $file;
+		return true;
+	}
+	return false;
 });

vendor/paragonie/sodium_compat/lib/stream-xchacha20.php

Indentation +35 added lines, -35 removed lines

@@ -1,43 +1,43 @@
 <?php
 
 if (!is_callable('sodium_crypto_stream_xchacha20')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_stream_xchacha20()
-     * @param int $len
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_stream_xchacha20($len, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_stream_xchacha20($len, $nonce, $key, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_stream_xchacha20()
+	 * @param int $len
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_stream_xchacha20($len, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream_xchacha20($len, $nonce, $key, true);
+	}
 }
 if (!is_callable('sodium_crypto_stream_xchacha20_keygen')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_stream_xchacha20_keygen()
-     * @return string
-     * @throws Exception
-     */
-    function sodium_crypto_stream_xchacha20_keygen()
-    {
-        return ParagonIE_Sodium_Compat::crypto_stream_xchacha20_keygen();
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_stream_xchacha20_keygen()
+	 * @return string
+	 * @throws Exception
+	 */
+	function sodium_crypto_stream_xchacha20_keygen()
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream_xchacha20_keygen();
+	}
 }
 if (!is_callable('sodium_crypto_stream_xchacha20_xor')) {
-    /**
-     * @see ParagonIE_Sodium_Compat::crypto_stream_xchacha20_xor()
-     * @param string $message
-     * @param string $nonce
-     * @param string $key
-     * @return string
-     * @throws SodiumException
-     * @throws TypeError
-     */
-    function sodium_crypto_stream_xchacha20_xor($message, $nonce, $key)
-    {
-        return ParagonIE_Sodium_Compat::crypto_stream_xchacha20_xor($message, $nonce, $key, true);
-    }
+	/**
+	 * @see ParagonIE_Sodium_Compat::crypto_stream_xchacha20_xor()
+	 * @param string $message
+	 * @param string $nonce
+	 * @param string $key
+	 * @return string
+	 * @throws SodiumException
+	 * @throws TypeError
+	 */
+	function sodium_crypto_stream_xchacha20_xor($message, $nonce, $key)
+	{
+		return ParagonIE_Sodium_Compat::crypto_stream_xchacha20_xor($message, $nonce, $key, true);
+	}
 }

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();
+	}
 }

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');

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

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');

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