stuff

+<?php
+
+// autoload.php @generated by Composer
+
+if (!class_exists('ComposerAutoloaderInite213e65b2dafae4ad799b13fe0d36f8e')) {
+	require_once __DIR__ . '/composer/autoload_real.php';
+}
+
+return ComposerAutoloaderInite213e65b2dafae4ad799b13fe0d36f8e::getLoader();

+<?php
+
+namespace Composer;
+
+use Composer\Semver\VersionParser;
+
+
+
+
+
+
+class InstalledVersions
+{
+private static $installed = array (
+  'root' => 
+  array (
+    'pretty_version' => 'dev-master',
+    'version' => 'dev-master',
+    'aliases' => 
+    array (
+    ),
+    'reference' => '547ce2234fff039cbd57697d05f7236e431868e5',
+    'name' => '__root__',
+  ),
+  'versions' => 
+  array (
+    '__root__' => 
+    array (
+      'pretty_version' => 'dev-master',
+      'version' => 'dev-master',
+      'aliases' => 
+      array (
+      ),
+      'reference' => '547ce2234fff039cbd57697d05f7236e431868e5',
+    ),
+    'paragonie/random_compat' => 
+    array (
+      'pretty_version' => 'v2.0.10',
+      'version' => '2.0.10.0',
+      'aliases' => 
+      array (
+      ),
+      'reference' => '634bae8e911eefa89c1abfbf1b66da679ac8f54d',
+    ),
+    'paragonie/sodium_compat' => 
+    array (
+      'pretty_version' => 'v1.13.0',
+      'version' => '1.13.0.0',
+      'aliases' => 
+      array (
+      ),
+      'reference' => 'bbade402cbe84c69b718120911506a3aa2bae653',
+    ),
+  ),
+);
+
+
+
+
+
+
+
+public static function getInstalledPackages()
+{
+return array_keys(self::$installed['versions']);
+}
+
+
+
+
+
+
+
+
+
+public static function isInstalled($packageName)
+{
+return isset(self::$installed['versions'][$packageName]);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public static function satisfies(VersionParser $parser, $packageName, $constraint)
+{
+$constraint = $parser->parseConstraints($constraint);
+$provided = $parser->parseConstraints(self::getVersionRanges($packageName));
+
+return $provided->matches($constraint);
+}
+
+
+
+
+
+
+
+
+
+
+public static function getVersionRanges($packageName)
+{
+if (!isset(self::$installed['versions'][$packageName])) {
+throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+}
+
+$ranges = array();
+if (isset(self::$installed['versions'][$packageName]['pretty_version'])) {
+$ranges[] = self::$installed['versions'][$packageName]['pretty_version'];
+}
+if (array_key_exists('aliases', self::$installed['versions'][$packageName])) {
+$ranges = array_merge($ranges, self::$installed['versions'][$packageName]['aliases']);
+}
+if (array_key_exists('replaced', self::$installed['versions'][$packageName])) {
+$ranges = array_merge($ranges, self::$installed['versions'][$packageName]['replaced']);
+}
+if (array_key_exists('provided', self::$installed['versions'][$packageName])) {
+$ranges = array_merge($ranges, self::$installed['versions'][$packageName]['provided']);
+}
+
+return implode(' || ', $ranges);
+}
+
+
+
+
+
+public static function getVersion($packageName)
+{
+if (!isset(self::$installed['versions'][$packageName])) {
+throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+}
+
+if (!isset(self::$installed['versions'][$packageName]['version'])) {
+return null;
+}
+
+return self::$installed['versions'][$packageName]['version'];
+}
+
+
+
+
+
+public static function getPrettyVersion($packageName)
+{
+if (!isset(self::$installed['versions'][$packageName])) {
+throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+}
+
+if (!isset(self::$installed['versions'][$packageName]['pretty_version'])) {
+return null;
+}
+
+return self::$installed['versions'][$packageName]['pretty_version'];
+}
+
+
+
+
+
+public static function getReference($packageName)
+{
+if (!isset(self::$installed['versions'][$packageName])) {
+throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
+}
+
+if (!isset(self::$installed['versions'][$packageName]['reference'])) {
+return null;
+}
+
+return self::$installed['versions'][$packageName]['reference'];
+}
+
+
+
+
+
+public static function getRootPackage()
+{
+return self::$installed['root'];
+}
+
+
+
+
+
+
+
+public static function getRawData()
+{
+return self::$installed;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+public static function reload($data)
+{
+self::$installed = $data;
+}
+}

+
+Copyright (c) Nils Adermann, Jordi Boggiano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

+<?php
+
+// autoload_classmap.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

+<?php
+
+// autoload_files.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    '5255c38a0faeba867671b61dfda6d864' => $vendorDir . '/paragonie/random_compat/lib/random.php',
+    '3109cb1a231dcd04bee1f9f620d46975' => $vendorDir . '/paragonie/sodium_compat/autoload.php',
+);

+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

+<?php
+
+// autoload_real.php @generated by Composer
+
+class ComposerAutoloaderInite213e65b2dafae4ad799b13fe0d36f8e
+{
+    private static $loader;
+
+    public static function loadClassLoader($class)
+    {
+        if ('Composer\Autoload\ClassLoader' === $class) {
+            require __DIR__ . '/ClassLoader.php';
+        }
+    }
+
+    /**
+     * @return \Composer\Autoload\ClassLoader
+     */
+    public static function getLoader()
+    {
+        if (null !== self::$loader) {
+            return self::$loader;
+        }
+
+        spl_autoload_register(array('ComposerAutoloaderInite213e65b2dafae4ad799b13fe0d36f8e', 'loadClassLoader'), true, true);
+        self::$loader = $loader = new \Composer\Autoload\ClassLoader();
+        spl_autoload_unregister(array('ComposerAutoloaderInite213e65b2dafae4ad799b13fe0d36f8e', 'loadClassLoader'));
+
+        $useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
+        if ($useStaticLoader) {
+            require_once __DIR__ . '/autoload_static.php';
+
+            call_user_func(\Composer\Autoload\ComposerStaticInite213e65b2dafae4ad799b13fe0d36f8e::getInitializer($loader));
+        } else {
+            $map = require __DIR__ . '/autoload_namespaces.php';
+            foreach ($map as $namespace => $path) {
+                $loader->set($namespace, $path);
+            }
+
+            $map = require __DIR__ . '/autoload_psr4.php';
+            foreach ($map as $namespace => $path) {
+                $loader->setPsr4($namespace, $path);
+            }
+
+            $classMap = require __DIR__ . '/autoload_classmap.php';
+            if ($classMap) {
+                $loader->addClassMap($classMap);
+            }
+        }
+
+        $loader->register(true);
+
+        if ($useStaticLoader) {
+            $includeFiles = Composer\Autoload\ComposerStaticInite213e65b2dafae4ad799b13fe0d36f8e::$files;
+        } else {
+            $includeFiles = require __DIR__ . '/autoload_files.php';
+        }
+        foreach ($includeFiles as $fileIdentifier => $file) {
+            composerRequiree213e65b2dafae4ad799b13fe0d36f8e($fileIdentifier, $file);
+        }
+
+        return $loader;
+    }
+}
+
+function composerRequiree213e65b2dafae4ad799b13fe0d36f8e($fileIdentifier, $file)
+{
+    if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
+        require $file;
+
+        $GLOBALS['__composer_autoload_files'][$fileIdentifier] = true;
+    }
+}

+<?php
+
+// autoload_static.php @generated by Composer
+
+namespace Composer\Autoload;
+
+class ComposerStaticInite213e65b2dafae4ad799b13fe0d36f8e
+{
+    public static $files = array (
+        '5255c38a0faeba867671b61dfda6d864' => __DIR__ . '/..' . '/paragonie/random_compat/lib/random.php',
+        '3109cb1a231dcd04bee1f9f620d46975' => __DIR__ . '/..' . '/paragonie/sodium_compat/autoload.php',
+    );
+
+    public static function getInitializer(ClassLoader $loader)
+    {
+        return \Closure::bind(function () use ($loader) {
+
+        }, null, ClassLoader::class);
+    }
+}

+[
+    {
+        "name": "paragonie/random_compat",
+        "version": "v2.0.17",
+        "version_normalized": "2.0.17.0",
+        "source": {
+            "type": "git",
+            "url": "https://github.com/paragonie/random_compat.git",
+            "reference": "29af24f25bab834fcbb38ad2a69fa93b867e070d"
+        },
+        "dist": {
+            "type": "zip",
+            "url": "https://api.github.com/repos/paragonie/random_compat/zipball/29af24f25bab834fcbb38ad2a69fa93b867e070d",
+            "reference": "29af24f25bab834fcbb38ad2a69fa93b867e070d",
+            "shasum": ""
+        },
+        "require": {
+            "php": ">=5.2.0"
+        },
+        "require-dev": {
+            "phpunit/phpunit": "4.*|5.*"
+        },
+        "suggest": {
+            "ext-libsodium": "Provides a modern crypto API that can be used to generate random bytes."
+        },
+        "time": "2018-07-04T16:31:37+00:00",
+        "type": "library",
+        "installation-source": "dist",
+        "autoload": {
+            "files": [
+                "lib/random.php"
+            ]
+        },
+        "notification-url": "https://packagist.org/downloads/",
+        "license": [
+            "MIT"
+        ],
+        "authors": [
+            {
+                "name": "Paragon Initiative Enterprises",
+                "email": "security@paragonie.com",
+                "homepage": "https://paragonie.com"
+            }
+        ],
+        "description": "PHP 5.x polyfill for random_bytes() and random_int() from PHP 7",
+        "keywords": [
+            "csprng",
+            "polyfill",
+            "pseudorandom",
+            "random"
+        ]
+    },
+    {
+        "name": "paragonie/sodium_compat",
+        "version": "v1.13.0",
+        "version_normalized": "1.13.0.0",
+        "source": {
+            "type": "git",
+            "url": "https://github.com/paragonie/sodium_compat.git",
+            "reference": "bbade402cbe84c69b718120911506a3aa2bae653"
+        },
+        "dist": {
+            "type": "zip",
+            "url": "https://api.github.com/repos/paragonie/sodium_compat/zipball/bbade402cbe84c69b718120911506a3aa2bae653",
+            "reference": "bbade402cbe84c69b718120911506a3aa2bae653",
+            "shasum": ""
+        },
+        "require": {
+            "paragonie/random_compat": ">=1",
+            "php": "^5.2.4|^5.3|^5.4|^5.5|^5.6|^7|^8"
+        },
+        "require-dev": {
+            "phpunit/phpunit": "^3|^4|^5|^6|^7"
+        },
+        "suggest": {
+            "ext-libsodium": "PHP < 7.0: Better performance, password hashing (Argon2i), secure memory management (memzero), and better security.",
+            "ext-sodium": "PHP >= 7.0: Better performance, password hashing (Argon2i), secure memory management (memzero), and better security."
+        },
+        "time": "2020-03-20T21:48:09+00:00",
+        "type": "library",
+        "installation-source": "dist",
+        "autoload": {
+            "files": [
+                "autoload.php"
+            ]
+        },
+        "notification-url": "https://packagist.org/downloads/",
+        "license": [
+            "ISC"
+        ],
+        "authors": [
+            {
+                "name": "Paragon Initiative Enterprises",
+                "email": "security@paragonie.com"
+            },
+            {
+                "name": "Frank Denis",
+                "email": "jedisct1@pureftpd.org"
+            }
+        ],
+        "description": "Pure PHP implementation of libsodium; uses the PHP extension if it exists",
+        "keywords": [
+            "Authentication",
+            "BLAKE2b",
+            "ChaCha20",
+            "ChaCha20-Poly1305",
+            "Chapoly",
+            "Curve25519",
+            "Ed25519",
+            "EdDSA",
+            "Edwards-curve Digital Signature Algorithm",
+            "Elliptic Curve Diffie-Hellman",
+            "Poly1305",
+            "Pure-PHP cryptography",
+            "RFC 7748",
+            "RFC 8032",
+            "Salpoly",
+            "Salsa20",
+            "X25519",
+            "XChaCha20-Poly1305",
+            "XSalsa20-Poly1305",
+            "Xchacha20",
+            "Xsalsa20",
+            "aead",
+            "cryptography",
+            "ecdh",
+            "elliptic curve",
+            "elliptic curve cryptography",
+            "encryption",
+            "libsodium",
+            "php",
+            "public-key cryptography",
+            "secret-key cryptography",
+            "side-channel resistant"
+        ]
+    }
+]

+<?php return array (
+  'root' => 
+  array (
+    'pretty_version' => 'dev-master',
+    'version' => 'dev-master',
+    'aliases' => 
+    array (
+    ),
+    'reference' => '547ce2234fff039cbd57697d05f7236e431868e5',
+    'name' => '__root__',
+  ),
+  'versions' => 
+  array (
+    '__root__' => 
+    array (
+      'pretty_version' => 'dev-master',
+      'version' => 'dev-master',
+      'aliases' => 
+      array (
+      ),
+      'reference' => '547ce2234fff039cbd57697d05f7236e431868e5',
+    ),
+    'paragonie/random_compat' => 
+    array (
+      'pretty_version' => 'v2.0.10',
+      'version' => '2.0.10.0',
+      'aliases' => 
+      array (
+      ),
+      'reference' => '634bae8e911eefa89c1abfbf1b66da679ac8f54d',
+    ),
+    'paragonie/sodium_compat' => 
+    array (
+      'pretty_version' => 'v1.13.0',
+      'version' => '1.13.0.0',
+      'aliases' => 
+      array (
+      ),
+      'reference' => 'bbade402cbe84c69b718120911506a3aa2bae653',
+    ),
+  ),
+);

+<?php
+
+// platform_check.php @generated by Composer
+
+$issues = array();
+
+if (!(PHP_VERSION_ID >= 50204)) {
+    $issues[] = 'Your Composer dependencies require a PHP version ">= 5.2.4". You are running ' . PHP_VERSION . '.';
+}
+
+if ($issues) {
+    if (!headers_sent()) {
+        header('HTTP/1.1 500 Internal Server Error');
+    }
+    if (!ini_get('display_errors')) {
+        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
+            fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL);
+        } elseif (!headers_sent()) {
+            echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL;
+        }
+    }
+    trigger_error(
+        'Composer detected issues in your platform: ' . implode(' ', $issues),
+        E_USER_ERROR
+    );
+}

+The MIT License (MIT)
+
+Copyright (c) 2015 Paragon Initiative Enterprises
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

+-----BEGIN PUBLIC KEY-----
+MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEEd+wCqJDrx5B4OldM0dQE0ZMX+lx1ZWm
+pui0SUqD4G29L3NGsz9UhJ/0HjBdbnkhIK5xviT0X5vtjacF6ajgcCArbTB+ds+p
++h7Q084NuSuIpNb6YPfoUFgC/CL9kAoc
+-----END PUBLIC KEY-----

+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.22 (MingW32)
+
+iQEcBAABAgAGBQJWtW1hAAoJEGuXocKCZATaJf0H+wbZGgskK1dcRTsuVJl9IWip
+QwGw/qIKI280SD6/ckoUMxKDCJiFuPR14zmqnS36k7N5UNPnpdTJTS8T11jttSpg
+1LCmgpbEIpgaTah+cELDqFCav99fS+bEiAL5lWDAHBTE/XPjGVCqeehyPYref4IW
+NDBIEsvnHPHPLsn6X5jq4+Yj5oUixgxaMPiR+bcO4Sh+RzOVB6i2D0upWfRXBFXA
+NNnsg9/zjvoC7ZW73y9uSH+dPJTt/Vgfeiv52/v41XliyzbUyLalf02GNPY+9goV
+JHG1ulEEBJOCiUD9cE1PUIJwHA/HqyhHIvV350YoEFiHl8iSwm7SiZu5kPjaq74=
+=B6+8
+-----END PGP SIGNATURE-----

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!is_callable('RandomCompat_strlen')) {
+    if (
+        defined('MB_OVERLOAD_STRING')
+            &&
+        ((int) ini_get('mbstring.func_overload')) & MB_OVERLOAD_STRING
+    ) {
+        /**
+         * strlen() implementation that isn't brittle to mbstring.func_overload
+         *
+         * This version uses mb_strlen() in '8bit' mode to treat strings as raw
+         * binary rather than UTF-8, ISO-8859-1, etc
+         *
+         * @param string $binary_string
+         *
+         * @throws TypeError
+         *
+         * @return int
+         */
+        function RandomCompat_strlen($binary_string)
+        {
+            if (!is_string($binary_string)) {
+                throw new TypeError(
+                    'RandomCompat_strlen() expects a string'
+                );
+            }
+
+            return (int) mb_strlen($binary_string, '8bit');
+        }
+
+    } else {
+        /**
+         * strlen() implementation that isn't brittle to mbstring.func_overload
+         *
+         * This version just used the default strlen()
+         *
+         * @param string $binary_string
+         *
+         * @throws TypeError
+         *
+         * @return int
+         */
+        function RandomCompat_strlen($binary_string)
+        {
+            if (!is_string($binary_string)) {
+                throw new TypeError(
+                    'RandomCompat_strlen() expects a string'
+                );
+            }
+            return (int) strlen($binary_string);
+        }
+    }
+}
+
+if (!is_callable('RandomCompat_substr')) {
+
+    if (
+        defined('MB_OVERLOAD_STRING')
+            &&
+        ((int) ini_get('mbstring.func_overload')) & MB_OVERLOAD_STRING
+    ) {
+        /**
+         * substr() implementation that isn't brittle to mbstring.func_overload
+         *
+         * This version uses mb_substr() in '8bit' mode to treat strings as raw
+         * binary rather than UTF-8, ISO-8859-1, etc
+         *
+         * @param string $binary_string
+         * @param int $start
+         * @param int|null $length (optional)
+         *
+         * @throws TypeError
+         *
+         * @return string
+         */
+        function RandomCompat_substr($binary_string, $start, $length = null)
+        {
+            if (!is_string($binary_string)) {
+                throw new TypeError(
+                    'RandomCompat_substr(): First argument should be a string'
+                );
+            }
+
+            if (!is_int($start)) {
+                throw new TypeError(
+                    'RandomCompat_substr(): Second argument should be an integer'
+                );
+            }
+
+            if ($length === null) {
+                /**
+                 * mb_substr($str, 0, NULL, '8bit') returns an empty string on
+                 * PHP 5.3, so we have to find the length ourselves.
+                 */
+                /** @var int $length */
+                $length = RandomCompat_strlen($binary_string) - $start;
+            } elseif (!is_int($length)) {
+                throw new TypeError(
+                    'RandomCompat_substr(): Third argument should be an integer, or omitted'
+                );
+            }
+
+            // Consistency with PHP's behavior
+            if ($start === RandomCompat_strlen($binary_string) && $length === 0) {
+                return '';
+            }
+            if ($start > RandomCompat_strlen($binary_string)) {
+                return '';
+            }
+
+            return (string) mb_substr(
+                (string) $binary_string,
+                (int) $start,
+                (int) $length,
+                '8bit'
+            );
+        }
+
+    } else {
+
+        /**
+         * substr() implementation that isn't brittle to mbstring.func_overload
+         *
+         * This version just uses the default substr()
+         *
+         * @param string $binary_string
+         * @param int $start
+         * @param int|null $length (optional)
+         *
+         * @throws TypeError
+         *
+         * @return string
+         */
+        function RandomCompat_substr($binary_string, $start, $length = null)
+        {
+            if (!is_string($binary_string)) {
+                throw new TypeError(
+                    'RandomCompat_substr(): First argument should be a string'
+                );
+            }
+
+            if (!is_int($start)) {
+                throw new TypeError(
+                    'RandomCompat_substr(): Second argument should be an integer'
+                );
+            }
+
+            if ($length !== null) {
+                if (!is_int($length)) {
+                    throw new TypeError(
+                        'RandomCompat_substr(): Third argument should be an integer, or omitted'
+                    );
+                }
+
+                return (string) substr(
+                    (string )$binary_string,
+                    (int) $start,
+                    (int) $length
+                );
+            }
+
+            return (string) substr(
+                (string) $binary_string,
+                (int) $start
+            );
+        }
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!is_callable('RandomCompat_intval')) {
+    
+    /**
+     * Cast to an integer if we can, safely.
+     * 
+     * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
+     * (non-inclusive), it will sanely cast it to an int. If you it's equal to
+     * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats 
+     * lose precision, so the <= and => operators might accidentally let a float
+     * through.
+     * 
+     * @param int|float $number    The number we want to convert to an int
+     * @param bool      $fail_open Set to true to not throw an exception
+     * 
+     * @return float|int
+     * @psalm-suppress InvalidReturnType
+     *
+     * @throws TypeError
+     */
+    function RandomCompat_intval($number, $fail_open = false)
+    {
+        if (is_int($number) || is_float($number)) {
+            $number += 0;
+        } elseif (is_numeric($number)) {
+            /** @psalm-suppress InvalidOperand */
+            $number += 0;
+        }
+        /** @var int|float $number */
+
+        if (
+            is_float($number)
+                &&
+            $number > ~PHP_INT_MAX
+                &&
+            $number < PHP_INT_MAX
+        ) {
+            $number = (int) $number;
+        }
+
+        if (is_int($number)) {
+            return (int) $number;
+        } elseif (!$fail_open) {
+            throw new TypeError(
+                'Expected an integer.'
+            );
+        }
+        return $number;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library 
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ * 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!class_exists('Error', false)) {
+    // We can't really avoid making this extend Exception in PHP 5.
+    class Error extends Exception
+    {
+        
+    }
+}
+
+if (!class_exists('TypeError', false)) {
+    if (is_subclass_of('Error', 'Exception')) {
+        class TypeError extends Error
+        {
+            
+        }
+    } else {
+        class TypeError extends Exception
+        {
+            
+        }
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ *
+ * @version 2.0.17
+ * @released 2018-07-04
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!defined('PHP_VERSION_ID')) {
+    // This constant was introduced in PHP 5.2.7
+    $RandomCompatversion = array_map('intval', explode('.', PHP_VERSION));
+    define(
+        'PHP_VERSION_ID',
+        $RandomCompatversion[0] * 10000
+        + $RandomCompatversion[1] * 100
+        + $RandomCompatversion[2]
+    );
+    $RandomCompatversion = null;
+}
+
+/**
+ * PHP 7.0.0 and newer have these functions natively.
+ */
+if (PHP_VERSION_ID >= 70000) {
+    return;
+}
+
+if (!defined('RANDOM_COMPAT_READ_BUFFER')) {
+    define('RANDOM_COMPAT_READ_BUFFER', 8);
+}
+
+$RandomCompatDIR = dirname(__FILE__);
+
+require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'byte_safe_strings.php';
+require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'cast_to_int.php';
+require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'error_polyfill.php';
+
+if (!is_callable('random_bytes')) {
+    /**
+     * PHP 5.2.0 - 5.6.x way to implement random_bytes()
+     *
+     * We use conditional statements here to define the function in accordance
+     * to the operating environment. It's a micro-optimization.
+     *
+     * In order of preference:
+     *   1. Use libsodium if available.
+     *   2. fread() /dev/urandom if available (never on Windows)
+     *   3. mcrypt_create_iv($bytes, MCRYPT_DEV_URANDOM)
+     *   4. COM('CAPICOM.Utilities.1')->GetRandom()
+     *
+     * See RATIONALE.md for our reasoning behind this particular order
+     */
+    if (extension_loaded('libsodium')) {
+        // See random_bytes_libsodium.php
+        if (PHP_VERSION_ID >= 50300 && is_callable('\\Sodium\\randombytes_buf')) {
+            require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_libsodium.php';
+        } elseif (method_exists('Sodium', 'randombytes_buf')) {
+            require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_libsodium_legacy.php';
+        }
+    }
+
+    /**
+     * Reading directly from /dev/urandom:
+     */
+    if (DIRECTORY_SEPARATOR === '/') {
+        // DIRECTORY_SEPARATOR === '/' on Unix-like OSes -- this is a fast
+        // way to exclude Windows.
+        $RandomCompatUrandom = true;
+        $RandomCompat_basedir = ini_get('open_basedir');
+
+        if (!empty($RandomCompat_basedir)) {
+            $RandomCompat_open_basedir = explode(
+                PATH_SEPARATOR,
+                strtolower($RandomCompat_basedir)
+            );
+            $RandomCompatUrandom = (array() !== array_intersect(
+                array('/dev', '/dev/', '/dev/urandom'),
+                $RandomCompat_open_basedir
+            ));
+            $RandomCompat_open_basedir = null;
+        }
+
+        if (
+            !is_callable('random_bytes')
+            &&
+            $RandomCompatUrandom
+            &&
+            @is_readable('/dev/urandom')
+        ) {
+            // Error suppression on is_readable() in case of an open_basedir
+            // or safe_mode failure. All we care about is whether or not we
+            // can read it at this point. If the PHP environment is going to
+            // panic over trying to see if the file can be read in the first
+            // place, that is not helpful to us here.
+
+            // See random_bytes_dev_urandom.php
+            require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_dev_urandom.php';
+        }
+        // Unset variables after use
+        $RandomCompat_basedir = null;
+    } else {
+        $RandomCompatUrandom = false;
+    }
+
+    /**
+     * mcrypt_create_iv()
+     *
+     * We only want to use mcypt_create_iv() if:
+     *
+     * - random_bytes() hasn't already been defined
+     * - the mcrypt extensions is loaded
+     * - One of these two conditions is true:
+     *   - We're on Windows (DIRECTORY_SEPARATOR !== '/')
+     *   - We're not on Windows and /dev/urandom is readabale
+     *     (i.e. we're not in a chroot jail)
+     * - Special case:
+     *   - If we're not on Windows, but the PHP version is between
+     *     5.6.10 and 5.6.12, we don't want to use mcrypt. It will
+     *     hang indefinitely. This is bad.
+     *   - If we're on Windows, we want to use PHP >= 5.3.7 or else
+     *     we get insufficient entropy errors.
+     */
+    if (
+        !is_callable('random_bytes')
+        &&
+        // Windows on PHP < 5.3.7 is broken, but non-Windows is not known to be.
+        (DIRECTORY_SEPARATOR === '/' || PHP_VERSION_ID >= 50307)
+        &&
+        // Prevent this code from hanging indefinitely on non-Windows;
+        // see https://bugs.php.net/bug.php?id=69833
+        (
+            DIRECTORY_SEPARATOR !== '/' ||
+            (PHP_VERSION_ID <= 50609 || PHP_VERSION_ID >= 50613)
+        )
+        &&
+        extension_loaded('mcrypt')
+    ) {
+        // See random_bytes_mcrypt.php
+        require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_mcrypt.php';
+    }
+    $RandomCompatUrandom = null;
+
+    /**
+     * This is a Windows-specific fallback, for when the mcrypt extension
+     * isn't loaded.
+     */
+    if (
+        !is_callable('random_bytes')
+        &&
+        extension_loaded('com_dotnet')
+        &&
+        class_exists('COM')
+    ) {
+        $RandomCompat_disabled_classes = preg_split(
+            '#\s*,\s*#',
+            strtolower(ini_get('disable_classes'))
+        );
+
+        if (!in_array('com', $RandomCompat_disabled_classes)) {
+            try {
+                $RandomCompatCOMtest = new COM('CAPICOM.Utilities.1');
+                if (method_exists($RandomCompatCOMtest, 'GetRandom')) {
+                    // See random_bytes_com_dotnet.php
+                    require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_bytes_com_dotnet.php';
+                }
+            } catch (com_exception $e) {
+                // Don't try to use it.
+            }
+        }
+        $RandomCompat_disabled_classes = null;
+        $RandomCompatCOMtest = null;
+    }
+
+    /**
+     * throw new Exception
+     */
+    if (!is_callable('random_bytes')) {
+        /**
+         * We don't have any more options, so let's throw an exception right now
+         * and hope the developer won't let it fail silently.
+         *
+         * @param mixed $length
+         * @psalm-suppress InvalidReturnType
+         * @throws Exception
+         * @return string
+         */
+        function random_bytes($length)
+        {
+            unset($length); // Suppress "variable not used" warnings.
+            throw new Exception(
+                'There is no suitable CSPRNG installed on your system'
+            );
+            return '';
+        }
+    }
+}
+
+if (!is_callable('random_int')) {
+    require_once $RandomCompatDIR . DIRECTORY_SEPARATOR . 'random_int.php';
+}
+
+$RandomCompatDIR = null;

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library 
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ * 
+ * The MIT License (MIT)
+ * 
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!is_callable('random_bytes')) {
+    /**
+     * Windows with PHP < 5.3.0 will not have the function
+     * openssl_random_pseudo_bytes() available, so let's use
+     * CAPICOM to work around this deficiency.
+     *
+     * @param int $bytes
+     *
+     * @throws Exception
+     *
+     * @return string
+     */
+    function random_bytes($bytes)
+    {
+        try {
+            /** @var int $bytes */
+            $bytes = RandomCompat_intval($bytes);
+        } catch (TypeError $ex) {
+            throw new TypeError(
+                'random_bytes(): $bytes must be an integer'
+            );
+        }
+
+        if ($bytes < 1) {
+            throw new Error(
+                'Length must be greater than 0'
+            );
+        }
+
+        /** @var string $buf */
+        $buf = '';
+        if (!class_exists('COM')) {
+            throw new Error(
+                'COM does not exist'
+            );
+        }
+        /** @var COM $util */
+        $util = new COM('CAPICOM.Utilities.1');
+        $execCount = 0;
+
+        /**
+         * Let's not let it loop forever. If we run N times and fail to
+         * get N bytes of random data, then CAPICOM has failed us.
+         */
+        do {
+            $buf .= base64_decode((string) $util->GetRandom($bytes, 0));
+            if (RandomCompat_strlen($buf) >= $bytes) {
+                /**
+                 * Return our random entropy buffer here:
+                 */
+                return (string) RandomCompat_substr($buf, 0, $bytes);
+            }
+            ++$execCount;
+        } while ($execCount < $bytes);
+
+        /**
+         * If we reach here, PHP has failed us.
+         */
+        throw new Exception(
+            'Could not gather sufficient random data'
+        );
+    }
+}
\ No newline at end of file

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library 
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ * 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!defined('RANDOM_COMPAT_READ_BUFFER')) {
+    define('RANDOM_COMPAT_READ_BUFFER', 8);
+}
+
+if (!is_callable('random_bytes')) {
+    /**
+     * Unless open_basedir is enabled, use /dev/urandom for
+     * random numbers in accordance with best practices
+     *
+     * Why we use /dev/urandom and not /dev/random
+     * @ref http://sockpuppet.org/blog/2014/02/25/safely-generate-random-numbers
+     *
+     * @param int $bytes
+     *
+     * @throws Exception
+     *
+     * @return string
+     */
+    function random_bytes($bytes)
+    {
+        /** @var resource $fp */
+        static $fp = null;
+
+        /**
+         * This block should only be run once
+         */
+        if (empty($fp)) {
+            /**
+             * We use /dev/urandom if it is a char device.
+             * We never fall back to /dev/random
+             */
+            /** @var resource|bool $fp */
+            $fp = fopen('/dev/urandom', 'rb');
+            if (is_resource($fp)) {
+                /** @var array<string, int> $st */
+                $st = fstat($fp);
+                if (($st['mode'] & 0170000) !== 020000) {
+                    fclose($fp);
+                    $fp = false;
+                }
+            }
+
+            if (is_resource($fp)) {
+                /**
+                 * stream_set_read_buffer() does not exist in HHVM
+                 *
+                 * If we don't set the stream's read buffer to 0, PHP will
+                 * internally buffer 8192 bytes, which can waste entropy
+                 *
+                 * stream_set_read_buffer returns 0 on success
+                 */
+                if (is_callable('stream_set_read_buffer')) {
+                    stream_set_read_buffer($fp, RANDOM_COMPAT_READ_BUFFER);
+                }
+                if (is_callable('stream_set_chunk_size')) {
+                    stream_set_chunk_size($fp, RANDOM_COMPAT_READ_BUFFER);
+                }
+            }
+        }
+
+        try {
+            /** @var int $bytes */
+            $bytes = RandomCompat_intval($bytes);
+        } catch (TypeError $ex) {
+            throw new TypeError(
+                'random_bytes(): $bytes must be an integer'
+            );
+        }
+
+        if ($bytes < 1) {
+            throw new Error(
+                'Length must be greater than 0'
+            );
+        }
+
+        /**
+         * This if() block only runs if we managed to open a file handle
+         *
+         * It does not belong in an else {} block, because the above
+         * if (empty($fp)) line is logic that should only be run once per
+         * page load.
+         */
+        if (is_resource($fp)) {
+            /**
+             * @var int
+             */
+            $remaining = $bytes;
+
+            /**
+             * @var string|bool
+             */
+            $buf = '';
+
+            /**
+             * We use fread() in a loop to protect against partial reads
+             */
+            do {
+                /**
+                 * @var string|bool
+                 */
+                $read = fread($fp, $remaining);
+                if (!is_string($read)) {
+                    if ($read === false) {
+                        /**
+                         * We cannot safely read from the file. Exit the
+                         * do-while loop and trigger the exception condition
+                         *
+                         * @var string|bool
+                         */
+                        $buf = false;
+                        break;
+                    }
+                }
+                /**
+                 * Decrease the number of bytes returned from remaining
+                 */
+                $remaining -= RandomCompat_strlen($read);
+                /**
+                 * @var string|bool
+                 */
+                $buf = $buf . $read;
+            } while ($remaining > 0);
+
+            /**
+             * Is our result valid?
+             */
+            if (is_string($buf)) {
+                if (RandomCompat_strlen($buf) === $bytes) {
+                    /**
+                     * Return our random entropy buffer here:
+                     */
+                    return $buf;
+                }
+            }
+        }
+
+        /**
+         * If we reach here, PHP has failed us.
+         */
+        throw new Exception(
+            'Error reading from source device'
+        );
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library 
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ * 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!is_callable('random_bytes')) {
+    /**
+     * If the libsodium PHP extension is loaded, we'll use it above any other
+     * solution.
+     *
+     * libsodium-php project:
+     * @ref https://github.com/jedisct1/libsodium-php
+     *
+     * @param int $bytes
+     *
+     * @throws Exception
+     *
+     * @return string
+     */
+    function random_bytes($bytes)
+    {
+        try {
+            /** @var int $bytes */
+            $bytes = RandomCompat_intval($bytes);
+        } catch (TypeError $ex) {
+            throw new TypeError(
+                'random_bytes(): $bytes must be an integer'
+            );
+        }
+
+        if ($bytes < 1) {
+            throw new Error(
+                'Length must be greater than 0'
+            );
+        }
+
+        /**
+         * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
+         * generated in one invocation.
+         */
+        /** @var string|bool $buf */
+        if ($bytes > 2147483647) {
+            $buf = '';
+            for ($i = 0; $i < $bytes; $i += 1073741824) {
+                $n = ($bytes - $i) > 1073741824
+                    ? 1073741824
+                    : $bytes - $i;
+                $buf .= \Sodium\randombytes_buf($n);
+            }
+        } else {
+            /** @var string|bool $buf */
+            $buf = \Sodium\randombytes_buf($bytes);
+        }
+
+        if (is_string($buf)) {
+            if (RandomCompat_strlen($buf) === $bytes) {
+                return $buf;
+            }
+        }
+
+        /**
+         * If we reach here, PHP has failed us.
+         */
+        throw new Exception(
+            'Could not gather sufficient random data'
+        );
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library 
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ * 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!is_callable('random_bytes')) {
+    /**
+     * If the libsodium PHP extension is loaded, we'll use it above any other
+     * solution.
+     *
+     * libsodium-php project:
+     * @ref https://github.com/jedisct1/libsodium-php
+     *
+     * @param int $bytes
+     *
+     * @throws Exception
+     *
+     * @return string
+     */
+    function random_bytes($bytes)
+    {
+        try {
+            /** @var int $bytes */
+            $bytes = RandomCompat_intval($bytes);
+        } catch (TypeError $ex) {
+            throw new TypeError(
+                'random_bytes(): $bytes must be an integer'
+            );
+        }
+
+        if ($bytes < 1) {
+            throw new Error(
+                'Length must be greater than 0'
+            );
+        }
+
+        /**
+         * @var string
+         */
+        $buf = '';
+
+        /**
+         * \Sodium\randombytes_buf() doesn't allow more than 2147483647 bytes to be
+         * generated in one invocation.
+         */
+        if ($bytes > 2147483647) {
+            for ($i = 0; $i < $bytes; $i += 1073741824) {
+                $n = ($bytes - $i) > 1073741824
+                    ? 1073741824
+                    : $bytes - $i;
+                $buf .= Sodium::randombytes_buf((int) $n);
+            }
+        } else {
+            $buf .= Sodium::randombytes_buf((int) $bytes);
+        }
+
+        if (is_string($buf)) {
+            if (RandomCompat_strlen($buf) === $bytes) {
+                return $buf;
+            }
+        }
+
+        /**
+         * If we reach here, PHP has failed us.
+         */
+        throw new Exception(
+            'Could not gather sufficient random data'
+        );
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/**
+ * Random_* Compatibility Library 
+ * for using the new PHP 7 random_* API in PHP 5 projects
+ * 
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+if (!is_callable('random_bytes')) {
+    /**
+     * Powered by ext/mcrypt (and thankfully NOT libmcrypt)
+     *
+     * @ref https://bugs.php.net/bug.php?id=55169
+     * @ref https://github.com/php/php-src/blob/c568ffe5171d942161fc8dda066bce844bdef676/ext/mcrypt/mcrypt.c#L1321-L1386
+     *
+     * @param int $bytes
+     *
+     * @throws Exception
+     *
+     * @return string
+     */
+    function random_bytes($bytes)
+    {
+        try {
+            /** @var int $bytes */
+            $bytes = RandomCompat_intval($bytes);
+        } catch (TypeError $ex) {
+            throw new TypeError(
+                'random_bytes(): $bytes must be an integer'
+            );
+        }
+
+        if ($bytes < 1) {
+            throw new Error(
+                'Length must be greater than 0'
+            );
+        }
+
+        /** @var string|bool $buf */
+        $buf = @mcrypt_create_iv((int) $bytes, (int) MCRYPT_DEV_URANDOM);
+        if (
+            is_string($buf)
+                &&
+            RandomCompat_strlen($buf) === $bytes
+        ) {
+            /**
+             * Return our random entropy buffer here:
+             */
+            return $buf;
+        }
+
+        /**
+         * If we reach here, PHP has failed us.
+         */
+        throw new Exception(
+            'Could not gather sufficient random data'
+        );
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (!is_callable('random_int')) {
+    /**
+     * Random_* Compatibility Library
+     * for using the new PHP 7 random_* API in PHP 5 projects
+     *
+     * The MIT License (MIT)
+     *
+     * Copyright (c) 2015 - 2018 Paragon Initiative Enterprises
+     *
+     * Permission is hereby granted, free of charge, to any person obtaining a copy
+     * of this software and associated documentation files (the "Software"), to deal
+     * in the Software without restriction, including without limitation the rights
+     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+     * copies of the Software, and to permit persons to whom the Software is
+     * furnished to do so, subject to the following conditions:
+     *
+     * The above copyright notice and this permission notice shall be included in
+     * all copies or substantial portions of the Software.
+     *
+     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+     * SOFTWARE.
+     */
+
+    /**
+     * Fetch a random integer between $min and $max inclusive
+     *
+     * @param int $min
+     * @param int $max
+     *
+     * @throws Exception
+     *
+     * @return int
+     */
+    function random_int($min, $max)
+    {
+        /**
+         * Type and input logic checks
+         *
+         * If you pass it a float in the range (~PHP_INT_MAX, PHP_INT_MAX)
+         * (non-inclusive), it will sanely cast it to an int. If you it's equal to
+         * ~PHP_INT_MAX or PHP_INT_MAX, we let it fail as not an integer. Floats
+         * lose precision, so the <= and => operators might accidentally let a float
+         * through.
+         */
+
+        try {
+            /** @var int $min */
+            $min = RandomCompat_intval($min);
+        } catch (TypeError $ex) {
+            throw new TypeError(
+                'random_int(): $min must be an integer'
+            );
+        }
+
+        try {
+            /** @var int $max */
+            $max = RandomCompat_intval($max);
+        } catch (TypeError $ex) {
+            throw new TypeError(
+                'random_int(): $max must be an integer'
+            );
+        }
+
+        /**
+         * Now that we've verified our weak typing system has given us an integer,
+         * let's validate the logic then we can move forward with generating random
+         * integers along a given range.
+         */
+        if ($min > $max) {
+            throw new Error(
+                'Minimum value must be less than or equal to the maximum value'
+            );
+        }
+
+        if ($max === $min) {
+            return (int) $min;
+        }
+
+        /**
+         * Initialize variables to 0
+         *
+         * We want to store:
+         * $bytes => the number of random bytes we need
+         * $mask => an integer bitmask (for use with the &) operator
+         *          so we can minimize the number of discards
+         */
+        $attempts = $bits = $bytes = $mask = $valueShift = 0;
+        /** @var int $attempts */
+        /** @var int $bits */
+        /** @var int $bytes */
+        /** @var int $mask */
+        /** @var int $valueShift */
+
+        /**
+         * At this point, $range is a positive number greater than 0. It might
+         * overflow, however, if $max - $min > PHP_INT_MAX. PHP will cast it to
+         * a float and we will lose some precision.
+         *
+         * @var int|float $range
+         */
+        $range = $max - $min;
+
+        /**
+         * Test for integer overflow:
+         */
+        if (!is_int($range)) {
+
+            /**
+             * Still safely calculate wider ranges.
+             * Provided by @CodesInChaos, @oittaa
+             *
+             * @ref https://gist.github.com/CodesInChaos/03f9ea0b58e8b2b8d435
+             *
+             * We use ~0 as a mask in this case because it generates all 1s
+             *
+             * @ref https://eval.in/400356 (32-bit)
+             * @ref http://3v4l.org/XX9r5  (64-bit)
+             */
+            $bytes = PHP_INT_SIZE;
+            /** @var int $mask */
+            $mask = ~0;
+
+        } else {
+
+            /**
+             * $bits is effectively ceil(log($range, 2)) without dealing with
+             * type juggling
+             */
+            while ($range > 0) {
+                if ($bits % 8 === 0) {
+                    ++$bytes;
+                }
+                ++$bits;
+                $range >>= 1;
+                /** @var int $mask */
+                $mask = $mask << 1 | 1;
+            }
+            $valueShift = $min;
+        }
+
+        /** @var int $val */
+        $val = 0;
+        /**
+         * Now that we have our parameters set up, let's begin generating
+         * random integers until one falls between $min and $max
+         */
+        /** @psalm-suppress RedundantCondition */
+        do {
+            /**
+             * The rejection probability is at most 0.5, so this corresponds
+             * to a failure probability of 2^-128 for a working RNG
+             */
+            if ($attempts > 128) {
+                throw new Exception(
+                    'random_int: RNG is broken - too many rejections'
+                );
+            }
+
+            /**
+             * Let's grab the necessary number of random bytes
+             */
+            $randomByteString = random_bytes($bytes);
+
+            /**
+             * Let's turn $randomByteString into an integer
+             *
+             * This uses bitwise operators (<< and |) to build an integer
+             * out of the values extracted from ord()
+             *
+             * Example: [9F] | [6D] | [32] | [0C] =>
+             *   159 + 27904 + 3276800 + 201326592 =>
+             *   204631455
+             */
+            $val &= 0;
+            for ($i = 0; $i < $bytes; ++$i) {
+                $val |= ord($randomByteString[$i]) << ($i * 8);
+            }
+            /** @var int $val */
+
+            /**
+             * Apply mask
+             */
+            $val &= $mask;
+            $val += $valueShift;
+
+            ++$attempts;
+            /**
+             * If $val overflows to a floating point number,
+             * ... or is larger than $max,
+             * ... or smaller than $min,
+             * then try again.
+             */
+        } while (!is_int($val) || $val > $max || $val < $min);
+
+        return (int) $val;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+require_once 'lib/byte_safe_strings.php';
+require_once 'lib/cast_to_int.php';
+require_once 'lib/error_polyfill.php';
+require_once 'other/ide_stubs/libsodium.php';
+require_once 'lib/random.php';
+
+$int = random_int(0, 65536);

+/*
+ * ISC License
+ *
+ * Copyright (c) 2016-2019
+ * Paragon Initiative Enterprises <security at paragonie dot com>
+ *
+ * Copyright (c) 2013-2019
+ * Frank Denis <j at pureftpd dot org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
\ No newline at end of file

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+require_once 'autoload.php';
+ParagonIE_Sodium_Compat::$fastMult = true;

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+require_once 'autoload.php';
+define('DO_PEDANTIC_TEST', true);
+
+ParagonIE_Sodium_Compat::$fastMult = true;

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+/*
+ This file should only ever be loaded on PHP 7+
+ */
+if (PHP_VERSION_ID < 70000) {
+    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;
+    }
+
+    // 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;
+});

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+require_once (dirname(__FILE__) . '/vendor/autoload.php');
+
+if (PHP_VERSION_ID >= 50300) {
+    require_once (dirname(__FILE__) . '/tests/phpunit-shim.php');
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+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;
+            }
+
+            // 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;
+        }
+
+        // Now that we have an autoloader, let's register it!
+        spl_autoload_register('sodiumCompatAutoloader');
+    }
+} else {
+    require_once dirname(__FILE__) . '/autoload-php7.php';
+}
+
+if (!class_exists('SodiumException', false)) {
+    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';
+} else {
+    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');
+}

+{
+  "name": "paragonie/sodium_compat",
+  "description": "Pure PHP implementation of libsodium; uses the PHP extension if it exists",
+  "keywords": [
+    "PHP",
+    "cryptography",
+    "elliptic curve",
+    "elliptic curve cryptography",
+    "Pure-PHP cryptography",
+    "side-channel resistant",
+    "Curve25519",
+    "X25519",
+    "ECDH",
+    "Elliptic Curve Diffie-Hellman",
+    "Ed25519",
+    "RFC 7748",
+    "RFC 8032",
+    "EdDSA",
+    "Edwards-curve Digital Signature Algorithm",
+    "ChaCha20",
+    "Salsa20",
+    "Xchacha20",
+    "Xsalsa20",
+    "Poly1305",
+    "BLAKE2b",
+    "public-key cryptography",
+    "secret-key cryptography",
+    "AEAD",
+    "Chapoly",
+    "Salpoly",
+    "ChaCha20-Poly1305",
+    "XSalsa20-Poly1305",
+    "XChaCha20-Poly1305",
+    "encryption",
+    "authentication",
+    "libsodium"
+  ],
+  "license": "ISC",
+  "authors": [
+    {
+      "name": "Paragon Initiative Enterprises",
+      "email": "security@paragonie.com"
+    },
+    {
+      "name": "Frank Denis",
+      "email": "jedisct1@pureftpd.org"
+    }
+  ],
+  "autoload": {
+    "files": ["autoload.php"]
+  },
+  "repositories": [
+    {
+      "type": "git",
+      "url": "https://github.com/garex/phpunit"
+    },
+    {
+      "type": "git",
+      "url": "https://github.com/garex/phpunit-mock-objects"
+    }
+  ],
+  "require": {
+    "php": "^5.2.4|^5.3|^5.4|^5.5|^5.6|^7|^8",
+    "xrstf/composer-php52": "1.*",
+    "paragonie/random_compat": ">=1"
+  },
+  "minimum-stability": "dev",
+  "require-dev": {
+    "phpunit/phpunit-php52": "dev-3.6.12-php52",
+    "phpunit/phpunit-mock-objects-php52": "dev-1.1.0-php52"
+  },
+  "scripts": {
+    "post-install-cmd": [
+      "xrstf\\Composer52\\Generator::onPostInstallCmd"
+    ],
+    "post-update-cmd": [
+      "xrstf\\Composer52\\Generator::onPostInstallCmd"
+    ],
+    "post-autoload-dump": [
+      "xrstf\\Composer52\\Generator::onPostInstallCmd"
+    ]
+  },
+  "suggest": {
+    "ext-libsodium": "PHP < 7.0: Better performance, password hashing (Argon2i), secure memory management (memzero), and better security.",
+    "ext-sodium": "PHP >= 7.0: Better performance, password hashing (Argon2i), secure memory management (memzero), and better security."
+  }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace Sodium;
+
+require_once dirname(dirname(__FILE__)) . '/autoload.php';
+
+use ParagonIE_Sodium_Compat;
+
+const CRYPTO_AEAD_AES256GCM_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_KEYBYTES;
+const CRYPTO_AEAD_AES256GCM_NSECBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_NSECBYTES;
+const CRYPTO_AEAD_AES256GCM_NPUBBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_NPUBBYTES;
+const CRYPTO_AEAD_AES256GCM_ABYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_AES256GCM_ABYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_ABYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_ABYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES;
+const CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES = ParagonIE_Sodium_Compat::CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES;
+const CRYPTO_AUTH_BYTES = ParagonIE_Sodium_Compat::CRYPTO_AUTH_BYTES;
+const CRYPTO_AUTH_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_AUTH_KEYBYTES;
+const CRYPTO_BOX_SEALBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_SEALBYTES;
+const CRYPTO_BOX_SECRETKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_SECRETKEYBYTES;
+const CRYPTO_BOX_PUBLICKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_PUBLICKEYBYTES;
+const CRYPTO_BOX_KEYPAIRBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_KEYPAIRBYTES;
+const CRYPTO_BOX_MACBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_MACBYTES;
+const CRYPTO_BOX_NONCEBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_NONCEBYTES;
+const CRYPTO_BOX_SEEDBYTES = ParagonIE_Sodium_Compat::CRYPTO_BOX_SEEDBYTES;
+const CRYPTO_KX_BYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_BYTES;
+const CRYPTO_KX_SEEDBYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_SEEDBYTES;
+const CRYPTO_KX_PUBLICKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_PUBLICKEYBYTES;
+const CRYPTO_KX_SECRETKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_KX_SECRETKEYBYTES;
+const CRYPTO_GENERICHASH_BYTES = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES;
+const CRYPTO_GENERICHASH_BYTES_MIN = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MIN;
+const CRYPTO_GENERICHASH_BYTES_MAX = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_BYTES_MAX;
+const CRYPTO_GENERICHASH_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES;
+const CRYPTO_GENERICHASH_KEYBYTES_MIN = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MIN;
+const CRYPTO_GENERICHASH_KEYBYTES_MAX = ParagonIE_Sodium_Compat::CRYPTO_GENERICHASH_KEYBYTES_MAX;
+const CRYPTO_SCALARMULT_BYTES = ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_BYTES;
+const CRYPTO_SCALARMULT_SCALARBYTES = ParagonIE_Sodium_Compat::CRYPTO_SCALARMULT_SCALARBYTES;
+const CRYPTO_SHORTHASH_BYTES = ParagonIE_Sodium_Compat::CRYPTO_SHORTHASH_BYTES;
+const CRYPTO_SHORTHASH_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SHORTHASH_KEYBYTES;
+const CRYPTO_SECRETBOX_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_KEYBYTES;
+const CRYPTO_SECRETBOX_MACBYTES = ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_MACBYTES;
+const CRYPTO_SECRETBOX_NONCEBYTES = ParagonIE_Sodium_Compat::CRYPTO_SECRETBOX_NONCEBYTES;
+const CRYPTO_SIGN_BYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_BYTES;
+const CRYPTO_SIGN_SEEDBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_SEEDBYTES;
+const CRYPTO_SIGN_PUBLICKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_PUBLICKEYBYTES;
+const CRYPTO_SIGN_SECRETKEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_SECRETKEYBYTES;
+const CRYPTO_SIGN_KEYPAIRBYTES = ParagonIE_Sodium_Compat::CRYPTO_SIGN_KEYPAIRBYTES;
+const CRYPTO_STREAM_KEYBYTES = ParagonIE_Sodium_Compat::CRYPTO_STREAM_KEYBYTES;
+const CRYPTO_STREAM_NONCEBYTES = ParagonIE_Sodium_Compat::CRYPTO_STREAM_NONCEBYTES;

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+require_once dirname(dirname(__FILE__)) . '/autoload.php';
+
+if (PHP_VERSION_ID < 50300) {
+    return;
+}
+
+/*
+ * This file is just for convenience, to allow developers to reduce verbosity when
+ * they add this project to their libraries.
+ *
+ * Replace this:
+ *
+ * $x = ParagonIE_Sodium_Compat::crypto_aead_xchacha20poly1305_encrypt(...$args);
+ *
+ * with this:
+ *
+ * use ParagonIE\Sodium\Compat;
+ *
+ * $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;
+    }
+
+    // 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;
+});

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+const SODIUM_LIBRARY_MAJOR_VERSION = 9;
+const SODIUM_LIBRARY_MINOR_VERSION = 1;
+const SODIUM_LIBRARY_VERSION = '1.0.8';
+
+const SODIUM_BASE64_VARIANT_ORIGINAL = 1;
+const SODIUM_BASE64_VARIANT_ORIGINAL_NO_PADDING = 3;
+const SODIUM_BASE64_VARIANT_URLSAFE = 5;
+const SODIUM_BASE64_VARIANT_URLSAFE_NO_PADDING = 7;
+const SODIUM_CRYPTO_AEAD_AES256GCM_KEYBYTES = 32;
+const SODIUM_CRYPTO_AEAD_AES256GCM_NSECBYTES = 0;
+const SODIUM_CRYPTO_AEAD_AES256GCM_NPUBBYTES = 12;
+const SODIUM_CRYPTO_AEAD_AES256GCM_ABYTES = 16;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_KEYBYTES = 32;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_NSECBYTES = 0;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_NPUBBYTES = 8;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_ABYTES = 16;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_KEYBYTES = 32;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_NSECBYTES = 0;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_NPUBBYTES = 12;
+const SODIUM_CRYPTO_AEAD_CHACHA20POLY1305_IETF_ABYTES = 16;
+const SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_KEYBYTES = 32;
+const SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NSECBYTES = 0;
+const SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES = 24;
+const SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_ABYTES = 16;
+const SODIUM_CRYPTO_AUTH_BYTES = 32;
+const SODIUM_CRYPTO_AUTH_KEYBYTES = 32;
+const SODIUM_CRYPTO_BOX_SEALBYTES = 16;
+const SODIUM_CRYPTO_BOX_SECRETKEYBYTES = 32;
+const SODIUM_CRYPTO_BOX_PUBLICKEYBYTES = 32;
+const SODIUM_CRYPTO_BOX_KEYPAIRBYTES = 64;
+const SODIUM_CRYPTO_BOX_MACBYTES = 16;
+const SODIUM_CRYPTO_BOX_NONCEBYTES = 24;
+const SODIUM_CRYPTO_BOX_SEEDBYTES = 32;
+const SODIUM_CRYPTO_KDF_BYTES_MIN = 16;
+const SODIUM_CRYPTO_KDF_BYTES_MAX = 64;
+const SODIUM_CRYPTO_KDF_CONTEXTBYTES = 8;
+const SODIUM_CRYPTO_KDF_KEYBYTES = 32;
+const SODIUM_CRYPTO_KX_BYTES = 32;
+const SODIUM_CRYPTO_KX_PRIMITIVE = 'x25519blake2b';
+const SODIUM_CRYPTO_KX_SEEDBYTES = 32;
+const SODIUM_CRYPTO_KX_KEYPAIRBYTES = 64;
+const SODIUM_CRYPTO_KX_PUBLICKEYBYTES = 32;
+const SODIUM_CRYPTO_KX_SECRETKEYBYTES = 32;
+const SODIUM_CRYPTO_KX_SESSIONKEYBYTES = 32;
+const SODIUM_CRYPTO_GENERICHASH_BYTES = 32;
+const SODIUM_CRYPTO_GENERICHASH_BYTES_MIN = 16;
+const SODIUM_CRYPTO_GENERICHASH_BYTES_MAX = 64;
+const SODIUM_CRYPTO_GENERICHASH_KEYBYTES = 32;
+const SODIUM_CRYPTO_GENERICHASH_KEYBYTES_MIN = 16;
+const SODIUM_CRYPTO_GENERICHASH_KEYBYTES_MAX = 64;
+const SODIUM_CRYPTO_PWHASH_SALTBYTES = 16;
+const SODIUM_CRYPTO_PWHASH_STRPREFIX = '$argon2id$';
+const SODIUM_CRYPTO_PWHASH_ALG_ARGON2I13 = 1;
+const SODIUM_CRYPTO_PWHASH_ALG_ARGON2ID13 = 2;
+const SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE = 33554432;
+const SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE = 4;
+const SODIUM_CRYPTO_PWHASH_MEMLIMIT_MODERATE = 134217728;
+const SODIUM_CRYPTO_PWHASH_OPSLIMIT_MODERATE = 6;
+const SODIUM_CRYPTO_PWHASH_MEMLIMIT_SENSITIVE = 536870912;
+const SODIUM_CRYPTO_PWHASH_OPSLIMIT_SENSITIVE = 8;
+const SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_SALTBYTES = 32;
+const SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_STRPREFIX = '$7$';
+const SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_INTERACTIVE = 534288;
+const SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_INTERACTIVE = 16777216;
+const SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_OPSLIMIT_SENSITIVE = 33554432;
+const SODIUM_CRYPTO_PWHASH_SCRYPTSALSA208SHA256_MEMLIMIT_SENSITIVE = 1073741824;
+const SODIUM_CRYPTO_SCALARMULT_BYTES = 32;
+const SODIUM_CRYPTO_SCALARMULT_SCALARBYTES = 32;
+const SODIUM_CRYPTO_SHORTHASH_BYTES = 8;
+const SODIUM_CRYPTO_SHORTHASH_KEYBYTES = 16;
+const SODIUM_CRYPTO_SECRETBOX_KEYBYTES = 32;
+const SODIUM_CRYPTO_SECRETBOX_MACBYTES = 16;
+const SODIUM_CRYPTO_SECRETBOX_NONCEBYTES = 24;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_ABYTES = 17;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_HEADERBYTES = 24;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_KEYBYTES = 32;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PUSH = 0;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_PULL = 1;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_REKEY = 2;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_FINAL = 3;
+const SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_MESSAGEBYTES_MAX = 0x3fffffff80;
+const SODIUM_CRYPTO_SIGN_BYTES = 64;
+const SODIUM_CRYPTO_SIGN_SEEDBYTES = 32;
+const SODIUM_CRYPTO_SIGN_PUBLICKEYBYTES = 32;
+const SODIUM_CRYPTO_SIGN_SECRETKEYBYTES = 64;
+const SODIUM_CRYPTO_SIGN_KEYPAIRBYTES = 96;
+const SODIUM_CRYPTO_STREAM_KEYBYTES = 32;
+const SODIUM_CRYPTO_STREAM_NONCEBYTES = 24;

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium;
+
+class Compat extends \ParagonIE_Sodium_Compat
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class BLAKE2b extends \ParagonIE_Sodium_Core_BLAKE2b
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class ChaCha20 extends \ParagonIE_Sodium_Core_ChaCha20
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\ChaCha20;
+
+class Ctx extends \ParagonIE_Sodium_Core_ChaCha20_Ctx
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\ChaCha20;
+
+class IetfCtx extends \ParagonIE_Sodium_Core_ChaCha20_IetfCtx
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class Curve25519 extends \ParagonIE_Sodium_Core_Curve25519
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Curve25519;
+
+class Fe extends \ParagonIE_Sodium_Core_Curve25519_Fe
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Curve25519\Ge;
+
+class Cached extends \ParagonIE_Sodium_Core_Curve25519_Ge_Cached
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Curve25519\Ge;
+
+class P1p1 extends \ParagonIE_Sodium_Core_Curve25519_Ge_P1p1
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Curve25519\Ge;
+
+class P2 extends \ParagonIE_Sodium_Core_Curve25519_Ge_P2
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Curve25519\Ge;
+
+class P3 extends \ParagonIE_Sodium_Core_Curve25519_Ge_P3
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Curve25519\Ge;
+
+class Precomp extends \ParagonIE_Sodium_Core_Curve25519_Ge_Precomp
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Curve25519;
+
+class H extends \ParagonIE_Sodium_Core_Curve25519_H
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class Ed25519 extends \ParagonIE_Sodium_Core_Ed25519
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class HChaCha20 extends \ParagonIE_Sodium_Core_HChaCha20
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class HSalsa20 extends \ParagonIE_Sodium_Core_HSalsa20
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class Poly1305 extends \ParagonIE_Sodium_Core_Poly1305
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core\Poly1305;
+
+class State extends \ParagonIE_Sodium_Core_Poly1305_State
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class Salsa20 extends \ParagonIE_Sodium_Core_Salsa20
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class SipHash extends \ParagonIE_Sodium_Core_SipHash
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class Util extends \ParagonIE_Sodium_Core_Util
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class X25519 extends \ParagonIE_Sodium_Core_X25519
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class XChaCha20 extends \ParagonIE_Sodium_Core_XChaCha20
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium\Core;
+
+class Xsalsa20 extends \ParagonIE_Sodium_Core_XSalsa20
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium;
+
+class Crypto extends \ParagonIE_Sodium_Crypto
+{
+
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+namespace ParagonIE\Sodium;
+
+class File extends \ParagonIE_Sodium_File
+{
+
+}

+<?xml version="1.0"?>
+<psalm
+        useDocblockTypes="true"
+        totallyTyped="true"
+>
+    <projectFiles>
+        <directory name="src" />
+    </projectFiles>
+    <issueHandlers>
+        <InvalidFunctionCall errorLevel="suppress" />
+        <!--
+            Previous issue type is suppressed because we have to use a string
+            as a function name for PHP 5.2 compatibility. When testing, be sure
+            to change this to "info".
+         -->
+
+        <UndefinedFunction errorLevel="info" />
+        <!--
+            Inconsistently erroneous.
+        -->
+
+        <DuplicateClass errorLevel="info" />
+        <!--
+            Psalm isn't correctly identifying the guard conditions that return
+            early if a class already exists.
+        -->
+        <RedundantConditionGivenDocblockType errorLevel="suppress" />
+
+        <TooFewArguments errorLevel="info" />
+
+        <DocblockTypeContradiction errorLevel="suppress" />
+        <RedundantCondition errorLevel="info" />
+        <!--
+            Redundancy is good for PHP <7
+        -->
+
+        <TypeDoesNotContainType errorLevel="info" />
+        <!--
+            This mostly fails on `PHP_INT_SIZE === 4`
+        -->
+
+        <InternalMethod errorLevel="suppress" />
+        <!--
+            We mark methods as internal.
+        -->
+        <PossiblyNullArgument errorLevel="suppress" />
+        <!--
+            Not interesting
+        -->
+
+    </issueHandlers>
+</psalm>

+<?xml version="1.0"?>
+<psalm
+    useDocblockTypes="true"
+    totallyTyped="true"
+>
+    <projectFiles>
+        <directory name="src" />
+    </projectFiles>
+    <issueHandlers>
+        <InvalidFunctionCall errorLevel="suppress" />
+        <!--
+            Previous issue type is suppressed because we have to use a string
+            as a function name for PHP 5.2 compatibility. When testing, be sure
+            to change this to "info".
+         -->
+
+        <UndefinedFunction errorLevel="info" />
+        <!--
+            Inconsistently erroneous.
+        -->
+
+        <DuplicateClass errorLevel="info" />
+        <!--
+            Psalm isn't correctly identifying the guard conditions that return
+            early if a class already exists.
+        -->
+        <RedundantConditionGivenDocblockType errorLevel="suppress" />
+
+        <TooFewArguments errorLevel="info" />
+
+        <DocblockTypeContradiction errorLevel="info" />
+        <RedundantCondition errorLevel="info" />
+        <!--
+            Redundancy is good for PHP <7
+        -->
+
+        <TypeDoesNotContainType errorLevel="info" />
+        <!--
+            This mostly fails on `PHP_INT_SIZE === 4`
+        -->
+
+    </issueHandlers>
+</psalm>

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+/**
+ * Class ParagonIE_Sodium_Core_Base64
+ *
+ *  Copyright (c) 2016 - 2018 Paragon Initiative Enterprises.
+ *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
+ *
+ * We have to copy/paste the contents into the variant files because PHP 5.2
+ * doesn't support late static binding, and we have no better workaround
+ * available that won't break PHP 7+. Therefore, we're forced to duplicate code.
+ */
+abstract class ParagonIE_Sodium_Core_Base64_Common
+{
+    /**
+     * Encode into Base64
+     *
+     * Base64 character set "[A-Z][a-z][0-9]+/"
+     *
+     * @param string $src
+     * @return string
+     * @throws TypeError
+     */
+    public static function encode($src)
+    {
+        return self::doEncode($src, true);
+    }
+
+    /**
+     * Encode into Base64, no = padding
+     *
+     * Base64 character set "[A-Z][a-z][0-9]+/"
+     *
+     * @param string $src
+     * @return string
+     * @throws TypeError
+     */
+    public static function encodeUnpadded($src)
+    {
+        return self::doEncode($src, false);
+    }
+
+    /**
+     * @param string $src
+     * @param bool $pad   Include = padding?
+     * @return string
+     * @throws TypeError
+     */
+    protected static function doEncode($src, $pad = true)
+    {
+        $dest = '';
+        $srcLen = ParagonIE_Sodium_Core_Util::strlen($src);
+        // Main loop (no padding):
+        for ($i = 0; $i + 3 <= $srcLen; $i += 3) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, 3));
+            $b0 = $chunk[1];
+            $b1 = $chunk[2];
+            $b2 = $chunk[3];
+
+            $dest .=
+                self::encode6Bits(               $b0 >> 2       ) .
+                self::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
+                self::encode6Bits((($b1 << 2) | ($b2 >> 6)) & 63) .
+                self::encode6Bits(  $b2                     & 63);
+        }
+        // The last chunk, which may have padding:
+        if ($i < $srcLen) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, $srcLen - $i));
+            $b0 = $chunk[1];
+            if ($i + 1 < $srcLen) {
+                $b1 = $chunk[2];
+                $dest .=
+                    self::encode6Bits($b0 >> 2) .
+                    self::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
+                    self::encode6Bits(($b1 << 2) & 63);
+                if ($pad) {
+                    $dest .= '=';
+                }
+            } else {
+                $dest .=
+                    self::encode6Bits( $b0 >> 2) .
+                    self::encode6Bits(($b0 << 4) & 63);
+                if ($pad) {
+                    $dest .= '==';
+                }
+            }
+        }
+        return $dest;
+    }
+
+    /**
+     * decode from base64 into binary
+     *
+     * Base64 character set "./[A-Z][a-z][0-9]"
+     *
+     * @param string $src
+     * @param bool $strictPadding
+     * @return string
+     * @throws RangeException
+     * @throws TypeError
+     * @psalm-suppress RedundantCondition
+     */
+    public static function decode($src, $strictPadding = false)
+    {
+        // Remove padding
+        $srcLen = ParagonIE_Sodium_Core_Util::strlen($src);
+        if ($srcLen === 0) {
+            return '';
+        }
+
+        if ($strictPadding) {
+            if (($srcLen & 3) === 0) {
+                if ($src[$srcLen - 1] === '=') {
+                    $srcLen--;
+                    if ($src[$srcLen - 1] === '=') {
+                        $srcLen--;
+                    }
+                }
+            }
+            if (($srcLen & 3) === 1) {
+                throw new RangeException(
+                    'Incorrect padding'
+                );
+            }
+            if ($src[$srcLen - 1] === '=') {
+                throw new RangeException(
+                    'Incorrect padding'
+                );
+            }
+        } else {
+            $src = rtrim($src, '=');
+            $srcLen = ParagonIE_Sodium_Core_Util::strlen($src);
+        }
+
+        $err = 0;
+        $dest = '';
+        // Main loop (no padding):
+        for ($i = 0; $i + 4 <= $srcLen; $i += 4) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, 4));
+            $c0 = self::decode6Bits($chunk[1]);
+            $c1 = self::decode6Bits($chunk[2]);
+            $c2 = self::decode6Bits($chunk[3]);
+            $c3 = self::decode6Bits($chunk[4]);
+
+            $dest .= pack(
+                'CCC',
+                ((($c0 << 2) | ($c1 >> 4)) & 0xff),
+                ((($c1 << 4) | ($c2 >> 2)) & 0xff),
+                ((($c2 << 6) |  $c3      ) & 0xff)
+            );
+            $err |= ($c0 | $c1 | $c2 | $c3) >> 8;
+        }
+        // The last chunk, which may have padding:
+        if ($i < $srcLen) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, $srcLen - $i));
+            $c0 = self::decode6Bits($chunk[1]);
+
+            if ($i + 2 < $srcLen) {
+                $c1 = self::decode6Bits($chunk[2]);
+                $c2 = self::decode6Bits($chunk[3]);
+                $dest .= pack(
+                    'CC',
+                    ((($c0 << 2) | ($c1 >> 4)) & 0xff),
+                    ((($c1 << 4) | ($c2 >> 2)) & 0xff)
+                );
+                $err |= ($c0 | $c1 | $c2) >> 8;
+            } elseif ($i + 1 < $srcLen) {
+                $c1 = self::decode6Bits($chunk[2]);
+                $dest .= pack(
+                    'C',
+                    ((($c0 << 2) | ($c1 >> 4)) & 0xff)
+                );
+                $err |= ($c0 | $c1) >> 8;
+            } elseif ($i < $srcLen && $strictPadding) {
+                $err |= 1;
+            }
+        }
+        /** @var bool $check */
+        $check = ($err === 0);
+        if (!$check) {
+            throw new RangeException(
+                'Base64::decode() only expects characters in the correct base64 alphabet'
+            );
+        }
+        return $dest;
+    }
+
+    /**
+     * Uses bitwise operators instead of table-lookups to turn 6-bit integers
+     * into 8-bit integers.
+     *
+     * Base64 character set:
+     * [A-Z]      [a-z]      [0-9]      +     /
+     * 0x41-0x5a, 0x61-0x7a, 0x30-0x39, 0x2b, 0x2f
+     *
+     * @param int $src
+     * @return int
+     */
+    abstract protected static function decode6Bits($src);
+
+    /**
+     * Uses bitwise operators instead of table-lookups to turn 8-bit integers
+     * into 6-bit integers.
+     *
+     * @param int $src
+     * @return string
+     */
+    abstract protected static function encode6Bits($src);
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+/**
+ * Class ParagonIE_Sodium_Core_Base64
+ *
+ *  Copyright (c) 2016 - 2018 Paragon Initiative Enterprises.
+ *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
+ */
+class ParagonIE_Sodium_Core_Base64_Original
+{
+    // COPY ParagonIE_Sodium_Core_Base64_Common STARTING HERE
+    /**
+     * Encode into Base64
+     *
+     * Base64 character set "[A-Z][a-z][0-9]+/"
+     *
+     * @param string $src
+     * @return string
+     * @throws TypeError
+     */
+    public static function encode($src)
+    {
+        return self::doEncode($src, true);
+    }
+
+    /**
+     * Encode into Base64, no = padding
+     *
+     * Base64 character set "[A-Z][a-z][0-9]+/"
+     *
+     * @param string $src
+     * @return string
+     * @throws TypeError
+     */
+    public static function encodeUnpadded($src)
+    {
+        return self::doEncode($src, false);
+    }
+
+    /**
+     * @param string $src
+     * @param bool $pad   Include = padding?
+     * @return string
+     * @throws TypeError
+     */
+    protected static function doEncode($src, $pad = true)
+    {
+        $dest = '';
+        $srcLen = ParagonIE_Sodium_Core_Util::strlen($src);
+        // Main loop (no padding):
+        for ($i = 0; $i + 3 <= $srcLen; $i += 3) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, 3));
+            $b0 = $chunk[1];
+            $b1 = $chunk[2];
+            $b2 = $chunk[3];
+
+            $dest .=
+                self::encode6Bits(               $b0 >> 2       ) .
+                self::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
+                self::encode6Bits((($b1 << 2) | ($b2 >> 6)) & 63) .
+                self::encode6Bits(  $b2                     & 63);
+        }
+        // The last chunk, which may have padding:
+        if ($i < $srcLen) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, $srcLen - $i));
+            $b0 = $chunk[1];
+            if ($i + 1 < $srcLen) {
+                $b1 = $chunk[2];
+                $dest .=
+                    self::encode6Bits($b0 >> 2) .
+                    self::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
+                    self::encode6Bits(($b1 << 2) & 63);
+                if ($pad) {
+                    $dest .= '=';
+                }
+            } else {
+                $dest .=
+                    self::encode6Bits( $b0 >> 2) .
+                    self::encode6Bits(($b0 << 4) & 63);
+                if ($pad) {
+                    $dest .= '==';
+                }
+            }
+        }
+        return $dest;
+    }
+
+    /**
+     * decode from base64 into binary
+     *
+     * Base64 character set "./[A-Z][a-z][0-9]"
+     *
+     * @param string $src
+     * @param bool $strictPadding
+     * @return string
+     * @throws RangeException
+     * @throws TypeError
+     * @psalm-suppress RedundantCondition
+     */
+    public static function decode($src, $strictPadding = false)
+    {
+        // Remove padding
+        $srcLen = ParagonIE_Sodium_Core_Util::strlen($src);
+        if ($srcLen === 0) {
+            return '';
+        }
+
+        if ($strictPadding) {
+            if (($srcLen & 3) === 0) {
+                if ($src[$srcLen - 1] === '=') {
+                    $srcLen--;
+                    if ($src[$srcLen - 1] === '=') {
+                        $srcLen--;
+                    }
+                }
+            }
+            if (($srcLen & 3) === 1) {
+                throw new RangeException(
+                    'Incorrect padding'
+                );
+            }
+            if ($src[$srcLen - 1] === '=') {
+                throw new RangeException(
+                    'Incorrect padding'
+                );
+            }
+        } else {
+            $src = rtrim($src, '=');
+            $srcLen =  ParagonIE_Sodium_Core_Util::strlen($src);
+        }
+
+        $err = 0;
+        $dest = '';
+        // Main loop (no padding):
+        for ($i = 0; $i + 4 <= $srcLen; $i += 4) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, 4));
+            $c0 = self::decode6Bits($chunk[1]);
+            $c1 = self::decode6Bits($chunk[2]);
+            $c2 = self::decode6Bits($chunk[3]);
+            $c3 = self::decode6Bits($chunk[4]);
+
+            $dest .= pack(
+                'CCC',
+                ((($c0 << 2) | ($c1 >> 4)) & 0xff),
+                ((($c1 << 4) | ($c2 >> 2)) & 0xff),
+                ((($c2 << 6) | $c3) & 0xff)
+            );
+            $err |= ($c0 | $c1 | $c2 | $c3) >> 8;
+        }
+        // The last chunk, which may have padding:
+        if ($i < $srcLen) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, $srcLen - $i));
+            $c0 = self::decode6Bits($chunk[1]);
+
+            if ($i + 2 < $srcLen) {
+                $c1 = self::decode6Bits($chunk[2]);
+                $c2 = self::decode6Bits($chunk[3]);
+                $dest .= pack(
+                    'CC',
+                    ((($c0 << 2) | ($c1 >> 4)) & 0xff),
+                    ((($c1 << 4) | ($c2 >> 2)) & 0xff)
+                );
+                $err |= ($c0 | $c1 | $c2) >> 8;
+            } elseif ($i + 1 < $srcLen) {
+                $c1 = self::decode6Bits($chunk[2]);
+                $dest .= pack(
+                    'C',
+                    ((($c0 << 2) | ($c1 >> 4)) & 0xff)
+                );
+                $err |= ($c0 | $c1) >> 8;
+            } elseif ($i < $srcLen && $strictPadding) {
+                $err |= 1;
+            }
+        }
+        /** @var bool $check */
+        $check = ($err === 0);
+        if (!$check) {
+            throw new RangeException(
+                'Base64::decode() only expects characters in the correct base64 alphabet'
+            );
+        }
+        return $dest;
+    }
+    // COPY ParagonIE_Sodium_Core_Base64_Common ENDING HERE
+
+    /**
+     * Uses bitwise operators instead of table-lookups to turn 6-bit integers
+     * into 8-bit integers.
+     *
+     * Base64 character set:
+     * [A-Z]      [a-z]      [0-9]      +     /
+     * 0x41-0x5a, 0x61-0x7a, 0x30-0x39, 0x2b, 0x2f
+     *
+     * @param int $src
+     * @return int
+     */
+    protected static function decode6Bits($src)
+    {
+        $ret = -1;
+
+        // if ($src > 0x40 && $src < 0x5b) $ret += $src - 0x41 + 1; // -64
+        $ret += (((0x40 - $src) & ($src - 0x5b)) >> 8) & ($src - 64);
+
+        // if ($src > 0x60 && $src < 0x7b) $ret += $src - 0x61 + 26 + 1; // -70
+        $ret += (((0x60 - $src) & ($src - 0x7b)) >> 8) & ($src - 70);
+
+        // if ($src > 0x2f && $src < 0x3a) $ret += $src - 0x30 + 52 + 1; // 5
+        $ret += (((0x2f - $src) & ($src - 0x3a)) >> 8) & ($src + 5);
+
+        // if ($src == 0x2b) $ret += 62 + 1;
+        $ret += (((0x2a - $src) & ($src - 0x2c)) >> 8) & 63;
+
+        // if ($src == 0x2f) ret += 63 + 1;
+        $ret += (((0x2e - $src) & ($src - 0x30)) >> 8) & 64;
+
+        return $ret;
+    }
+
+    /**
+     * Uses bitwise operators instead of table-lookups to turn 8-bit integers
+     * into 6-bit integers.
+     *
+     * @param int $src
+     * @return string
+     */
+    protected static function encode6Bits($src)
+    {
+        $diff = 0x41;
+
+        // if ($src > 25) $diff += 0x61 - 0x41 - 26; // 6
+        $diff += ((25 - $src) >> 8) & 6;
+
+        // if ($src > 51) $diff += 0x30 - 0x61 - 26; // -75
+        $diff -= ((51 - $src) >> 8) & 75;
+
+        // if ($src > 61) $diff += 0x2b - 0x30 - 10; // -15
+        $diff -= ((61 - $src) >> 8) & 15;
+
+        // if ($src > 62) $diff += 0x2f - 0x2b - 1; // 3
+        $diff += ((62 - $src) >> 8) & 3;
+
+        return pack('C', $src + $diff);
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+/**
+ * Class ParagonIE_Sodium_Core_Base64UrlSafe
+ *
+ *  Copyright (c) 2016 - 2018 Paragon Initiative Enterprises.
+ *  Copyright (c) 2014 Steve "Sc00bz" Thomas (steve at tobtu dot com)
+ */
+class ParagonIE_Sodium_Core_Base64_UrlSafe
+{
+    // COPY ParagonIE_Sodium_Core_Base64_Common STARTING HERE
+    /**
+     * Encode into Base64
+     *
+     * Base64 character set "[A-Z][a-z][0-9]+/"
+     *
+     * @param string $src
+     * @return string
+     * @throws TypeError
+     */
+    public static function encode($src)
+    {
+        return self::doEncode($src, true);
+    }
+
+    /**
+     * Encode into Base64, no = padding
+     *
+     * Base64 character set "[A-Z][a-z][0-9]+/"
+     *
+     * @param string $src
+     * @return string
+     * @throws TypeError
+     */
+    public static function encodeUnpadded($src)
+    {
+        return self::doEncode($src, false);
+    }
+
+    /**
+     * @param string $src
+     * @param bool $pad   Include = padding?
+     * @return string
+     * @throws TypeError
+     */
+    protected static function doEncode($src, $pad = true)
+    {
+        $dest = '';
+        $srcLen = ParagonIE_Sodium_Core_Util::strlen($src);
+        // Main loop (no padding):
+        for ($i = 0; $i + 3 <= $srcLen; $i += 3) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, 3));
+            $b0 = $chunk[1];
+            $b1 = $chunk[2];
+            $b2 = $chunk[3];
+
+            $dest .=
+                self::encode6Bits(               $b0 >> 2       ) .
+                self::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
+                self::encode6Bits((($b1 << 2) | ($b2 >> 6)) & 63) .
+                self::encode6Bits(  $b2                     & 63);
+        }
+        // The last chunk, which may have padding:
+        if ($i < $srcLen) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, $srcLen - $i));
+            $b0 = $chunk[1];
+            if ($i + 1 < $srcLen) {
+                $b1 = $chunk[2];
+                $dest .=
+                    self::encode6Bits($b0 >> 2) .
+                    self::encode6Bits((($b0 << 4) | ($b1 >> 4)) & 63) .
+                    self::encode6Bits(($b1 << 2) & 63);
+                if ($pad) {
+                    $dest .= '=';
+                }
+            } else {
+                $dest .=
+                    self::encode6Bits( $b0 >> 2) .
+                    self::encode6Bits(($b0 << 4) & 63);
+                if ($pad) {
+                    $dest .= '==';
+                }
+            }
+        }
+        return $dest;
+    }
+
+    /**
+     * decode from base64 into binary
+     *
+     * Base64 character set "./[A-Z][a-z][0-9]"
+     *
+     * @param string $src
+     * @param bool $strictPadding
+     * @return string
+     * @throws RangeException
+     * @throws TypeError
+     * @psalm-suppress RedundantCondition
+     */
+    public static function decode($src, $strictPadding = false)
+    {
+        // Remove padding
+        $srcLen = ParagonIE_Sodium_Core_Util::strlen($src);
+        if ($srcLen === 0) {
+            return '';
+        }
+
+        if ($strictPadding) {
+            if (($srcLen & 3) === 0) {
+                if ($src[$srcLen - 1] === '=') {
+                    $srcLen--;
+                    if ($src[$srcLen - 1] === '=') {
+                        $srcLen--;
+                    }
+                }
+            }
+            if (($srcLen & 3) === 1) {
+                throw new RangeException(
+                    'Incorrect padding'
+                );
+            }
+            if ($src[$srcLen - 1] === '=') {
+                throw new RangeException(
+                    'Incorrect padding'
+                );
+            }
+        } else {
+            $src = rtrim($src, '=');
+            $srcLen =  ParagonIE_Sodium_Core_Util::strlen($src);
+        }
+
+        $err = 0;
+        $dest = '';
+        // Main loop (no padding):
+        for ($i = 0; $i + 4 <= $srcLen; $i += 4) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, 4));
+            $c0 = self::decode6Bits($chunk[1]);
+            $c1 = self::decode6Bits($chunk[2]);
+            $c2 = self::decode6Bits($chunk[3]);
+            $c3 = self::decode6Bits($chunk[4]);
+
+            $dest .= pack(
+                'CCC',
+                ((($c0 << 2) | ($c1 >> 4)) & 0xff),
+                ((($c1 << 4) | ($c2 >> 2)) & 0xff),
+                ((($c2 << 6) | $c3) & 0xff)
+            );
+            $err |= ($c0 | $c1 | $c2 | $c3) >> 8;
+        }
+        // The last chunk, which may have padding:
+        if ($i < $srcLen) {
+            /** @var array<int, int> $chunk */
+            $chunk = unpack('C*', ParagonIE_Sodium_Core_Util::substr($src, $i, $srcLen - $i));
+            $c0 = self::decode6Bits($chunk[1]);
+
+            if ($i + 2 < $srcLen) {
+                $c1 = self::decode6Bits($chunk[2]);
+                $c2 = self::decode6Bits($chunk[3]);
+                $dest .= pack(
+                    'CC',
+                    ((($c0 << 2) | ($c1 >> 4)) & 0xff),
+                    ((($c1 << 4) | ($c2 >> 2)) & 0xff)
+                );
+                $err |= ($c0 | $c1 | $c2) >> 8;
+            } elseif ($i + 1 < $srcLen) {
+                $c1 = self::decode6Bits($chunk[2]);
+                $dest .= pack(
+                    'C',
+                    ((($c0 << 2) | ($c1 >> 4)) & 0xff)
+                );
+                $err |= ($c0 | $c1) >> 8;
+            } elseif ($i < $srcLen && $strictPadding) {
+                $err |= 1;
+            }
+        }
+        /** @var bool $check */
+        $check = ($err === 0);
+        if (!$check) {
+            throw new RangeException(
+                'Base64::decode() only expects characters in the correct base64 alphabet'
+            );
+        }
+        return $dest;
+    }
+    // COPY ParagonIE_Sodium_Core_Base64_Common ENDING HERE
+    /**
+     * Uses bitwise operators instead of table-lookups to turn 6-bit integers
+     * into 8-bit integers.
+     *
+     * Base64 character set:
+     * [A-Z]      [a-z]      [0-9]      +     /
+     * 0x41-0x5a, 0x61-0x7a, 0x30-0x39, 0x2b, 0x2f
+     *
+     * @param int $src
+     * @return int
+     */
+    protected static function decode6Bits($src)
+    {
+        $ret = -1;
+
+        // if ($src > 0x40 && $src < 0x5b) $ret += $src - 0x41 + 1; // -64
+        $ret += (((0x40 - $src) & ($src - 0x5b)) >> 8) & ($src - 64);
+
+        // if ($src > 0x60 && $src < 0x7b) $ret += $src - 0x61 + 26 + 1; // -70
+        $ret += (((0x60 - $src) & ($src - 0x7b)) >> 8) & ($src - 70);
+
+        // if ($src > 0x2f && $src < 0x3a) $ret += $src - 0x30 + 52 + 1; // 5
+        $ret += (((0x2f - $src) & ($src - 0x3a)) >> 8) & ($src + 5);
+
+        // if ($src == 0x2c) $ret += 62 + 1;
+        $ret += (((0x2c - $src) & ($src - 0x2e)) >> 8) & 63;
+
+        // if ($src == 0x5f) ret += 63 + 1;
+        $ret += (((0x5e - $src) & ($src - 0x60)) >> 8) & 64;
+
+        return $ret;
+    }
+
+    /**
+     * Uses bitwise operators instead of table-lookups to turn 8-bit integers
+     * into 6-bit integers.
+     *
+     * @param int $src
+     * @return string
+     */
+    protected static function encode6Bits($src)
+    {
+        $diff = 0x41;
+
+        // if ($src > 25) $diff += 0x61 - 0x41 - 26; // 6
+        $diff += ((25 - $src) >> 8) & 6;
+
+        // if ($src > 51) $diff += 0x30 - 0x61 - 26; // -75
+        $diff -= ((51 - $src) >> 8) & 75;
+
+        // if ($src > 61) $diff += 0x2d - 0x30 - 10; // -13
+        $diff -= ((61 - $src) >> 8) & 13;
+
+        // if ($src > 62) $diff += 0x5f - 0x2b - 1; // 3
+        $diff += ((62 - $src) >> 8) & 49;
+
+        return pack('C', $src + $diff);
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_ChaCha20_Ctx', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_ChaCha20_Ctx
+ */
+class ParagonIE_Sodium_Core_ChaCha20_Ctx extends ParagonIE_Sodium_Core_Util implements ArrayAccess
+{
+    /**
+     * @var SplFixedArray internally, <int, int>
+     */
+    protected $container;
+
+    /**
+     * ParagonIE_Sodium_Core_ChaCha20_Ctx constructor.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param string $key     ChaCha20 key.
+     * @param string $iv      Initialization Vector (a.k.a. nonce).
+     * @param string $counter The initial counter value.
+     *                        Defaults to 8 0x00 bytes.
+     * @throws InvalidArgumentException
+     * @throws TypeError
+     */
+    public function __construct($key = '', $iv = '', $counter = '')
+    {
+        if (self::strlen($key) !== 32) {
+            throw new InvalidArgumentException('ChaCha20 expects a 256-bit key.');
+        }
+        if (self::strlen($iv) !== 8) {
+            throw new InvalidArgumentException('ChaCha20 expects a 64-bit nonce.');
+        }
+        $this->container = new SplFixedArray(16);
+
+        /* "expand 32-byte k" as per ChaCha20 spec */
+        $this->container[0]  = 0x61707865;
+        $this->container[1]  = 0x3320646e;
+        $this->container[2]  = 0x79622d32;
+        $this->container[3]  = 0x6b206574;
+        $this->container[4]  = self::load_4(self::substr($key, 0, 4));
+        $this->container[5]  = self::load_4(self::substr($key, 4, 4));
+        $this->container[6]  = self::load_4(self::substr($key, 8, 4));
+        $this->container[7]  = self::load_4(self::substr($key, 12, 4));
+        $this->container[8]  = self::load_4(self::substr($key, 16, 4));
+        $this->container[9]  = self::load_4(self::substr($key, 20, 4));
+        $this->container[10] = self::load_4(self::substr($key, 24, 4));
+        $this->container[11] = self::load_4(self::substr($key, 28, 4));
+
+        if (empty($counter)) {
+            $this->container[12] = 0;
+            $this->container[13] = 0;
+        } else {
+            $this->container[12] = self::load_4(self::substr($counter, 0, 4));
+            $this->container[13] = self::load_4(self::substr($counter, 4, 4));
+        }
+        $this->container[14] = self::load_4(self::substr($iv, 0, 4));
+        $this->container[15] = self::load_4(self::substr($iv, 4, 4));
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $offset
+     * @param int $value
+     * @return void
+     * @psalm-suppress MixedArrayOffset
+     */
+    public function offsetSet($offset, $value)
+    {
+        if (!is_int($offset)) {
+            throw new InvalidArgumentException('Expected an integer');
+        }
+        if (!is_int($value)) {
+            throw new InvalidArgumentException('Expected an integer');
+        }
+        $this->container[$offset] = $value;
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $offset
+     * @return bool
+     */
+    public function offsetExists($offset)
+    {
+        return isset($this->container[$offset]);
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $offset
+     * @return void
+     * @psalm-suppress MixedArrayOffset
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->container[$offset]);
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $offset
+     * @return mixed|null
+     * @psalm-suppress MixedArrayOffset
+     */
+    public function offsetGet($offset)
+    {
+        return isset($this->container[$offset])
+            ? $this->container[$offset]
+            : null;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_ChaCha20_IetfCtx', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_ChaCha20_IetfCtx
+ */
+class ParagonIE_Sodium_Core_ChaCha20_IetfCtx extends ParagonIE_Sodium_Core_ChaCha20_Ctx
+{
+    /**
+     * ParagonIE_Sodium_Core_ChaCha20_IetfCtx constructor.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param string $key     ChaCha20 key.
+     * @param string $iv      Initialization Vector (a.k.a. nonce).
+     * @param string $counter The initial counter value.
+     *                        Defaults to 4 0x00 bytes.
+     * @throws InvalidArgumentException
+     * @throws TypeError
+     */
+    public function __construct($key = '', $iv = '', $counter = '')
+    {
+        if (self::strlen($iv) !== 12) {
+            throw new InvalidArgumentException('ChaCha20 expects a 96-bit nonce in IETF mode.');
+        }
+        parent::__construct($key, self::substr($iv, 0, 8), $counter);
+
+        if (!empty($counter)) {
+            $this->container[12] = self::load_4(self::substr($counter, 0, 4));
+        }
+        $this->container[13] = self::load_4(self::substr($iv, 0, 4));
+        $this->container[14] = self::load_4(self::substr($iv, 4, 4));
+        $this->container[15] = self::load_4(self::substr($iv, 8, 4));
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_Curve25519_Fe', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_Curve25519_Fe
+ *
+ * This represents a Field Element
+ */
+class ParagonIE_Sodium_Core_Curve25519_Fe implements ArrayAccess
+{
+    /**
+     * @var array<int, int>
+     */
+    protected $container = array();
+
+    /**
+     * @var int
+     */
+    protected $size = 10;
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param array<int, int> $array
+     * @param bool $save_indexes
+     * @return self
+     */
+    public static function fromArray($array, $save_indexes = null)
+    {
+        $count = count($array);
+        if ($save_indexes) {
+            $keys = array_keys($array);
+        } else {
+            $keys = range(0, $count - 1);
+        }
+        $array = array_values($array);
+        /** @var array<int, int> $keys */
+
+        $obj = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        if ($save_indexes) {
+            for ($i = 0; $i < $count; ++$i) {
+                $obj->offsetSet($keys[$i], $array[$i]);
+            }
+        } else {
+            for ($i = 0; $i < $count; ++$i) {
+                $obj->offsetSet($i, $array[$i]);
+            }
+        }
+        return $obj;
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int|null $offset
+     * @param int $value
+     * @return void
+     * @psalm-suppress MixedArrayOffset
+     */
+    public function offsetSet($offset, $value)
+    {
+        if (!is_int($value)) {
+            throw new InvalidArgumentException('Expected an integer');
+        }
+        if (is_null($offset)) {
+            $this->container[] = $value;
+        } else {
+            $this->container[$offset] = $value;
+        }
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $offset
+     * @return bool
+     * @psalm-suppress MixedArrayOffset
+     */
+    public function offsetExists($offset)
+    {
+        return isset($this->container[$offset]);
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $offset
+     * @return void
+     * @psalm-suppress MixedArrayOffset
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->container[$offset]);
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $offset
+     * @return int
+     * @psalm-suppress MixedArrayOffset
+     */
+    public function offsetGet($offset)
+    {
+        if (!isset($this->container[$offset])) {
+            $this->container[$offset] = 0;
+        }
+        return (int) ($this->container[$offset]);
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @return array
+     */
+    public function __debugInfo()
+    {
+        return array(implode(', ', $this->container));
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+
+if (class_exists('ParagonIE_Sodium_Core_Curve25519_Ge_Cached', false)) {
+    return;
+}
+/**
+ * Class ParagonIE_Sodium_Core_Curve25519_Ge_Cached
+ */
+class ParagonIE_Sodium_Core_Curve25519_Ge_Cached
+{
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $YplusX;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $YminusX;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $Z;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $T2d;
+
+    /**
+     * ParagonIE_Sodium_Core_Curve25519_Ge_Cached constructor.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $YplusX
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $YminusX
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $Z
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $T2d
+     */
+    public function __construct(
+        ParagonIE_Sodium_Core_Curve25519_Fe $YplusX = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $YminusX = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $Z = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $T2d = null
+    ) {
+        if ($YplusX === null) {
+            $YplusX = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->YplusX = $YplusX;
+        if ($YminusX === null) {
+            $YminusX = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->YminusX = $YminusX;
+        if ($Z === null) {
+            $Z = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->Z = $Z;
+        if ($T2d === null) {
+            $T2d = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->T2d = $T2d;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_Curve25519_Ge_P1p1', false)) {
+    return;
+}
+/**
+ * Class ParagonIE_Sodium_Core_Curve25519_Ge_P1p1
+ */
+class ParagonIE_Sodium_Core_Curve25519_Ge_P1p1
+{
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $X;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $Y;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $Z;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $T;
+
+    /**
+     * ParagonIE_Sodium_Core_Curve25519_Ge_P1p1 constructor.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $x
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $y
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $z
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $t
+     */
+    public function __construct(
+        ParagonIE_Sodium_Core_Curve25519_Fe $x = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $y = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $z = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $t = null
+    ) {
+        if ($x === null) {
+            $x = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->X = $x;
+        if ($y === null) {
+            $y = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->Y = $y;
+        if ($z === null) {
+            $z = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->Z = $z;
+        if ($t === null) {
+            $t = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->T = $t;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_Curve25519_Ge_P2', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_Curve25519_Ge_P2
+ */
+class ParagonIE_Sodium_Core_Curve25519_Ge_P2
+{
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $X;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $Y;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $Z;
+
+    /**
+     * ParagonIE_Sodium_Core_Curve25519_Ge_P2 constructor.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $x
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $y
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $z
+     */
+    public function __construct(
+        ParagonIE_Sodium_Core_Curve25519_Fe $x = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $y = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $z = null
+    ) {
+        if ($x === null) {
+            $x = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->X = $x;
+        if ($y === null) {
+            $y = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->Y = $y;
+        if ($z === null) {
+            $z = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->Z = $z;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_Curve25519_Ge_P3', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_Curve25519_Ge_P3
+ */
+class ParagonIE_Sodium_Core_Curve25519_Ge_P3
+{
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $X;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $Y;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $Z;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $T;
+
+    /**
+     * ParagonIE_Sodium_Core_Curve25519_Ge_P3 constructor.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $x
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $y
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $z
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe|null $t
+     */
+    public function __construct(
+        ParagonIE_Sodium_Core_Curve25519_Fe $x = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $y = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $z = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $t = null
+    ) {
+        if ($x === null) {
+            $x = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->X = $x;
+        if ($y === null) {
+            $y = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->Y = $y;
+        if ($z === null) {
+            $z = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->Z = $z;
+        if ($t === null) {
+            $t = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->T = $t;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_Curve25519_Ge_Precomp', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_Curve25519_Ge_Precomp
+ */
+class ParagonIE_Sodium_Core_Curve25519_Ge_Precomp
+{
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $yplusx;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $yminusx;
+
+    /**
+     * @var ParagonIE_Sodium_Core_Curve25519_Fe
+     */
+    public $xy2d;
+
+    /**
+     * ParagonIE_Sodium_Core_Curve25519_Ge_Precomp constructor.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe $yplusx
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe $yminusx
+     * @param ParagonIE_Sodium_Core_Curve25519_Fe $xy2d
+     */
+    public function __construct(
+        ParagonIE_Sodium_Core_Curve25519_Fe $yplusx = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $yminusx = null,
+        ParagonIE_Sodium_Core_Curve25519_Fe $xy2d = null
+    ) {
+        if ($yplusx === null) {
+            $yplusx = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->yplusx = $yplusx;
+        if ($yminusx === null) {
+            $yminusx = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->yminusx = $yminusx;
+        if ($xy2d === null) {
+            $xy2d = new ParagonIE_Sodium_Core_Curve25519_Fe();
+        }
+        $this->xy2d = $xy2d;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_HChaCha20', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_HChaCha20
+ */
+class ParagonIE_Sodium_Core_HChaCha20 extends ParagonIE_Sodium_Core_ChaCha20
+{
+    /**
+     * @param string $in
+     * @param string $key
+     * @param string|null $c
+     * @return string
+     * @throws TypeError
+     */
+    public static function hChaCha20($in = '', $key = '', $c = null)
+    {
+        $ctx = array();
+
+        if ($c === null) {
+            $ctx[0] = 0x61707865;
+            $ctx[1] = 0x3320646e;
+            $ctx[2] = 0x79622d32;
+            $ctx[3] = 0x6b206574;
+        } else {
+            $ctx[0] = self::load_4(self::substr($c,  0, 4));
+            $ctx[1] = self::load_4(self::substr($c,  4, 4));
+            $ctx[2] = self::load_4(self::substr($c,  8, 4));
+            $ctx[3] = self::load_4(self::substr($c, 12, 4));
+        }
+        $ctx[4]  = self::load_4(self::substr($key,  0, 4));
+        $ctx[5]  = self::load_4(self::substr($key,  4, 4));
+        $ctx[6]  = self::load_4(self::substr($key,  8, 4));
+        $ctx[7]  = self::load_4(self::substr($key, 12, 4));
+        $ctx[8]  = self::load_4(self::substr($key, 16, 4));
+        $ctx[9]  = self::load_4(self::substr($key, 20, 4));
+        $ctx[10] = self::load_4(self::substr($key, 24, 4));
+        $ctx[11] = self::load_4(self::substr($key, 28, 4));
+        $ctx[12] = self::load_4(self::substr($in,   0, 4));
+        $ctx[13] = self::load_4(self::substr($in,   4, 4));
+        $ctx[14] = self::load_4(self::substr($in,   8, 4));
+        $ctx[15] = self::load_4(self::substr($in,  12, 4));
+        return self::hChaCha20Bytes($ctx);
+    }
+
+    /**
+     * @param array $ctx
+     * @return string
+     * @throws TypeError
+     */
+    protected static function hChaCha20Bytes(array $ctx)
+    {
+        $x0  = (int) $ctx[0];
+        $x1  = (int) $ctx[1];
+        $x2  = (int) $ctx[2];
+        $x3  = (int) $ctx[3];
+        $x4  = (int) $ctx[4];
+        $x5  = (int) $ctx[5];
+        $x6  = (int) $ctx[6];
+        $x7  = (int) $ctx[7];
+        $x8  = (int) $ctx[8];
+        $x9  = (int) $ctx[9];
+        $x10 = (int) $ctx[10];
+        $x11 = (int) $ctx[11];
+        $x12 = (int) $ctx[12];
+        $x13 = (int) $ctx[13];
+        $x14 = (int) $ctx[14];
+        $x15 = (int) $ctx[15];
+
+        for ($i = 0; $i < 10; ++$i) {
+            # QUARTERROUND( x0,  x4,  x8,  x12)
+            list($x0, $x4, $x8, $x12) = self::quarterRound($x0, $x4, $x8, $x12);
+
+            # QUARTERROUND( x1,  x5,  x9,  x13)
+            list($x1, $x5, $x9, $x13) = self::quarterRound($x1, $x5, $x9, $x13);
+
+            # QUARTERROUND( x2,  x6,  x10,  x14)
+            list($x2, $x6, $x10, $x14) = self::quarterRound($x2, $x6, $x10, $x14);
+
+            # QUARTERROUND( x3,  x7,  x11,  x15)
+            list($x3, $x7, $x11, $x15) = self::quarterRound($x3, $x7, $x11, $x15);
+
+            # QUARTERROUND( x0,  x5,  x10,  x15)
+            list($x0, $x5, $x10, $x15) = self::quarterRound($x0, $x5, $x10, $x15);
+
+            # QUARTERROUND( x1,  x6,  x11,  x12)
+            list($x1, $x6, $x11, $x12) = self::quarterRound($x1, $x6, $x11, $x12);
+
+            # QUARTERROUND( x2,  x7,  x8,  x13)
+            list($x2, $x7, $x8, $x13) = self::quarterRound($x2, $x7, $x8, $x13);
+
+            # QUARTERROUND( x3,  x4,  x9,  x14)
+            list($x3, $x4, $x9, $x14) = self::quarterRound($x3, $x4, $x9, $x14);
+        }
+
+        return self::store32_le((int) ($x0  & 0xffffffff)) .
+            self::store32_le((int) ($x1  & 0xffffffff)) .
+            self::store32_le((int) ($x2  & 0xffffffff)) .
+            self::store32_le((int) ($x3  & 0xffffffff)) .
+            self::store32_le((int) ($x12 & 0xffffffff)) .
+            self::store32_le((int) ($x13 & 0xffffffff)) .
+            self::store32_le((int) ($x14 & 0xffffffff)) .
+            self::store32_le((int) ($x15 & 0xffffffff));
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_HSalsa20', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_HSalsa20
+ */
+abstract class ParagonIE_Sodium_Core_HSalsa20 extends ParagonIE_Sodium_Core_Salsa20
+{
+    /**
+     * Calculate an hsalsa20 hash of a single block
+     *
+     * HSalsa20 doesn't have a counter and will never be used for more than
+     * one block (used to derive a subkey for xsalsa20).
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param string $in
+     * @param string $k
+     * @param string|null $c
+     * @return string
+     * @throws TypeError
+     */
+    public static function hsalsa20($in, $k, $c = null)
+    {
+        if ($c === null) {
+            $x0  = 0x61707865;
+            $x5  = 0x3320646e;
+            $x10 = 0x79622d32;
+            $x15 = 0x6b206574;
+        } else {
+            $x0  = self::load_4(self::substr($c, 0, 4));
+            $x5  = self::load_4(self::substr($c, 4, 4));
+            $x10 = self::load_4(self::substr($c, 8, 4));
+            $x15 = self::load_4(self::substr($c, 12, 4));
+        }
+        $x1  = self::load_4(self::substr($k, 0, 4));
+        $x2  = self::load_4(self::substr($k, 4, 4));
+        $x3  = self::load_4(self::substr($k, 8, 4));
+        $x4  = self::load_4(self::substr($k, 12, 4));
+        $x11 = self::load_4(self::substr($k, 16, 4));
+        $x12 = self::load_4(self::substr($k, 20, 4));
+        $x13 = self::load_4(self::substr($k, 24, 4));
+        $x14 = self::load_4(self::substr($k, 28, 4));
+        $x6  = self::load_4(self::substr($in, 0, 4));
+        $x7  = self::load_4(self::substr($in, 4, 4));
+        $x8  = self::load_4(self::substr($in, 8, 4));
+        $x9  = self::load_4(self::substr($in, 12, 4));
+
+        for ($i = self::ROUNDS; $i > 0; $i -= 2) {
+            $x4 ^= self::rotate($x0 + $x12, 7);
+            $x8 ^= self::rotate($x4 + $x0, 9);
+            $x12 ^= self::rotate($x8 + $x4, 13);
+            $x0 ^= self::rotate($x12 + $x8, 18);
+            $x9 ^= self::rotate($x5 + $x1, 7);
+            $x13 ^= self::rotate($x9 + $x5, 9);
+            $x1 ^= self::rotate($x13 + $x9, 13);
+            $x5 ^= self::rotate($x1 + $x13, 18);
+            $x14 ^= self::rotate($x10 + $x6, 7);
+            $x2 ^= self::rotate($x14 + $x10, 9);
+            $x6 ^= self::rotate($x2 + $x14, 13);
+            $x10 ^= self::rotate($x6 + $x2, 18);
+            $x3 ^= self::rotate($x15 + $x11, 7);
+            $x7 ^= self::rotate($x3 + $x15, 9);
+            $x11 ^= self::rotate($x7 + $x3, 13);
+            $x15 ^= self::rotate($x11 + $x7, 18);
+            $x1 ^= self::rotate($x0 + $x3, 7);
+            $x2 ^= self::rotate($x1 + $x0, 9);
+            $x3 ^= self::rotate($x2 + $x1, 13);
+            $x0 ^= self::rotate($x3 + $x2, 18);
+            $x6 ^= self::rotate($x5 + $x4, 7);
+            $x7 ^= self::rotate($x6 + $x5, 9);
+            $x4 ^= self::rotate($x7 + $x6, 13);
+            $x5 ^= self::rotate($x4 + $x7, 18);
+            $x11 ^= self::rotate($x10 + $x9, 7);
+            $x8 ^= self::rotate($x11 + $x10, 9);
+            $x9 ^= self::rotate($x8 + $x11, 13);
+            $x10 ^= self::rotate($x9 + $x8, 18);
+            $x12 ^= self::rotate($x15 + $x14, 7);
+            $x13 ^= self::rotate($x12 + $x15, 9);
+            $x14 ^= self::rotate($x13 + $x12, 13);
+            $x15 ^= self::rotate($x14 + $x13, 18);
+        }
+
+        return self::store32_le($x0) .
+            self::store32_le($x5) .
+            self::store32_le($x10) .
+            self::store32_le($x15) .
+            self::store32_le($x6) .
+            self::store32_le($x7) .
+            self::store32_le($x8) .
+            self::store32_le($x9);
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_Poly1305', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_Poly1305
+ */
+abstract class ParagonIE_Sodium_Core_Poly1305 extends ParagonIE_Sodium_Core_Util
+{
+    const BLOCK_SIZE = 16;
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param string $m
+     * @param string $key
+     * @return string
+     * @throws SodiumException
+     * @throws TypeError
+     */
+    public static function onetimeauth($m, $key)
+    {
+        if (self::strlen($key) < 32) {
+            throw new InvalidArgumentException(
+                'Key must be 32 bytes long.'
+            );
+        }
+        $state = new ParagonIE_Sodium_Core_Poly1305_State(
+            self::substr($key, 0, 32)
+        );
+        return $state
+            ->update($m)
+            ->finish();
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param string $mac
+     * @param string $m
+     * @param string $key
+     * @return bool
+     * @throws SodiumException
+     * @throws TypeError
+     */
+    public static function onetimeauth_verify($mac, $m, $key)
+    {
+        if (self::strlen($key) < 32) {
+            throw new InvalidArgumentException(
+                'Key must be 32 bytes long.'
+            );
+        }
+        $state = new ParagonIE_Sodium_Core_Poly1305_State(
+            self::substr($key, 0, 32)
+        );
+        $calc = $state
+            ->update($m)
+            ->finish();
+        return self::verify_16($calc, $mac);
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_Salsa20', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_Sodium_Core_Salsa20
+ */
+abstract class ParagonIE_Sodium_Core_Salsa20 extends ParagonIE_Sodium_Core_Util
+{
+    const ROUNDS = 20;
+
+    /**
+     * Calculate an salsa20 hash of a single block
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param string $in
+     * @param string $k
+     * @param string|null $c
+     * @return string
+     * @throws TypeError
+     */
+    public static function core_salsa20($in, $k, $c = null)
+    {
+        if (self::strlen($k) < 32) {
+            throw new RangeException('Key must be 32 bytes long');
+        }
+        if ($c === null) {
+            $j0  = $x0  = 0x61707865;
+            $j5  = $x5  = 0x3320646e;
+            $j10 = $x10 = 0x79622d32;
+            $j15 = $x15 = 0x6b206574;
+        } else {
+            $j0  = $x0  = self::load_4(self::substr($c, 0, 4));
+            $j5  = $x5  = self::load_4(self::substr($c, 4, 4));
+            $j10 = $x10 = self::load_4(self::substr($c, 8, 4));
+            $j15 = $x15 = self::load_4(self::substr($c, 12, 4));
+        }
+        $j1  = $x1  = self::load_4(self::substr($k, 0, 4));
+        $j2  = $x2  = self::load_4(self::substr($k, 4, 4));
+        $j3  = $x3  = self::load_4(self::substr($k, 8, 4));
+        $j4  = $x4  = self::load_4(self::substr($k, 12, 4));
+        $j6  = $x6  = self::load_4(self::substr($in, 0, 4));
+        $j7  = $x7  = self::load_4(self::substr($in, 4, 4));
+        $j8  = $x8  = self::load_4(self::substr($in, 8, 4));
+        $j9  = $x9  = self::load_4(self::substr($in, 12, 4));
+        $j11 = $x11 = self::load_4(self::substr($k, 16, 4));
+        $j12 = $x12 = self::load_4(self::substr($k, 20, 4));
+        $j13 = $x13 = self::load_4(self::substr($k, 24, 4));
+        $j14 = $x14 = self::load_4(self::substr($k, 28, 4));
+
+        for ($i = self::ROUNDS; $i > 0; $i -= 2) {
+            $x4 ^= self::rotate($x0 + $x12, 7);
+            $x8 ^= self::rotate($x4 + $x0, 9);
+            $x12 ^= self::rotate($x8 + $x4, 13);
+            $x0 ^= self::rotate($x12 + $x8, 18);
+
+            $x9 ^= self::rotate($x5 + $x1, 7);
+            $x13 ^= self::rotate($x9 + $x5, 9);
+            $x1 ^= self::rotate($x13 + $x9, 13);
+            $x5 ^= self::rotate($x1 + $x13, 18);
+
+            $x14 ^= self::rotate($x10 + $x6, 7);
+            $x2 ^= self::rotate($x14 + $x10, 9);
+            $x6 ^= self::rotate($x2 + $x14, 13);
+            $x10 ^= self::rotate($x6 + $x2, 18);
+
+            $x3 ^= self::rotate($x15 + $x11, 7);
+            $x7 ^= self::rotate($x3 + $x15, 9);
+            $x11 ^= self::rotate($x7 + $x3, 13);
+            $x15 ^= self::rotate($x11 + $x7, 18);
+
+            $x1 ^= self::rotate($x0 + $x3, 7);
+            $x2 ^= self::rotate($x1 + $x0, 9);
+            $x3 ^= self::rotate($x2 + $x1, 13);
+            $x0 ^= self::rotate($x3 + $x2, 18);
+
+            $x6 ^= self::rotate($x5 + $x4, 7);
+            $x7 ^= self::rotate($x6 + $x5, 9);
+            $x4 ^= self::rotate($x7 + $x6, 13);
+            $x5 ^= self::rotate($x4 + $x7, 18);
+
+            $x11 ^= self::rotate($x10 + $x9, 7);
+            $x8 ^= self::rotate($x11 + $x10, 9);
+            $x9 ^= self::rotate($x8 + $x11, 13);
+            $x10 ^= self::rotate($x9 + $x8, 18);
+
+            $x12 ^= self::rotate($x15 + $x14, 7);
+            $x13 ^= self::rotate($x12 + $x15, 9);
+            $x14 ^= self::rotate($x13 + $x12, 13);
+            $x15 ^= self::rotate($x14 + $x13, 18);
+        }
+
+        $x0  += $j0;
+        $x1  += $j1;
+        $x2  += $j2;
+        $x3  += $j3;
+        $x4  += $j4;
+        $x5  += $j5;
+        $x6  += $j6;
+        $x7  += $j7;
+        $x8  += $j8;
+        $x9  += $j9;
+        $x10 += $j10;
+        $x11 += $j11;
+        $x12 += $j12;
+        $x13 += $j13;
+        $x14 += $j14;
+        $x15 += $j15;
+
+        return self::store32_le($x0) .
+            self::store32_le($x1) .
+            self::store32_le($x2) .
+            self::store32_le($x3) .
+            self::store32_le($x4) .
+            self::store32_le($x5) .
+            self::store32_le($x6) .
+            self::store32_le($x7) .
+            self::store32_le($x8) .
+            self::store32_le($x9) .
+            self::store32_le($x10) .
+            self::store32_le($x11) .
+            self::store32_le($x12) .
+            self::store32_le($x13) .
+            self::store32_le($x14) .
+            self::store32_le($x15);
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $len
+     * @param string $nonce
+     * @param string $key
+     * @return string
+     * @throws SodiumException
+     * @throws TypeError
+     */
+    public static function salsa20($len, $nonce, $key)
+    {
+        if (self::strlen($key) !== 32) {
+            throw new RangeException('Key must be 32 bytes long');
+        }
+        $kcopy = '' . $key;
+        $in = self::substr($nonce, 0, 8) . str_repeat("\0", 8);
+        $c = '';
+        while ($len >= 64) {
+            $c .= self::core_salsa20($in, $kcopy, null);
+            $u = 1;
+            // Internal counter.
+            for ($i = 8; $i < 16; ++$i) {
+                $u += self::chrToInt($in[$i]);
+                $in[$i] = self::intToChr($u & 0xff);
+                $u >>= 8;
+            }
+            $len -= 64;
+        }
+        if ($len > 0) {
+            $c .= self::substr(
+                self::core_salsa20($in, $kcopy, null),
+                0,
+                $len
+            );
+        }
+        try {
+            ParagonIE_Sodium_Compat::memzero($kcopy);
+        } catch (SodiumException $ex) {
+            $kcopy = null;
+        }
+        return $c;
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param string $m
+     * @param string $n
+     * @param int $ic
+     * @param string $k
+     * @return string
+     * @throws SodiumException
+     * @throws TypeError
+     */
+    public static function salsa20_xor_ic($m, $n, $ic, $k)
+    {
+        $mlen = self::strlen($m);
+        if ($mlen < 1) {
+            return '';
+        }
+        $kcopy = self::substr($k, 0, 32);
+        $in = self::substr($n, 0, 8);
+        // Initialize the counter
+        $in .= ParagonIE_Sodium_Core_Util::store64_le($ic);
+
+        $c = '';
+        while ($mlen >= 64) {
+            $block = self::core_salsa20($in, $kcopy, null);
+            $c .= self::xorStrings(
+                self::substr($m, 0, 64),
+                self::substr($block, 0, 64)
+            );
+            $u = 1;
+            for ($i = 8; $i < 16; ++$i) {
+                $u += self::chrToInt($in[$i]);
+                $in[$i] = self::intToChr($u & 0xff);
+                $u >>= 8;
+            }
+
+            $mlen -= 64;
+            $m = self::substr($m, 64);
+        }
+
+        if ($mlen) {
+            $block = self::core_salsa20($in, $kcopy, null);
+            $c .= self::xorStrings(
+                self::substr($m, 0, $mlen),
+                self::substr($block, 0, $mlen)
+            );
+        }
+        try {
+            ParagonIE_Sodium_Compat::memzero($block);
+            ParagonIE_Sodium_Compat::memzero($kcopy);
+        } catch (SodiumException $ex) {
+            $block = null;
+            $kcopy = null;
+        }
+
+        return $c;
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param string $message
+     * @param string $nonce
+     * @param string $key
+     * @return string
+     * @throws SodiumException
+     * @throws TypeError
+     */
+    public static function salsa20_xor($message, $nonce, $key)
+    {
+        return self::xorStrings(
+            $message,
+            self::salsa20(
+                self::strlen($message),
+                $nonce,
+                $key
+            )
+        );
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $u
+     * @param int $c
+     * @return int
+     */
+    public static function rotate($u, $c)
+    {
+        $u &= 0xffffffff;
+        $c %= 32;
+        return (int) (0xffffffff & (
+                ($u << $c)
+                    |
+                ($u >> (32 - $c))
+            )
+        );
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+/**
+ * Class ParagonIE_Sodium_Core_SecretStream_State
+ */
+class ParagonIE_Sodium_Core_SecretStream_State
+{
+    /** @var string $key */
+    protected $key;
+
+    /** @var int $counter */
+    protected $counter;
+
+    /** @var string $nonce */
+    protected $nonce;
+
+    /** @var string $_pad */
+    protected $_pad;
+
+    /**
+     * ParagonIE_Sodium_Core_SecretStream_State constructor.
+     * @param string $key
+     * @param string|null $nonce
+     */
+    public function __construct($key, $nonce = null)
+    {
+        $this->key = $key;
+        $this->counter = 1;
+        if (is_null($nonce)) {
+            $nonce = str_repeat("\0", 12);
+        }
+        $this->nonce = str_pad($nonce, 12, "\0", STR_PAD_RIGHT);;
+        $this->_pad = str_repeat("\0", 4);
+    }
+
+    /**
+     * @return self
+     */
+    public function counterReset()
+    {
+        $this->counter = 1;
+        $this->_pad = str_repeat("\0", 4);
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getKey()
+    {
+        return $this->key;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCounter()
+    {
+        return ParagonIE_Sodium_Core_Util::store32_le($this->counter);
+    }
+
+    /**
+     * @return string
+     */
+    public function getNonce()
+    {
+        if (!is_string($this->nonce)) {
+            $this->nonce = str_repeat("\0", 12);
+        }
+        if (ParagonIE_Sodium_Core_Util::strlen($this->nonce) !== 12) {
+            $this->nonce = str_pad($this->nonce, 12, "\0", STR_PAD_RIGHT);
+        }
+        return $this->nonce;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCombinedNonce()
+    {
+        return $this->getCounter() .
+            ParagonIE_Sodium_Core_Util::substr($this->getNonce(), 0, 8);
+    }
+
+    /**
+     * @return self
+     */
+    public function incrementCounter()
+    {
+        ++$this->counter;
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function needsRekey()
+    {
+        return ($this->counter & 0xffff) === 0;
+    }
+
+    /**
+     * @param string $newKeyAndNonce
+     * @return self
+     */
+    public function rekey($newKeyAndNonce)
+    {
+        $this->key = ParagonIE_Sodium_Core_Util::substr($newKeyAndNonce, 0, 32);
+        $this->nonce = str_pad(
+            ParagonIE_Sodium_Core_Util::substr($newKeyAndNonce, 32),
+            12,
+            "\0",
+            STR_PAD_RIGHT
+        );
+        return $this;
+    }
+
+    /**
+     * @param string $str
+     * @return self
+     */
+    public function xorNonce($str)
+    {
+        $this->nonce = ParagonIE_Sodium_Core_Util::xorStrings(
+            $this->getNonce(),
+            str_pad(
+                ParagonIE_Sodium_Core_Util::substr($str, 0, 8),
+                12,
+                "\0",
+                STR_PAD_RIGHT
+            )
+        );
+        return $this;
+    }
+
+    /**
+     * @param string $string
+     * @return self
+     */
+    public static function fromString($string)
+    {
+        $state = new ParagonIE_Sodium_Core_SecretStream_State(
+            ParagonIE_Sodium_Core_Util::substr($string, 0, 32)
+        );
+        $state->counter = ParagonIE_Sodium_Core_Util::load_4(
+            ParagonIE_Sodium_Core_Util::substr($string, 32, 4)
+        );
+        $state->nonce = ParagonIE_Sodium_Core_Util::substr($string, 36, 12);
+        $state->_pad = ParagonIE_Sodium_Core_Util::substr($string, 48, 8);
+        return $state;
+    }
+
+    /**
+     * @return string
+     */
+    public function toString()
+    {
+        return $this->key .
+            $this->getCounter() .
+            $this->nonce .
+            $this->_pad;
+    }
+}

+<?php
+// phpcs:ignoreFile -- compatibility library for PHP 5-7.1
+
+if (class_exists('ParagonIE_Sodium_Core_SipHash', false)) {
+    return;
+}
+
+/**
+ * Class ParagonIE_SodiumCompat_Core_SipHash
+ *
+ * Only uses 32-bit arithmetic, while the original SipHash used 64-bit integers
+ */
+class ParagonIE_Sodium_Core_SipHash extends ParagonIE_Sodium_Core_Util
+{
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int[] $v
+     * @return int[]
+     */
+    public static function sipRound(array $v)
+    {
+        # v0 += v1;
+        list($v[0], $v[1]) = self::add(
+            array($v[0], $v[1]),
+            array($v[2], $v[3])
+        );
+
+        #  v1=ROTL(v1,13);
+        list($v[2], $v[3]) = self::rotl_64($v[2], $v[3], 13);
+
+        #  v1 ^= v0;
+        $v[2] ^= $v[0];
+        $v[3] ^= $v[1];
+
+        #  v0=ROTL(v0,32);
+        list($v[0], $v[1]) = self::rotl_64((int) $v[0], (int) $v[1], 32);
+
+        # v2 += v3;
+        list($v[4], $v[5]) = self::add(
+            array($v[4], $v[5]),
+            array($v[6], $v[7])
+        );
+
+        # v3=ROTL(v3,16);
+        list($v[6], $v[7]) = self::rotl_64($v[6], $v[7], 16);
+
+        #  v3 ^= v2;
+        $v[6] ^= $v[4];
+        $v[7] ^= $v[5];
+
+        # v0 += v3;
+        list($v[0], $v[1]) = self::add(
+            array((int) $v[0], (int) $v[1]),
+            array((int) $v[6], (int) $v[7])
+        );
+
+        # v3=ROTL(v3,21);
+        list($v[6], $v[7]) = self::rotl_64((int) $v[6], (int) $v[7], 21);
+
+        # v3 ^= v0;
+        $v[6] ^= $v[0];
+        $v[7] ^= $v[1];
+
+        # v2 += v1;
+        list($v[4], $v[5]) = self::add(
+            array((int) $v[4], (int) $v[5]),
+            array((int) $v[2], (int) $v[3])
+        );
+
+        # v1=ROTL(v1,17);
+        list($v[2], $v[3]) = self::rotl_64((int) $v[2], (int) $v[3], 17);
+
+        #  v1 ^= v2;;
+        $v[2] ^= $v[4];
+        $v[3] ^= $v[5];
+
+        # v2=ROTL(v2,32)
+        list($v[4], $v[5]) = self::rotl_64((int) $v[4], (int) $v[5], 32);
+
+        return $v;
+    }
+
+    /**
+     * Add two 32 bit integers representing a 64-bit integer.
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param int[] $a
+     * @param int[] $b
+     * @return array<int, mixed>
+     */
+    public static function add(array $a, array $b)
+    {
+        /** @var int $x1 */
+        $x1 = $a[1] + $b[1];
+        /** @var int $c */
+        $c = $x1 >> 32; // Carry if ($a + $b) > 0xffffffff
+        /** @var int $x0 */
+        $x0 = $a[0] + $b[0] + $c;
+        return array(
+            $x0 & 0xffffffff,
+            $x1 & 0xffffffff
+        );
+    }
+
+    /**
+     * @internal You should not use this directly from another application
+     *
+     * @param int $int0
+     * @param int $int1
+     * @param int $c
+     * @return array<int, mixed>
+     */
+    public static function rotl_64($int0, $int1, $c)
+    {
+        $int0 &= 0xffffffff;
+        $int1 &= 0xffffffff;
+        $c &= 63;
+        if ($c === 32) {
+            return array($int1, $int0);
+        }
+        if ($c > 31) {
+            $tmp = $int1;
+            $int1 = $int0;
+            $int0 = $tmp;
+            $c &= 31;
+        }
+        if ($c === 0) {
+            return array($int0, $int1);
+        }
+        return array(
+            0xffffffff & (
+                ($int0 << $c)
+                    |
+                ($int1 >> (32 - $c))
+            ),
+            0xffffffff & (
+                ($int1 << $c)
+                    |
+                ($int0 >> (32 - $c))
+            ),
+        );
+    }
+
+    /**
+     * Implements Siphash-2-4 using only 32-bit numbers.
+     *
+     * When we split an int into two, the higher bits go to the lower index.
+     * e.g. 0xDEADBEEFAB10C92D becomes [
+     *     0 => 0xDEADBEEF,
+     *     1 => 0xAB10C92D
+     * ].
+     *
+     * @internal You should not use this directly from another application
+     *
+     * @param string $in
+     * @param string $key
+     * @return string
+     * @throws SodiumException
+     * @throws TypeError
+     */
+    public static function sipHash24($in, $key)
+    {
+        $inlen = self::strlen($in);
+
+        # /* "somepseudorandomlygeneratedbytes" */
+        # u64 v0 = 0x736f6d6570736575ULL;
+        # u64 v1 = 0x646f72616e646f6dULL;
+        # u64 v2 = 0x6c7967656e657261ULL;
+        # u64 v3 = 0x7465646279746573ULL;
+        $v = array(
+            0x736f6d65, // 0
+            0x70736575, // 1
+            0x646f7261, // 2
+            0x6e646f6d, // 3
+            0x6c796765, // 4
+            0x6e657261, // 5
+            0x74656462, // 6
+            0x79746573  // 7
+        );
+        // v0 => $v[0], $v[1]
+        // v1 => $v[2], $v[3]
+        // v2 => $v[4], $v[5]
+        // v3 => $v[6], $v[7]
+
+        # u64 k0 = LOAD64_LE( k );
+        # u64 k1 = LOAD64_LE( k + 8 );
+        $k = array(
+            self::load_4(self::substr($key, 4, 4)),
+            self::load_4(self::substr($key, 0, 4)),
+            self::load_4(self::substr($key, 12, 4)),
+            self::load_4(self::substr($key, 8, 4))
+        );
+        // k0 => $k[0], $k[1]
+        // k1 => $k[2], $k[3]
+
+        # b = ( ( u64 )inlen ) << 56;
+        $b = array(
+            $inlen << 24,
+            0
+        );
+        // See docblock for why the 0th index gets the higher bits.
+
+        # v3 ^= k1;
+        $v[6] ^= $k[2];
+        $v[7] ^= $k[3];
+        # v2 ^= k0;
+        $v[4] ^= $k[0];
+        $v[5] ^= $k[1];
+        # v1 ^= k1;
+        $v[2] ^= $k[2];
+        $v[3] ^= $k[3];
+        # v0 ^= k0;
+        $v[0] ^= $k[0];
+        $v[1] ^= $k[1];
+
+        $left = $inlen;
+        # for ( ; in != end; in += 8 )
+        while ($left >= 8) {
+            # m = LOAD64_LE( in );
+            $m = array(
+                self::load_4(self::substr($in, 4, 4)),
+                self::load_4(self::substr($in, 0, 4))
+            );
+
+            # v3 ^= m;
+            $v[6] ^= $m[0];
+            $v[7] ^= $m[1];
+
+            # SIPROUND;
+            # SIPROUND;
+            $v = self::sipRound($v);
+            $v = self::sipRound($v);
+
+            # v0 ^= m;
+            $v[0] ^= $m[0];
+            $v[1] ^= $m[1];
+
+            $in = self::substr($in, 8);
+            $left -= 8;
+        }
+
+        # switch( left )
+        #  {
+        #     case 7: b |= ( ( u64 )in[ 6] )  << 48;
+        #     case 6: b |= ( ( u64 )in[ 5] )  << 40;
+        #     case 5: b |= ( ( u64 )in[ 4] )  << 32;
+        #     case 4: b |= ( ( u64 )in[ 3] )  << 24;
+        #     case 3: b |= ( ( u64 )in[ 2] )  << 16;
+        #     case 2: b |= ( ( u64 )in[ 1] )  <<  8;
+        #     case 1: b |= ( ( u64 )in[ 0] ); break;
+        #     case 0: break;
+        # }
+        switch ($left) {
+            case 7:
+                $b[0] |= self::chrToInt($in[6]) << 16;
+            case 6:
+                $b[0] |= self::chrToInt($in[5]) << 8;
+            case 5:
+                $b[0] |= self::chrToInt($in[4]);
+            case 4:
+                $b[1] |= self::chrToInt($in[3]) << 24;
+            case 3:
+                $b[1] |= self::chrToInt($in[2]) << 16;
+            case 2:
+                $b[1] |= self::chrToInt($in[1]) << 8;
+            case 1:
+                $b[1] |= self::chrToInt($in[0]);
+            case 0:
+                break;
+        }
+        // See docblock for why the 0th index gets the higher bits.
+
+        # v3 ^= b;
+        $v[6] ^= $b[0];
+        $v[7] ^= $b[1];
+
+        # SIPROUND;
+        # SIPROUND;
+        $v = self::sipRound($v);
+        $v = self::sipRound($v);
+
+        # v0 ^= b;
+        $v[0] ^= $b[0];
+        $v[1] ^= $b[1];
+
+        // Flip the lower 8 bits of v2 which is ($v[4], $v[5]) in our implementation
+        # v2 ^= 0xff;
+        $v[5] ^= 0xff;
+
+        # SIPROUND;
+        # SIPROUND;
+        # SIPROUND;
+        # SIPROUND;
+        $v = self::sipRound($v);
+        $v = self::sipRound($v);
+        $v = self::sipRound($v);
+        $v = self::sipRound($v);
+
+        # b = v0 ^ v1 ^ v2 ^ v3;
+        # STORE64_LE( out, b );
+        return  self::store32_le($v[1] ^ $v[3] ^ $v[5] ^ $v[7]) .
+            self::store32_le($v[0] ^ $v[2] ^ $v[4] ^ $v[6]);
+    }
+}