feat: add GitHub-powered updates to WordPress admin

.github/workflows/release.yml

@@ -0,0 +1,38 @@
+name: Build plugin release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Validate version and build ZIP
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          VERSION="${RELEASE_TAG#v}"
+          grep -q "Version: ${VERSION}$" dabestaniha-authenticate-bridge.php
+          mkdir -p build/mahak-authenticate-bridge dist
+          rsync -a \
+            --exclude='.git/' \
+            --exclude='.github/' \
+            --exclude='build/' \
+            --exclude='dist/' \
+            --exclude='test/' \
+            ./ build/mahak-authenticate-bridge/
+          cd build
+          zip -qr ../dist/mahak-authenticate-bridge.zip mahak-authenticate-bridge
+
+      - name: Publish GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: gh release create "$RELEASE_TAG" dist/mahak-authenticate-bridge.zip --generate-notes --title "$RELEASE_TAG"

.gitignore

@@ -50,6 +50,5 @@ wp-config.php
 *.zip
 .DS_Store
 .idea/
-!vendor/
 node_modules/
 .env

README.md

@@ -8,6 +8,15 @@ Authenticate WordPress user via json web token from Laravel Application.
 - Login via JWT token
 - Admin settings page
 - Custom invalid token page
+- Optional debug mode with full exception details and stack traces
+
+Debug mode is disabled by default. An administrator can enable it from **Settings > Mahak Authentication** while troubleshooting. Because diagnostic pages expose server paths and other technical details to visitors of the login URL, disable it again after diagnosing the problem.
+
+## Updates
+
+Administrators can check for and install published releases from **Settings > Mahak Authentication**. Updates also appear in WordPress's standard **Plugins** and **Updates** screens.
+
+To publish an update, change the plugin `Version` header and `MAHAK_AUTHENTICATE_BRIDGE_VERSION` constant to the same version, commit the change, and push a matching tag such as `v2.3.0` to GitHub. The release workflow builds and attaches the ZIP required by the WordPress updater.
 
 ## Usage
 

composer.json

@@ -1,16 +0,0 @@
-{
-  "name": "dabestaniha/authenticate-bridge",
-  "require": {
-    "php": "^8.2",
-    "firebase/php-jwt": "^6.11"
-  },
-  "autoload": {
-    "psr-4": {
-      "Dabestaniha\\AuthenticateBridge\\App\\": "src/app/",
-      "Dabestaniha\\AuthenticateBridge\\": "src/"
-    },
-    "files": [
-      "src/helpers.php"
-    ]
-  }
-}

composer.lock

@@ -1,84 +0,0 @@
-{
-    "_readme": [
-        "This file locks the dependencies of your project to a known state",
-        "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
-        "This file is @generated automatically"
-    ],
-    "content-hash": "775143d1bcec2aacbb576adc03b110ae",
-    "packages": [
-        {
-            "name": "firebase/php-jwt",
-            "version": "v6.11.1",
-            "source": {
-                "type": "git",
-                "url": "https://github.com/firebase/php-jwt.git",
-                "reference": "d1e91ecf8c598d073d0995afa8cd5c75c6e19e66"
-            },
-            "dist": {
-                "type": "zip",
-                "url": "https://api.github.com/repos/firebase/php-jwt/zipball/d1e91ecf8c598d073d0995afa8cd5c75c6e19e66",
-                "reference": "d1e91ecf8c598d073d0995afa8cd5c75c6e19e66",
-                "shasum": ""
-            },
-            "require": {
-                "php": "^8.0"
-            },
-            "require-dev": {
-                "guzzlehttp/guzzle": "^7.4",
-                "phpspec/prophecy-phpunit": "^2.0",
-                "phpunit/phpunit": "^9.5",
-                "psr/cache": "^2.0||^3.0",
-                "psr/http-client": "^1.0",
-                "psr/http-factory": "^1.0"
-            },
-            "suggest": {
-                "ext-sodium": "Support EdDSA (Ed25519) signatures",
-                "paragonie/sodium_compat": "Support EdDSA (Ed25519) signatures when libsodium is not present"
-            },
-            "type": "library",
-            "autoload": {
-                "psr-4": {
-                    "Firebase\\JWT\\": "src"
-                }
-            },
-            "notification-url": "https://packagist.org/downloads/",
-            "license": [
-                "BSD-3-Clause"
-            ],
-            "authors": [
-                {
-                    "name": "Neuman Vong",
-                    "email": "neuman+pear@twilio.com",
-                    "role": "Developer"
-                },
-                {
-                    "name": "Anant Narayanan",
-                    "email": "anant@php.net",
-                    "role": "Developer"
-                }
-            ],
-            "description": "A simple library to encode and decode JSON Web Tokens (JWT) in PHP. Should conform to the current spec.",
-            "homepage": "https://github.com/firebase/php-jwt",
-            "keywords": [
-                "jwt",
-                "php"
-            ],
-            "support": {
-                "issues": "https://github.com/firebase/php-jwt/issues",
-                "source": "https://github.com/firebase/php-jwt/tree/v6.11.1"
-            },
-            "time": "2025-04-09T20:32:01+00:00"
-        }
-    ],
-    "packages-dev": [],
-    "aliases": [],
-    "minimum-stability": "stable",
-    "stability-flags": {},
-    "prefer-stable": false,
-    "prefer-lowest": false,
-    "platform": {
-        "php": "^8.2"
-    },
-    "platform-dev": {},
-    "plugin-api-version": "2.6.0"
-}

dabestaniha-authenticate-bridge.php

@@ -2,18 +2,35 @@
 
 /**
  * Plugin Name: Mahak Authenticate Bridge
+ * Plugin URI: https://github.com/dabestaniha/mahak-authenticate-bridge
  * Description: Authenticate WordPress user via json web token from Mahakiha Application.
- * Version: 1.0
+ * Version: 2.2.0
+ * Requires PHP: 7.4
+ * Update URI: https://github.com/dabestaniha/mahak-authenticate-bridge
  * Author: Dabestaniha
  *
  * Example: https://wordpress.test/mahak/login/?token=eyJ0...
  */
 
-require_once __DIR__.'/vendor/autoload.php';
+use Dabestaniha\AuthenticateBridge\Autoloader;
-
 use Dabestaniha\AuthenticateBridge\App\Http\Controllers\AuthenticateController;
 use Dabestaniha\AuthenticateBridge\App\Http\Controllers\SettingsPageMenuController;
 use Dabestaniha\AuthenticateBridge\App\Http\Controllers\SettingsPageFormController;
+use Dabestaniha\AuthenticateBridge\App\Support\PluginUpdater;
+
+define('MAHAK_AUTHENTICATE_BRIDGE_VERSION', '2.2.0');
+define('MAHAK_AUTHENTICATE_BRIDGE_FILE', __FILE__);
+
+require_once __DIR__.'/src/Autoloader.php';
+
+Autoloader::register([
+    'Dabestaniha\\AuthenticateBridge\\App\\' => __DIR__.'/src/app',
+    'Dabestaniha\\AuthenticateBridge\\' => __DIR__.'/src',
+]);
+
+require_once __DIR__.'/src/helpers.php';
+
+PluginUpdater::boot();
 
 add_action('init', fn() => AuthenticateController::resolve());
 

src/Autoloader.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Dabestaniha\AuthenticateBridge;
+
+final class Autoloader
+{
+    private array $prefixes;
+
+    public static function register(array $prefixes): void
+    {
+        $loader = new self($prefixes);
+
+        spl_autoload_register([$loader, 'load']);
+    }
+
+    public function __construct(array $prefixes)
+    {
+        $normalized = [];
+
+        foreach ($prefixes as $prefix => $baseDir) {
+            $prefix = rtrim($prefix, '\\').'\\';
+            $normalized[$prefix] = rtrim($baseDir, DIRECTORY_SEPARATOR);
+        }
+
+        uksort($normalized, fn (string $a, string $b) => strlen($b) <=> strlen($a));
+
+        $this->prefixes = $normalized;
+    }
+
+    public function load(string $class): void
+    {
+        foreach ($this->prefixes as $prefix => $baseDir) {
+            if (strncmp($class, $prefix, strlen($prefix)) !== 0) {
+                continue;
+            }
+
+            $relativeClass = substr($class, strlen($prefix));
+            $file = $baseDir.DIRECTORY_SEPARATOR.str_replace('\\', DIRECTORY_SEPARATOR, $relativeClass).'.php';
+
+            if (is_file($file)) {
+                require_once $file;
+            }
+
+            return;
+        }
+    }
+}

src/app/Http/Controllers/AuthenticateController.php

@@ -3,8 +3,10 @@
 namespace Dabestaniha\AuthenticateBridge\App\Http\Controllers;
 
 use Dabestaniha\AuthenticateBridge\App\Http\Requests\MahakAuthenticateRequest;
-use ReflectionMethod;
+use Dabestaniha\AuthenticateBridge\App\Support\JwtDecoder;
-use Firebase\JWT;
+use RuntimeException;
+use Throwable;
+use UnexpectedValueException;
 
 class AuthenticateController extends InvocableController
 {
@@ -31,12 +33,14 @@ class AuthenticateController extends InvocableController
     {
         $jwt_secret = get_configured_option('jwt-secret');
 
-        try {
+        $decoded = JwtDecoder::decodeHs256($token, $jwt_secret);
-            $decoded = (array) JWT\JWT::decode($token, new JWT\Key($jwt_secret, 'HS256'));
+        $data = $decoded['data'] ?? null;
-            return (array) $decoded['data'];
+
-        } catch (\Exception $e) {
+        if (!is_array($data)) {
-            wp_die(view('invalid-token'), 'Invalid Token', ['response' => 500]);
+            throw new UnexpectedValueException('JWT data must be an object.');
         }
+
+        return $data;
     }
 
     public function find_or_create_user(string $identifier_name, string $identifier_value, string $name): int
@@ -48,25 +52,42 @@ class AuthenticateController extends InvocableController
         }
         $random_password = wp_generate_password(12, true);
         $username = $identifier_value;
+        $email = $identifier_name === 'email' ? $identifier_value : '';
 
         if (username_exists($username)) {
             $username .= '_'.wp_generate_password(4, false);
         }
 
-        $user_id = wp_create_user($username, $random_password);
+        $user_id = wp_create_user($username, $random_password, $email);
 
         if (is_wp_error($user_id)) {
-            wp_die(view('invalid-token'), 'Invalid Token', ['response' => 500]);
+            throw new RuntimeException(
+                'WordPress could not create the user: '.$user_id->get_error_message()
+            );
         }
 
-        wp_update_user([
+        $updated_user_id = wp_update_user([
             'ID' => $user_id,
             'display_name' => $name,
         ]);
 
+        if (is_wp_error($updated_user_id)) {
+            throw new RuntimeException(
+                'WordPress could not update the user: '.$updated_user_id->get_error_message()
+            );
+        }
+
         return $user_id;
     }
 
+    protected function handleException(Throwable $exception): void
+    {
+        $status = $exception->getCode() === 403 ? 403 : 500;
+        $fallbackView = $exception instanceof UnexpectedValueException ? 'invalid-token' : 'server-error';
+
+        mahak_render_error($exception, $status, $fallbackView);
+    }
+
 
     public function login_user(int $user_id): bool
     {

src/app/Http/Controllers/InvocableController.php

@@ -4,11 +4,15 @@ namespace Dabestaniha\AuthenticateBridge\App\Http\Controllers;
 
 use Dabestaniha\AuthenticateBridge\App\Http\Requests\BaseFormRequest;
 use ReflectionMethod;
+use Throwable;
 
 abstract class InvocableController
 {
     public static function resolve(): void
     {
+        $controller = new static();
+
+        try {
             $reflection = new ReflectionMethod(static::class, '__invoke');
 
             $args = [];
@@ -27,7 +31,14 @@ abstract class InvocableController
                 }
             }
 
-        $controller = new static();
             $controller(...$args);
+        } catch (Throwable $exception) {
+            $controller->handleException($exception);
+        }
+    }
+
+    protected function handleException(Throwable $exception): void
+    {
+        throw $exception;
     }
 }

src/app/Http/Controllers/SettingsPageFormController.php

@@ -7,7 +7,16 @@ class SettingsPageFormController extends InvocableController
     public function __invoke()
     {
         foreach (config('mahak.options') as $configured => $options_key) {
-            register_setting(config('mahak.settings-group'), $options_key);
+            $args = [];
+
+            if ($configured === 'debug-mode') {
+                $args['sanitize_callback'] = function ($value): int {
+                    return (int) filter_var($value, FILTER_VALIDATE_BOOLEAN);
+                };
+                $args['default'] = 0;
+            }
+
+            register_setting(config('mahak.settings-group'), $options_key, $args);
         }
 
         add_settings_section(
@@ -49,6 +58,14 @@ class SettingsPageFormController extends InvocableController
             config('mahak.section-id')
         );
 
+        add_settings_field(
+            config('mahak.options.debug-mode'),
+            config('mahak.translations.debug-mode'),
+            fn () => $this->debug_mode(),
+            config('mahak.settings-page'),
+            config('mahak.section-id')
+        );
+
         $loginRouteOptionName = config('mahak.options.login-route');
         add_filter("pre_update_option_{$loginRouteOptionName}", function ($value) {
             return trim($value, '/');
@@ -103,4 +120,14 @@ class SettingsPageFormController extends InvocableController
         echo "<input type='text' name='$name' value='$value' class='regular-text' />";
         echo '</div>';
     }
+
+    public function debug_mode(): void
+    {
+        $name = config('mahak.options.debug-mode');
+        $enabled = (bool) get_option($name, false);
+
+        echo "<input type='hidden' name='".esc_attr($name)."' value='0' />";
+        echo "<label><input type='checkbox' name='".esc_attr($name)."' value='1' ".checked($enabled, true, false).' /> ';
+        echo esc_html(config('mahak.translations.debug-mode-description')).'</label>';
+    }
 }

src/app/Http/Controllers/SettingsPageMenuController.php

@@ -2,6 +2,8 @@
 
 namespace Dabestaniha\AuthenticateBridge\App\Http\Controllers;
 
+use Dabestaniha\AuthenticateBridge\App\Support\PluginUpdater;
+
 class SettingsPageMenuController extends InvocableController
 {
     public function __invoke()
@@ -27,6 +29,7 @@ class SettingsPageMenuController extends InvocableController
                 submit_button();
                 ?>
             </form>
+            <?php PluginUpdater::renderUpdatePanel(); ?>
         </div>
         <?php
     }

src/app/Http/Requests/BaseFormRequest.php

@@ -3,10 +3,11 @@
 namespace Dabestaniha\AuthenticateBridge\App\Http\Requests;
 
 use Dabestaniha\AuthenticateBridge\App\Support\Collection;
+use UnexpectedValueException;
 
 abstract class BaseFormRequest
 {
-    public static function make(): static
+    public static function make(): self
     {
         return new static();
     }
@@ -18,10 +19,7 @@ abstract class BaseFormRequest
     public function __construct()
     {
         $this->url = parse_url($_SERVER['REQUEST_URI']);
-        $this->form = [
+        $this->form = array_merge($_GET, $_POST);
-            ...$_GET,
-            ...$_POST,
-        ];
     }
 
     public function isRequestForThisRoute(): bool
@@ -33,7 +31,9 @@ abstract class BaseFormRequest
 
     public function getCurrentRoutePath(): string
     {
-        return $this->url['path'];
+        $site = parse_url(get_option('siteurl'));
+
+        return str_replace($site['path'] ?? '', null, $this->url['path'] ?? '');
     }
 
     public function validate(): void
@@ -45,7 +45,10 @@ abstract class BaseFormRequest
 
             foreach ($rules as $rule) {
                 if (!$this->validateValue($value, $rule)) {
-                    wp_die(view('invalid-token'), 'Invalid Token', ['response' => 403]);
+                    throw new UnexpectedValueException(
+                        sprintf('The request field "%s" failed the "%s" validation rule.', $attribute, $rule),
+                        403
+                    );
                 }
 
                 $data[$attribute] = $value;
@@ -59,11 +62,14 @@ abstract class BaseFormRequest
 
     protected function validateValue($value, $rule): bool
     {
-        return match ($rule) {
+        switch ($rule) {
-            'required' => !empty($value),
+            case 'required':
-            'nullable' => true,
+                return !empty($value);
-            default => false,
+            case 'nullable':
-        };
+                return true;
+            default:
+                return false;
+        }
     }
 
 

src/app/Support/Collection.php

@@ -4,14 +4,16 @@ namespace Dabestaniha\AuthenticateBridge\App\Support;
 
 class Collection
 {
-    public static function make(array $items): static
+    public static function make(array $items): self
     {
         return new static($items);
     }
 
-    public function __construct(private array $items)
+    private array $items;
+
+    public function __construct(array $items)
     {
-        //
+        $this->items = $items;
     }
 
     public function get(string $key, $default = null)

src/app/Support/JwtDecoder.php

@@ -0,0 +1,134 @@
+<?php
+
+namespace Dabestaniha\AuthenticateBridge\App\Support;
+
+use JsonException;
+use stdClass;
+use UnexpectedValueException;
+
+final class JwtDecoder
+{
+    public static function decodeHs256(string $token, string $secret): array
+    {
+        if ($secret === '') {
+            throw new UnexpectedValueException('JWT secret must not be empty.');
+        }
+
+        $segments = explode('.', $token);
+
+        if (count($segments) !== 3) {
+            throw new UnexpectedValueException('JWT must contain header, payload, and signature.');
+        }
+
+        [$encodedHeader, $encodedPayload, $encodedSignature] = $segments;
+
+        if ($encodedHeader === '' || $encodedPayload === '' || $encodedSignature === '') {
+            throw new UnexpectedValueException('JWT segments must not be empty.');
+        }
+
+        $header = self::decodeJsonObject(self::base64UrlDecode($encodedHeader), 'JWT header');
+        $payload = self::decodeJsonObject(self::base64UrlDecode($encodedPayload), 'JWT payload');
+
+        if (($header['alg'] ?? null) !== 'HS256') {
+            throw new UnexpectedValueException('JWT algorithm must be HS256.');
+        }
+
+        $signature = self::base64UrlDecode($encodedSignature);
+        $expectedSignature = hash_hmac('sha256', $encodedHeader.'.'.$encodedPayload, $secret, true);
+
+        if (!hash_equals($expectedSignature, $signature)) {
+            throw new UnexpectedValueException('JWT signature is invalid.');
+        }
+
+        self::validateTimestamps($payload);
+
+        return $payload;
+    }
+
+    private static function base64UrlDecode(string $value): string
+    {
+        $remainder = strlen($value) % 4;
+
+        if ($remainder === 1) {
+            throw new UnexpectedValueException('JWT base64 encoding is invalid.');
+        }
+
+        if ($remainder > 0) {
+            $value .= str_repeat('=', 4 - $remainder);
+        }
+
+        $decoded = base64_decode(strtr($value, '-_', '+/'), true);
+
+        if ($decoded === false) {
+            throw new UnexpectedValueException('JWT base64 encoding is invalid.');
+        }
+
+        return $decoded;
+    }
+
+    private static function decodeJsonObject(string $json, string $section): array
+    {
+        try {
+            $decoded = json_decode($json, false, 512, JSON_THROW_ON_ERROR);
+        } catch (JsonException $exception) {
+            throw new UnexpectedValueException("$section is not valid JSON.", 0, $exception);
+        }
+
+        if (!$decoded instanceof stdClass) {
+            throw new UnexpectedValueException("$section must be a JSON object.");
+        }
+
+        return self::objectToArray($decoded);
+    }
+
+    private static function objectToArray($value)
+    {
+        if ($value instanceof stdClass) {
+            $items = [];
+
+            foreach (get_object_vars($value) as $key => $item) {
+                $items[$key] = self::objectToArray($item);
+            }
+
+            return $items;
+        }
+
+        if (is_array($value)) {
+            foreach ($value as $key => $item) {
+                $value[$key] = self::objectToArray($item);
+            }
+        }
+
+        return $value;
+    }
+
+    private static function validateTimestamps(array $payload): void
+    {
+        $now = time();
+
+        if (isset($payload['nbf']) && self::numericDate($payload['nbf'], 'nbf') > $now) {
+            throw new UnexpectedValueException('JWT cannot be used before nbf.');
+        }
+
+        if (isset($payload['iat']) && self::numericDate($payload['iat'], 'iat') > $now) {
+            throw new UnexpectedValueException('JWT cannot be used before iat.');
+        }
+
+        if (isset($payload['exp']) && self::numericDate($payload['exp'], 'exp') <= $now) {
+            throw new UnexpectedValueException('JWT has expired.');
+        }
+    }
+
+    private static function numericDate($value, string $claim): int
+    {
+        if (is_int($value) || is_float($value)) {
+            return (int) $value;
+        }
+
+        if (is_string($value) && is_numeric($value)) {
+            return (int) $value;
+        }
+
+        throw new UnexpectedValueException("JWT $claim claim must be numeric.");
+    }
+}

src/app/Support/PluginUpdater.php

@@ -0,0 +1,240 @@
+<?php
+
+namespace Dabestaniha\AuthenticateBridge\App\Support;
+
+final class PluginUpdater
+{
+    private const API_URL = 'https://api.github.com/repos/dabestaniha/mahak-authenticate-bridge/releases/latest';
+    private const RELEASE_ASSET = 'mahak-authenticate-bridge.zip';
+    private const RELEASE_CACHE = 'mahak_authenticate_bridge_release';
+    private const CHECK_ACTION = 'mahak_authenticate_check_updates';
+
+    private static ?self $instance = null;
+
+    private string $plugin;
+    private string $slug;
+
+    private function __construct()
+    {
+        $this->plugin = plugin_basename(MAHAK_AUTHENTICATE_BRIDGE_FILE);
+        $this->slug = dirname($this->plugin);
+    }
+
+    public static function boot(): void
+    {
+        if (self::$instance !== null) {
+            return;
+        }
+
+        self::$instance = new self();
+        add_filter('pre_set_site_transient_update_plugins', [self::$instance, 'addUpdate']);
+        add_filter('plugins_api', [self::$instance, 'addPluginInformation'], 20, 3);
+        add_action('admin_post_'.self::CHECK_ACTION, [self::$instance, 'checkNow']);
+    }
+
+    public function addUpdate($transient)
+    {
+        if (!is_object($transient) || empty($transient->checked)) {
+            return $transient;
+        }
+
+        $update = $this->availableUpdate();
+
+        if ($update !== null) {
+            if (!isset($transient->response) || !is_array($transient->response)) {
+                $transient->response = [];
+            }
+
+            $transient->response[$this->plugin] = $update;
+        }
+
+        return $transient;
+    }
+
+    public function addPluginInformation($result, string $action, $args)
+    {
+        if ($action !== 'plugin_information' || ($args->slug ?? '') !== $this->slug) {
+            return $result;
+        }
+
+        $release = $this->latestRelease();
+
+        if (is_wp_error($release)) {
+            return $result;
+        }
+
+        $package = $this->releasePackage($release);
+
+        if ($package === null) {
+            return $result;
+        }
+
+        return (object) [
+            'name' => 'Mahak Authenticate Bridge',
+            'slug' => $this->slug,
+            'version' => $this->releaseVersion($release),
+            'author' => 'Dabestaniha',
+            'homepage' => $release['html_url'] ?? 'https://github.com/dabestaniha/mahak-authenticate-bridge',
+            'download_link' => $package,
+            'requires_php' => '7.4',
+            'sections' => [
+                'description' => 'Authenticate WordPress users via JSON Web Tokens from the Mahakiha application.',
+                'changelog' => nl2br(esc_html((string) ($release['body'] ?? ''))),
+            ],
+        ];
+    }
+
+    public function checkNow(): void
+    {
+        if (!current_user_can('update_plugins')) {
+            wp_die(esc_html__('Sorry, you are not allowed to update plugins.'));
+        }
+
+        check_admin_referer(self::CHECK_ACTION);
+        delete_site_transient(self::RELEASE_CACHE);
+        delete_site_transient('update_plugins');
+        wp_update_plugins();
+
+        wp_safe_redirect(add_query_arg(
+            ['page' => config('mahak.settings-page'), 'update-checked' => '1'],
+            admin_url('options-general.php')
+        ));
+        exit;
+    }
+
+    public static function renderUpdatePanel(): void
+    {
+        if (self::$instance === null || !current_user_can('update_plugins')) {
+            return;
+        }
+
+        $updater = self::$instance;
+        $release = $updater->latestRelease();
+
+        echo '<hr><h2>'.esc_html__('Plugin updates').'</h2>';
+        echo '<p>'.sprintf(
+            esc_html__('Installed version: %s'),
+            '<strong>'.esc_html(MAHAK_AUTHENTICATE_BRIDGE_VERSION).'</strong>'
+        ).'</p>';
+
+        if (is_wp_error($release)) {
+            echo '<div class="notice notice-warning inline"><p>'.esc_html($release->get_error_message()).'</p></div>';
+        } else {
+            $update = $updater->availableUpdate($release);
+
+            if ($update !== null) {
+                echo '<p>'.sprintf(esc_html__('Version %s is available.'), esc_html($update->new_version)).'</p>';
+                $updateUrl = wp_nonce_url(
+                    self_admin_url('update.php?action=upgrade-plugin&plugin='.rawurlencode($updater->plugin)),
+                    'upgrade-plugin_'.$updater->plugin
+                );
+                echo '<p><a class="button button-primary" href="'.esc_url($updateUrl).'">'.esc_html__('Update now').'</a></p>';
+            } else {
+                echo '<p>'.esc_html__('You are using the latest available version.').'</p>';
+            }
+        }
+
+        echo '<form method="post" action="'.esc_url(admin_url('admin-post.php')).'">';
+        echo '<input type="hidden" name="action" value="'.esc_attr(self::CHECK_ACTION).'">';
+        wp_nonce_field(self::CHECK_ACTION);
+        submit_button(esc_html__('Check for updates'), 'secondary', 'submit', false);
+        echo '</form>';
+    }
+
+    private function availableUpdate(?array $release = null): ?object
+    {
+        $release = $release ?? $this->latestRelease();
+
+        if (is_wp_error($release)) {
+            return null;
+        }
+
+        $version = $this->releaseVersion($release);
+        $package = $this->releasePackage($release);
+
+        if ($version === '' || $package === null || !version_compare($version, MAHAK_AUTHENTICATE_BRIDGE_VERSION, '>')) {
+            return null;
+        }
+
+        return (object) [
+            'id' => $release['html_url'] ?? self::API_URL,
+            'slug' => $this->slug,
+            'plugin' => $this->plugin,
+            'new_version' => $version,
+            'url' => $release['html_url'] ?? '',
+            'package' => $package,
+            'requires_php' => '7.4',
+        ];
+    }
+
+    private function latestRelease()
+    {
+        $cached = get_site_transient(self::RELEASE_CACHE);
+
+        if (is_array($cached)) {
+            return $cached;
+        }
+
+        $response = wp_remote_get(self::API_URL, [
+            'headers' => [
+                'Accept' => 'application/vnd.github+json',
+                'User-Agent' => 'Mahak-Authenticate-Bridge/'.MAHAK_AUTHENTICATE_BRIDGE_VERSION,
+            ],
+            'timeout' => 10,
+        ]);
+
+        if (is_wp_error($response)) {
+            return new \WP_Error('mahak_update_request_failed', 'Could not contact GitHub to check for plugin updates.');
+        }
+
+        if (wp_remote_retrieve_response_code($response) !== 200) {
+            return new \WP_Error('mahak_update_response_invalid', 'No published plugin release is currently available on GitHub.');
+        }
+
+        $release = json_decode(wp_remote_retrieve_body($response), true);
+
+        if (!is_array($release) || !empty($release['draft']) || !empty($release['prerelease'])) {
+            return new \WP_Error('mahak_update_release_invalid', 'GitHub returned invalid plugin release information.');
+        }
+
+        if ($this->releaseVersion($release) === '' || $this->releasePackage($release) === null) {
+            return new \WP_Error(
+                'mahak_update_asset_missing',
+                'The latest GitHub release does not contain a valid mahak-authenticate-bridge.zip package.'
+            );
+        }
+
+        set_site_transient(self::RELEASE_CACHE, $release, 6 * HOUR_IN_SECONDS);
+
+        return $release;
+    }
+
+    private function releaseVersion(array $release): string
+    {
+        return ltrim((string) ($release['tag_name'] ?? ''), 'vV');
+    }
+
+    private function releasePackage(array $release): ?string
+    {
+        foreach (($release['assets'] ?? []) as $asset) {
+            if (($asset['name'] ?? '') !== self::RELEASE_ASSET) {
+                continue;
+            }
+
+            $url = esc_url_raw((string) ($asset['browser_download_url'] ?? ''));
+
+            $path = (string) wp_parse_url($url, PHP_URL_PATH);
+
+            if (
+                $url !== ''
+                && wp_parse_url($url, PHP_URL_SCHEME) === 'https'
+                && wp_parse_url($url, PHP_URL_HOST) === 'github.com'
+                && strpos($path, '/dabestaniha/mahak-authenticate-bridge/releases/download/') === 0
+            ) {
+                return $url;
+            }
+        }
+
+        return null;
+    }
+}

src/configs/mahak.php

@@ -11,9 +11,11 @@ return [
         'user-identifier' => 'mahak_user_identifier',
         'login-route' => 'mahak_login_route',
         'after-login-route' => 'mahak_after_login_route',
+        'debug-mode' => 'mahak_debug_mode',
     ],
 
     'user-identifiers' => [
+        'login',
         'mobile',
         'email',
         'username',
@@ -23,6 +25,7 @@ return [
     'after_login_route_default' => 'dashboard',
 
     'translations' => [
+        'login' => 'ورود',
         'mobile' => 'تلفن همراه',
         'email' => 'ایمیل',
         'username' => 'نام کاربری',
@@ -35,6 +38,8 @@ return [
         'user-identifier' => 'فیلد شناسایی کاربر',
         'login-route' => 'مسیر لاگین ماهک',
         'after-login-route' => 'مسیر بعد از لاگین',
+        'debug-mode' => 'حالت اشکال‌زدایی',
+        'debug-mode-description' => 'در صورت بروز خطا، جزئیات کامل فنی در صفحه نمایش داده شود. این گزینه را فقط هنگام عیب‌یابی فعال کنید.',
 
         'new-user' => 'کاربر جدید',
     ],

src/helpers.php

@@ -1,15 +1,41 @@
 <?php
 
 if (!function_exists('view')) {
-    function view(string $view)
+    function view(string $view, array $data = []): string
     {
         $basedir = plugin_dir_path(__FILE__);
+        extract($data, EXTR_SKIP);
+        ob_start();
         include "{$basedir}resources/views/$view.php";
+
+        return ob_get_clean();
+    }
+}
+
+if (!function_exists('mahak_debug_enabled')) {
+    function mahak_debug_enabled(): bool
+    {
+        return (bool) get_configured_option('debug-mode', false);
+    }
+}
+
+if (!function_exists('mahak_render_error')) {
+    function mahak_render_error(\Throwable $exception, int $status = 500, string $fallbackView = 'server-error'): void
+    {
+        if (mahak_debug_enabled()) {
+            wp_die(
+                view('debug-error', ['exception' => $exception]),
+                'Mahak Authentication Error',
+                ['response' => $status]
+            );
+        }
+
+        wp_die(view($fallbackView), 'Authentication Error', ['response' => $status]);
     }
 }
 
 if (!function_exists('dd')) {
-    function dd(): never
+    function dd(): void
     {
         echo '<pre>';
         array_map(function ($arg) {
@@ -32,7 +58,7 @@ function setup_configs(): void
 setup_configs();
 
 if (!function_exists('config')) {
-    function config(string $key, ?string $default = null): null|string|array
+    function config(string $key, ?string $default = null)
     {
         $value = MAHAK_CASHED_CONFIG;
         foreach (explode('.', $key) as $key) {
@@ -44,7 +70,7 @@ if (!function_exists('config')) {
 
 
 if (!function_exists('get_configured_option')) {
-    function get_configured_option(string $key, ?string $default = null): null|string|array
+    function get_configured_option(string $key, ?string $default = null)
     {
         return get_option(config("mahak.options.$key"), $default);
     }

src/resources/views/debug-error.php

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Mahak Authentication Error</title>
+    <style>
+        body { margin: 2rem; color: #1d2327; background: #f0f0f1; font: 14px/1.5 monospace; }
+        main { max-width: 1100px; margin: auto; padding: 2rem; background: #fff; border-left: 4px solid #d63638; box-shadow: 0 1px 3px rgba(0, 0, 0, .12); }
+        h1 { margin-top: 0; color: #d63638; font: 24px/1.3 sans-serif; }
+        dt { margin-top: 1rem; font-weight: 700; }
+        dd { margin: .25rem 0 0; overflow-wrap: anywhere; }
+        pre { overflow: auto; padding: 1rem; color: #f0f0f1; background: #1d2327; white-space: pre-wrap; }
+    </style>
+</head>
+<body>
+<main>
+    <h1>Mahak Authentication Error</h1>
+    <dl>
+        <dt>Exception</dt>
+        <dd><?= esc_html(get_class($exception)) ?></dd>
+        <dt>Message</dt>
+        <dd><?= esc_html($exception->getMessage()) ?></dd>
+        <dt>Location</dt>
+        <dd><?= esc_html($exception->getFile().':'.$exception->getLine()) ?></dd>
+    </dl>
+    <h2>Stack trace</h2>
+    <pre><?= esc_html($exception->getTraceAsString()) ?></pre>
+</main>
+</body>
+</html>

src/resources/views/server-error.php

@@ -1,5 +1,5 @@
 
-<!-- views/invalid-token.php -->
+<!-- views/server-error.php -->
 <!DOCTYPE html>
 <html>
 <head>

test/README.md

@@ -0,0 +1,39 @@
+# Authentication Integration Test
+
+This test starts a fresh WordPress site with PHP 7.4, installs and configures this plugin, then verifies JWT login through the real HTTP route.
+
+Run from the project root:
+
+```bash
+bash test/run-authentication-test.sh
+```
+
+If Docker requires root on your machine:
+
+```bash
+sudo bash test/run-authentication-test.sh
+```
+
+The test resets its Docker volumes on every run. Set `KEEP_TEST_ENV=1` to leave WordPress running after the test:
+
+```bash
+KEEP_TEST_ENV=1 bash test/run-authentication-test.sh
+```
+
+Use another host port if `8080` is busy:
+
+```bash
+WORDPRESS_PORT=8081 bash test/run-authentication-test.sh
+```
+
+The test covers:
+
+- PHP 7.4 syntax checks for all project PHP files
+- fresh WordPress database installation
+- plugin activation without unexpected output
+- plugin option configuration
+- valid HS256 JWT login
+- created WordPress user lookup
+- WordPress auth cookie issuance
+- follow-up authenticated admin request
+- invalid/tampered JWT rejection

test/docker-compose.yml

@@ -0,0 +1,36 @@
+services:
+  db:
+    image: mariadb:10.6
+    environment:
+      MARIADB_DATABASE: wordpress
+      MARIADB_USER: wordpress
+      MARIADB_PASSWORD: wordpress
+      MARIADB_ROOT_PASSWORD: root
+    healthcheck:
+      test: ["CMD-SHELL", "mysqladmin ping -h 127.0.0.1 -uroot -p$${MARIADB_ROOT_PASSWORD} --silent"]
+      interval: 5s
+      timeout: 5s
+      retries: 30
+
+  wordpress:
+    image: wordpress:php7.4-apache
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      WORDPRESS_DB_HOST: db:3306
+      WORDPRESS_DB_NAME: wordpress
+      WORDPRESS_DB_USER: wordpress
+      WORDPRESS_DB_PASSWORD: wordpress
+      WORDPRESS_DEBUG: "1"
+      WORDPRESS_CONFIG_EXTRA: |
+        define('WP_DEBUG_LOG', true);
+        define('WP_DEBUG_DISPLAY', false);
+    ports:
+      - "${WORDPRESS_PORT:-8080}:80"
+    volumes:
+      - wordpress_data:/var/www/html
+      - ..:/var/www/html/wp-content/plugins/mahak-authenticate-bridge:ro
+
+volumes:
+  wordpress_data:

test/integration-authentication.php

@@ -0,0 +1,334 @@
+<?php
+
+declare(strict_types=1);
+
+const TEST_SITE_URL = 'http://127.0.0.1';
+const TEST_PLUGIN = 'mahak-authenticate-bridge/dabestaniha-authenticate-bridge.php';
+const TEST_SECRET = 'integration-test-secret';
+const TEST_EMAIL = 'mahak-auth-user@example.test';
+const TEST_NAME = 'Mahak Auth User';
+
+function fail(string $message): void
+{
+    fwrite(STDERR, "[FAIL] $message\n");
+    exit(1);
+}
+
+function pass(string $message): void
+{
+    echo "[OK] $message\n";
+}
+
+function assert_true(bool $condition, string $message): void
+{
+    if (!$condition) {
+        fail($message);
+    }
+}
+
+function boot_wordpress(): void
+{
+    $wpLoad = '/var/www/html/wp-load.php';
+
+    if (!is_file($wpLoad)) {
+        fail("WordPress bootstrap file was not found at $wpLoad.");
+    }
+
+    if (!defined('WP_INSTALLING')) {
+        define('WP_INSTALLING', true);
+    }
+
+    ob_start();
+    require_once $wpLoad;
+    ob_end_clean();
+}
+
+function install_wordpress(): void
+{
+    require_once ABSPATH.'wp-admin/includes/upgrade.php';
+
+    if (!is_blog_installed()) {
+        wp_install(
+            'Mahak Authenticate Bridge Test',
+            'admin',
+            'admin@example.test',
+            true,
+            '',
+            'admin-password'
+        );
+    }
+
+    update_option('siteurl', TEST_SITE_URL);
+    update_option('home', TEST_SITE_URL);
+
+    pass('Fresh WordPress database installed');
+}
+
+function activate_and_configure_plugin(): void
+{
+    require_once ABSPATH.'wp-admin/includes/plugin.php';
+
+    if (!is_plugin_active(TEST_PLUGIN)) {
+        ob_start();
+        $result = activate_plugin(TEST_PLUGIN);
+        $activationOutput = trim((string) ob_get_clean());
+
+        if (is_wp_error($result)) {
+            fail('Plugin activation failed: '.$result->get_error_message());
+        }
+
+        assert_true($activationOutput === '', 'Plugin activation produced unexpected output: '.$activationOutput);
+    }
+
+    assert_true(is_plugin_active(TEST_PLUGIN), 'Plugin was not activated.');
+
+    update_option('mahak_jwt_secret', TEST_SECRET);
+    update_option('mahak_user_identifier', 'email');
+    update_option('mahak_login_route', 'mahak/login');
+    update_option('mahak_after_login_route', 'wp-admin/profile.php');
+
+    pass('Plugin activated and configured');
+}
+
+function base64_url_encode(string $value): string
+{
+    return rtrim(strtr(base64_encode($value), '+/', '-_'), '=');
+}
+
+function make_jwt(array $payload, string $secret): string
+{
+    $header = base64_url_encode(json_encode(['typ' => 'JWT', 'alg' => 'HS256'], JSON_THROW_ON_ERROR));
+    $body = base64_url_encode(json_encode($payload, JSON_THROW_ON_ERROR));
+    $signature = base64_url_encode(hash_hmac('sha256', $header.'.'.$body, $secret, true));
+
+    return $header.'.'.$body.'.'.$signature;
+}
+
+function http_request(string $url, string $cookieHeader = ''): array
+{
+    $headers = "Connection: close\r\n";
+
+    if ($cookieHeader !== '') {
+        $headers .= "Cookie: $cookieHeader\r\n";
+    }
+
+    $context = stream_context_create([
+        'http' => [
+            'ignore_errors' => true,
+            'timeout' => 20,
+            'follow_location' => 0,
+            'max_redirects' => 1,
+            'header' => $headers,
+        ],
+    ]);
+
+    $body = @file_get_contents($url, false, $context);
+    $responseHeaders = $http_response_header ?? [];
+    $status = 0;
+
+    if (isset($responseHeaders[0]) && preg_match('/^HTTP\/\S+\s+(\d+)/', $responseHeaders[0], $matches)) {
+        $status = (int) $matches[1];
+    }
+
+    return [
+        'status' => $status,
+        'headers' => $responseHeaders,
+        'body' => $body === false ? '' : $body,
+    ];
+}
+
+function wait_for_http(): void
+{
+    for ($attempt = 1; $attempt <= 60; $attempt++) {
+        $response = http_request(TEST_SITE_URL.'/wp-login.php');
+
+        if ($response['status'] > 0) {
+            pass('WordPress HTTP server is reachable');
+            return;
+        }
+
+        sleep(1);
+    }
+
+    fail('WordPress HTTP server did not become reachable.');
+}
+
+function header_contains(array $headers, string $needle): bool
+{
+    foreach ($headers as $header) {
+        if (stripos($header, $needle) !== false) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function cookie_header_from_response(array $headers): string
+{
+    $cookies = [];
+
+    foreach ($headers as $header) {
+        if (stripos($header, 'Set-Cookie:') !== 0) {
+            continue;
+        }
+
+        $cookie = trim(substr($header, strlen('Set-Cookie:')));
+        $cookiePair = explode(';', $cookie, 2)[0] ?? '';
+
+        if ($cookiePair !== '') {
+            $cookies[] = $cookiePair;
+        }
+    }
+
+    return implode('; ', $cookies);
+}
+
+function test_valid_authentication(): void
+{
+    $token = make_jwt([
+        'iat' => time() - 10,
+        'exp' => time() + 300,
+        'data' => [
+            'name' => TEST_NAME,
+            'email' => TEST_EMAIL,
+            'mobile' => '9123456789',
+            'username' => 'mahak-auth-user',
+        ],
+    ], TEST_SECRET);
+
+    $response = http_request(TEST_SITE_URL.'/mahak/login/?token='.rawurlencode($token));
+
+    assert_true($response['status'] === 302, 'Valid authentication request should return HTTP 302.');
+    assert_true(
+        header_contains($response['headers'], 'Set-Cookie: wordpress_logged_in_'),
+        'Valid authentication request did not issue a WordPress logged-in cookie.'
+    );
+    assert_true(
+        header_contains($response['headers'], 'Location: '.TEST_SITE_URL.'/wp-admin/profile.php'),
+        'Valid authentication request did not redirect to the configured route.'
+    );
+
+    $user = get_user_by('email', TEST_EMAIL);
+
+    assert_true($user !== false, 'Authenticated user was not created.');
+    assert_true($user->display_name === TEST_NAME, 'Authenticated user display name was not saved.');
+
+    $cookieHeader = cookie_header_from_response($response['headers']);
+    $profileResponse = http_request(TEST_SITE_URL.'/wp-admin/profile.php', $cookieHeader);
+
+    assert_true(
+        $profileResponse['status'] !== 302 || !header_contains($profileResponse['headers'], 'wp-login.php'),
+        'Issued cookies did not authenticate a follow-up WordPress admin request.'
+    );
+
+    pass('Valid JWT creates/logs in user and issued cookies authenticate follow-up request');
+}
+
+function test_invalid_authentication(): void
+{
+    $token = make_jwt([
+        'iat' => time() - 10,
+        'exp' => time() + 300,
+        'data' => [
+            'name' => 'Invalid User',
+            'email' => 'invalid-user@example.test',
+        ],
+    ], TEST_SECRET);
+
+    $response = http_request(TEST_SITE_URL.'/mahak/login/?token='.rawurlencode($token.'tampered'));
+
+    assert_true(
+        $response['status'] === 500,
+        'Invalid authentication request should return HTTP 500. Got HTTP '.$response['status'].' with body: '.substr($response['body'], 0, 200)
+    );
+    assert_true(
+        !header_contains($response['headers'], 'Set-Cookie: wordpress_logged_in_'),
+        'Invalid authentication request issued a logged-in cookie.'
+    );
+    assert_true(
+        strpos($response['body'], 'JWT signature is invalid.') === false,
+        'Debug details were exposed while debug mode was disabled.'
+    );
+
+    pass('Invalid JWT is rejected without login cookies or debug details');
+}
+
+function test_debug_error_details(): void
+{
+    update_option('mahak_debug_mode', 1);
+
+    $response = http_request(TEST_SITE_URL.'/mahak/login/?token=not-a-jwt');
+
+    assert_true($response['status'] === 500, 'Debug error response should return HTTP 500.');
+    assert_true(
+        strpos($response['body'], 'JWT must contain header, payload, and signature.') !== false,
+        'Debug response did not contain the underlying exception message.'
+    );
+    assert_true(
+        strpos($response['body'], 'UnexpectedValueException') !== false,
+        'Debug response did not contain the exception class.'
+    );
+    assert_true(
+        strpos($response['body'], 'Stack trace') !== false,
+        'Debug response did not contain a stack trace.'
+    );
+
+    update_option('mahak_debug_mode', 0);
+    pass('Debug mode displays full exception details and stack trace');
+}
+
+function test_plugin_update_discovery(): void
+{
+    $packageUrl = 'https://github.com/dabestaniha/mahak-authenticate-bridge/releases/download/v2.3.0/mahak-authenticate-bridge.zip';
+    $mockRelease = function ($response, array $request, string $url) use ($packageUrl) {
+        if ($url !== 'https://api.github.com/repos/dabestaniha/mahak-authenticate-bridge/releases/latest') {
+            return $response;
+        }
+
+        return [
+            'headers' => [],
+            'body' => json_encode([
+                'tag_name' => 'v2.3.0',
+                'html_url' => 'https://github.com/dabestaniha/mahak-authenticate-bridge/releases/tag/v2.3.0',
+                'body' => 'Test release',
+                'draft' => false,
+                'prerelease' => false,
+                'assets' => [[
+                    'name' => 'mahak-authenticate-bridge.zip',
+                    'browser_download_url' => $packageUrl,
+                ]],
+            ], JSON_THROW_ON_ERROR),
+            'response' => ['code' => 200, 'message' => 'OK'],
+            'cookies' => [],
+            'filename' => null,
+        ];
+    };
+
+    delete_site_transient('mahak_authenticate_bridge_release');
+    add_filter('pre_http_request', $mockRelease, 10, 3);
+
+    $updates = apply_filters('pre_set_site_transient_update_plugins', (object) [
+        'checked' => [TEST_PLUGIN => MAHAK_AUTHENTICATE_BRIDGE_VERSION],
+        'response' => [],
+    ]);
+
+    remove_filter('pre_http_request', $mockRelease, 10);
+
+    assert_true(isset($updates->response[TEST_PLUGIN]), 'A newer GitHub release was not offered as a WordPress update.');
+    assert_true($updates->response[TEST_PLUGIN]->new_version === '2.3.0', 'The offered plugin version was incorrect.');
+    assert_true($updates->response[TEST_PLUGIN]->package === $packageUrl, 'The release package URL was incorrect.');
+
+    pass('Published GitHub releases are discovered by the WordPress updater');
+}
+
+boot_wordpress();
+install_wordpress();
+activate_and_configure_plugin();
+wait_for_http();
+test_valid_authentication();
+test_invalid_authentication();
+test_debug_error_details();
+test_plugin_update_discovery();
+
+echo "[OK] Authentication integration test passed\n";

test/run-authentication-test.sh

@@ -0,0 +1,81 @@
+#!/usr/bin/env bash
+
+set -Eeuo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_NAME="${COMPOSE_PROJECT_NAME:-mahak-authenticate-bridge-test}"
+WORDPRESS_PORT="${WORDPRESS_PORT:-8080}"
+KEEP_TEST_ENV="${KEEP_TEST_ENV:-0}"
+
+if docker info >/dev/null 2>&1; then
+  DOCKER=(docker)
+elif command -v sudo >/dev/null 2>&1; then
+  DOCKER=(sudo docker)
+else
+  echo "Docker is not available." >&2
+  exit 1
+fi
+
+COMPOSE=("${DOCKER[@]}" compose)
+
+compose() {
+  WORDPRESS_PORT="$WORDPRESS_PORT" "${COMPOSE[@]}" \
+    -p "$PROJECT_NAME" \
+    -f "$SCRIPT_DIR/docker-compose.yml" \
+    "$@"
+}
+
+cleanup() {
+  if [[ "$KEEP_TEST_ENV" != "1" ]]; then
+    compose down --volumes --remove-orphans >/dev/null 2>&1 || true
+  fi
+}
+
+wait_for_wordpress_files() {
+  for _ in $(seq 1 90); do
+    if compose exec -T wordpress php -r 'exit(is_file("/var/www/html/wp-load.php") ? 0 : 1);' >/dev/null 2>&1; then
+      return 0
+    fi
+
+    sleep 1
+  done
+
+  echo "WordPress files were not ready in time." >&2
+  return 1
+}
+
+run_php_lint() {
+  compose exec -T wordpress sh -lc '
+    find /var/www/html/wp-content/plugins/mahak-authenticate-bridge \
+      -path "*/.git" -prune -o \
+      -name "*.php" -print \
+      | xargs -n1 php -l
+  '
+}
+
+trap cleanup EXIT
+
+echo "Resetting test containers and volumes..."
+compose down --volumes --remove-orphans
+
+echo "Pulling Docker images..."
+compose pull
+
+echo "Starting fresh WordPress on http://127.0.0.1:${WORDPRESS_PORT} ..."
+compose up -d
+
+echo "Waiting for WordPress files..."
+wait_for_wordpress_files
+
+echo "Running PHP 7.4 syntax checks..."
+run_php_lint
+
+echo "Running authentication integration test in PHP 7.4..."
+compose exec -T wordpress php /var/www/html/wp-content/plugins/mahak-authenticate-bridge/test/integration-authentication.php
+
+echo "Integration test passed."
+
+if [[ "$KEEP_TEST_ENV" == "1" ]]; then
+  echo "Test environment kept running. Clean it up with:"
+  echo "  ${COMPOSE[*]} -p $PROJECT_NAME -f $SCRIPT_DIR/docker-compose.yml down --volumes --remove-orphans"
+fi

vendor/autoload.php

@@ -1,22 +0,0 @@
-<?php
-
-// autoload.php @generated by Composer
-
-if (PHP_VERSION_ID < 50600) {
-    if (!headers_sent()) {
-        header('HTTP/1.1 500 Internal Server Error');
-    }
-    $err = 'Composer 2.3.0 dropped support for autoloading on PHP <5.6 and you are running '.PHP_VERSION.', please upgrade PHP or use Composer 2.2 LTS via "composer self-update --2.2". Aborting.'.PHP_EOL;
-    if (!ini_get('display_errors')) {
-        if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') {
-            fwrite(STDERR, $err);
-        } elseif (!headers_sent()) {
-            echo $err;
-        }
-    }
-    throw new RuntimeException($err);
-}
-
-require_once __DIR__ . '/composer/autoload_real.php';
-
-return ComposerAutoloaderInit1e84672d5963a78cf9ba3e25dc66cf6f::getLoader();

vendor/composer/ClassLoader.php

@@ -1,579 +0,0 @@
-<?php
-
-/*
- * This file is part of Composer.
- *
- * (c) Nils Adermann <naderman@naderman.de>
- *     Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Composer\Autoload;
-
-/**
- * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
- *
- *     $loader = new \Composer\Autoload\ClassLoader();
- *
- *     // register classes with namespaces
- *     $loader->add('Symfony\Component', __DIR__.'/component');
- *     $loader->add('Symfony',           __DIR__.'/framework');
- *
- *     // activate the autoloader
- *     $loader->register();
- *
- *     // to enable searching the include path (eg. for PEAR packages)
- *     $loader->setUseIncludePath(true);
- *
- * In this example, if you try to use a class in the Symfony\Component
- * namespace or one of its children (Symfony\Component\Console for instance),
- * the autoloader will first look for the class under the component/
- * directory, and it will then fallback to the framework/ directory if not
- * found before giving up.
- *
- * This class is loosely based on the Symfony UniversalClassLoader.
- *
- * @author Fabien Potencier <fabien@symfony.com>
- * @author Jordi Boggiano <j.boggiano@seld.be>
- * @see    https://www.php-fig.org/psr/psr-0/
- * @see    https://www.php-fig.org/psr/psr-4/
- */
-class ClassLoader
-{
-    /** @var \Closure(string):void */
-    private static $includeFile;
-
-    /** @var string|null */
-    private $vendorDir;
-
-    // PSR-4
-    /**
-     * @var array<string, array<string, int>>
-     */
-    private $prefixLengthsPsr4 = array();
-    /**
-     * @var array<string, list<string>>
-     */
-    private $prefixDirsPsr4 = array();
-    /**
-     * @var list<string>
-     */
-    private $fallbackDirsPsr4 = array();
-
-    // PSR-0
-    /**
-     * List of PSR-0 prefixes
-     *
-     * Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2')))
-     *
-     * @var array<string, array<string, list<string>>>
-     */
-    private $prefixesPsr0 = array();
-    /**
-     * @var list<string>
-     */
-    private $fallbackDirsPsr0 = array();
-
-    /** @var bool */
-    private $useIncludePath = false;
-
-    /**
-     * @var array<string, string>
-     */
-    private $classMap = array();
-
-    /** @var bool */
-    private $classMapAuthoritative = false;
-
-    /**
-     * @var array<string, bool>
-     */
-    private $missingClasses = array();
-
-    /** @var string|null */
-    private $apcuPrefix;
-
-    /**
-     * @var array<string, self>
-     */
-    private static $registeredLoaders = array();
-
-    /**
-     * @param string|null $vendorDir
-     */
-    public function __construct($vendorDir = null)
-    {
-        $this->vendorDir = $vendorDir;
-        self::initializeIncludeClosure();
-    }
-
-    /**
-     * @return array<string, list<string>>
-     */
-    public function getPrefixes()
-    {
-        if (!empty($this->prefixesPsr0)) {
-            return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
-        }
-
-        return array();
-    }
-
-    /**
-     * @return array<string, list<string>>
-     */
-    public function getPrefixesPsr4()
-    {
-        return $this->prefixDirsPsr4;
-    }
-
-    /**
-     * @return list<string>
-     */
-    public function getFallbackDirs()
-    {
-        return $this->fallbackDirsPsr0;
-    }
-
-    /**
-     * @return list<string>
-     */
-    public function getFallbackDirsPsr4()
-    {
-        return $this->fallbackDirsPsr4;
-    }
-
-    /**
-     * @return array<string, string> Array of classname => path
-     */
-    public function getClassMap()
-    {
-        return $this->classMap;
-    }
-
-    /**
-     * @param array<string, string> $classMap Class to filename map
-     *
-     * @return void
-     */
-    public function addClassMap(array $classMap)
-    {
-        if ($this->classMap) {
-            $this->classMap = array_merge($this->classMap, $classMap);
-        } else {
-            $this->classMap = $classMap;
-        }
-    }
-
-    /**
-     * Registers a set of PSR-0 directories for a given prefix, either
-     * appending or prepending to the ones previously set for this prefix.
-     *
-     * @param string              $prefix  The prefix
-     * @param list<string>|string $paths   The PSR-0 root directories
-     * @param bool                $prepend Whether to prepend the directories
-     *
-     * @return void
-     */
-    public function add($prefix, $paths, $prepend = false)
-    {
-        $paths = (array) $paths;
-        if (!$prefix) {
-            if ($prepend) {
-                $this->fallbackDirsPsr0 = array_merge(
-                    $paths,
-                    $this->fallbackDirsPsr0
-                );
-            } else {
-                $this->fallbackDirsPsr0 = array_merge(
-                    $this->fallbackDirsPsr0,
-                    $paths
-                );
-            }
-
-            return;
-        }
-
-        $first = $prefix[0];
-        if (!isset($this->prefixesPsr0[$first][$prefix])) {
-            $this->prefixesPsr0[$first][$prefix] = $paths;
-
-            return;
-        }
-        if ($prepend) {
-            $this->prefixesPsr0[$first][$prefix] = array_merge(
-                $paths,
-                $this->prefixesPsr0[$first][$prefix]
-            );
-        } else {
-            $this->prefixesPsr0[$first][$prefix] = array_merge(
-                $this->prefixesPsr0[$first][$prefix],
-                $paths
-            );
-        }
-    }
-
-    /**
-     * Registers a set of PSR-4 directories for a given namespace, either
-     * appending or prepending to the ones previously set for this namespace.
-     *
-     * @param string              $prefix  The prefix/namespace, with trailing '\\'
-     * @param list<string>|string $paths   The PSR-4 base directories
-     * @param bool                $prepend Whether to prepend the directories
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    public function addPsr4($prefix, $paths, $prepend = false)
-    {
-        $paths = (array) $paths;
-        if (!$prefix) {
-            // Register directories for the root namespace.
-            if ($prepend) {
-                $this->fallbackDirsPsr4 = array_merge(
-                    $paths,
-                    $this->fallbackDirsPsr4
-                );
-            } else {
-                $this->fallbackDirsPsr4 = array_merge(
-                    $this->fallbackDirsPsr4,
-                    $paths
-                );
-            }
-        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
-            // Register directories for a new namespace.
-            $length = strlen($prefix);
-            if ('\\' !== $prefix[$length - 1]) {
-                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
-            }
-            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
-            $this->prefixDirsPsr4[$prefix] = $paths;
-        } elseif ($prepend) {
-            // Prepend directories for an already registered namespace.
-            $this->prefixDirsPsr4[$prefix] = array_merge(
-                $paths,
-                $this->prefixDirsPsr4[$prefix]
-            );
-        } else {
-            // Append directories for an already registered namespace.
-            $this->prefixDirsPsr4[$prefix] = array_merge(
-                $this->prefixDirsPsr4[$prefix],
-                $paths
-            );
-        }
-    }
-
-    /**
-     * Registers a set of PSR-0 directories for a given prefix,
-     * replacing any others previously set for this prefix.
-     *
-     * @param string              $prefix The prefix
-     * @param list<string>|string $paths  The PSR-0 base directories
-     *
-     * @return void
-     */
-    public function set($prefix, $paths)
-    {
-        if (!$prefix) {
-            $this->fallbackDirsPsr0 = (array) $paths;
-        } else {
-            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
-        }
-    }
-
-    /**
-     * Registers a set of PSR-4 directories for a given namespace,
-     * replacing any others previously set for this namespace.
-     *
-     * @param string              $prefix The prefix/namespace, with trailing '\\'
-     * @param list<string>|string $paths  The PSR-4 base directories
-     *
-     * @throws \InvalidArgumentException
-     *
-     * @return void
-     */
-    public function setPsr4($prefix, $paths)
-    {
-        if (!$prefix) {
-            $this->fallbackDirsPsr4 = (array) $paths;
-        } else {
-            $length = strlen($prefix);
-            if ('\\' !== $prefix[$length - 1]) {
-                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
-            }
-            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
-            $this->prefixDirsPsr4[$prefix] = (array) $paths;
-        }
-    }
-
-    /**
-     * Turns on searching the include path for class files.
-     *
-     * @param bool $useIncludePath
-     *
-     * @return void
-     */
-    public function setUseIncludePath($useIncludePath)
-    {
-        $this->useIncludePath = $useIncludePath;
-    }
-
-    /**
-     * Can be used to check if the autoloader uses the include path to check
-     * for classes.
-     *
-     * @return bool
-     */
-    public function getUseIncludePath()
-    {
-        return $this->useIncludePath;
-    }
-
-    /**
-     * Turns off searching the prefix and fallback directories for classes
-     * that have not been registered with the class map.
-     *
-     * @param bool $classMapAuthoritative
-     *
-     * @return void
-     */
-    public function setClassMapAuthoritative($classMapAuthoritative)
-    {
-        $this->classMapAuthoritative = $classMapAuthoritative;
-    }
-
-    /**
-     * Should class lookup fail if not found in the current class map?
-     *
-     * @return bool
-     */
-    public function isClassMapAuthoritative()
-    {
-        return $this->classMapAuthoritative;
-    }
-
-    /**
-     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
-     *
-     * @param string|null $apcuPrefix
-     *
-     * @return void
-     */
-    public function setApcuPrefix($apcuPrefix)
-    {
-        $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
-    }
-
-    /**
-     * The APCu prefix in use, or null if APCu caching is not enabled.
-     *
-     * @return string|null
-     */
-    public function getApcuPrefix()
-    {
-        return $this->apcuPrefix;
-    }
-
-    /**
-     * Registers this instance as an autoloader.
-     *
-     * @param bool $prepend Whether to prepend the autoloader or not
-     *
-     * @return void
-     */
-    public function register($prepend = false)
-    {
-        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
-
-        if (null === $this->vendorDir) {
-            return;
-        }
-
-        if ($prepend) {
-            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
-        } else {
-            unset(self::$registeredLoaders[$this->vendorDir]);
-            self::$registeredLoaders[$this->vendorDir] = $this;
-        }
-    }
-
-    /**
-     * Unregisters this instance as an autoloader.
-     *
-     * @return void
-     */
-    public function unregister()
-    {
-        spl_autoload_unregister(array($this, 'loadClass'));
-
-        if (null !== $this->vendorDir) {
-            unset(self::$registeredLoaders[$this->vendorDir]);
-        }
-    }
-
-    /**
-     * Loads the given class or interface.
-     *
-     * @param  string    $class The name of the class
-     * @return true|null True if loaded, null otherwise
-     */
-    public function loadClass($class)
-    {
-        if ($file = $this->findFile($class)) {
-            $includeFile = self::$includeFile;
-            $includeFile($file);
-
-            return true;
-        }
-
-        return null;
-    }
-
-    /**
-     * Finds the path to the file where the class is defined.
-     *
-     * @param string $class The name of the class
-     *
-     * @return string|false The path if found, false otherwise
-     */
-    public function findFile($class)
-    {
-        // class map lookup
-        if (isset($this->classMap[$class])) {
-            return $this->classMap[$class];
-        }
-        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
-            return false;
-        }
-        if (null !== $this->apcuPrefix) {
-            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
-            if ($hit) {
-                return $file;
-            }
-        }
-
-        $file = $this->findFileWithExtension($class, '.php');
-
-        // Search for Hack files if we are running on HHVM
-        if (false === $file && defined('HHVM_VERSION')) {
-            $file = $this->findFileWithExtension($class, '.hh');
-        }
-
-        if (null !== $this->apcuPrefix) {
-            apcu_add($this->apcuPrefix.$class, $file);
-        }
-
-        if (false === $file) {
-            // Remember that this class does not exist.
-            $this->missingClasses[$class] = true;
-        }
-
-        return $file;
-    }
-
-    /**
-     * Returns the currently registered loaders keyed by their corresponding vendor directories.
-     *
-     * @return array<string, self>
-     */
-    public static function getRegisteredLoaders()
-    {
-        return self::$registeredLoaders;
-    }
-
-    /**
-     * @param  string       $class
-     * @param  string       $ext
-     * @return string|false
-     */
-    private function findFileWithExtension($class, $ext)
-    {
-        // PSR-4 lookup
-        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
-
-        $first = $class[0];
-        if (isset($this->prefixLengthsPsr4[$first])) {
-            $subPath = $class;
-            while (false !== $lastPos = strrpos($subPath, '\\')) {
-                $subPath = substr($subPath, 0, $lastPos);
-                $search = $subPath . '\\';
-                if (isset($this->prefixDirsPsr4[$search])) {
-                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
-                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
-                        if (file_exists($file = $dir . $pathEnd)) {
-                            return $file;
-                        }
-                    }
-                }
-            }
-        }
-
-        // PSR-4 fallback dirs
-        foreach ($this->fallbackDirsPsr4 as $dir) {
-            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
-                return $file;
-            }
-        }
-
-        // PSR-0 lookup
-        if (false !== $pos = strrpos($class, '\\')) {
-            // namespaced class name
-            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
-                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
-        } else {
-            // PEAR-like class name
-            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
-        }
-
-        if (isset($this->prefixesPsr0[$first])) {
-            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
-                if (0 === strpos($class, $prefix)) {
-                    foreach ($dirs as $dir) {
-                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
-                            return $file;
-                        }
-                    }
-                }
-            }
-        }
-
-        // PSR-0 fallback dirs
-        foreach ($this->fallbackDirsPsr0 as $dir) {
-            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
-                return $file;
-            }
-        }
-
-        // PSR-0 include paths.
-        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
-            return $file;
-        }
-
-        return false;
-    }
-
-    /**
-     * @return void
-     */
-    private static function initializeIncludeClosure()
-    {
-        if (self::$includeFile !== null) {
-            return;
-        }
-
-        /**
-         * Scope isolated include.
-         *
-         * Prevents access to $this/self from included files.
-         *
-         * @param  string $file
-         * @return void
-         */
-        self::$includeFile = \Closure::bind(static function($file) {
-            include $file;
-        }, null, null);
-    }
-}

vendor/composer/InstalledVersions.php

@@ -1,396 +0,0 @@
-<?php
-
-/*
- * This file is part of Composer.
- *
- * (c) Nils Adermann <naderman@naderman.de>
- *     Jordi Boggiano <j.boggiano@seld.be>
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-namespace Composer;
-
-use Composer\Autoload\ClassLoader;
-use Composer\Semver\VersionParser;
-
-/**
- * This class is copied in every Composer installed project and available to all
- *
- * See also https://getcomposer.org/doc/07-runtime.md#installed-versions
- *
- * To require its presence, you can require `composer-runtime-api ^2.0`
- *
- * @final
- */
-class InstalledVersions
-{
-    /**
-     * @var string|null if set (by reflection by Composer), this should be set to the path where this class is being copied to
-     * @internal
-     */
-    private static $selfDir = null;
-
-    /**
-     * @var mixed[]|null
-     * @psalm-var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}|array{}|null
-     */
-    private static $installed;
-
-    /**
-     * @var bool
-     */
-    private static $installedIsLocalDir;
-
-    /**
-     * @var bool|null
-     */
-    private static $canGetVendors;
-
-    /**
-     * @var array[]
-     * @psalm-var array<string, array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
-     */
-    private static $installedByVendor = array();
-
-    /**
-     * Returns a list of all package names which are present, either by being installed, replaced or provided
-     *
-     * @return string[]
-     * @psalm-return list<string>
-     */
-    public static function getInstalledPackages()
-    {
-        $packages = array();
-        foreach (self::getInstalled() as $installed) {
-            $packages[] = array_keys($installed['versions']);
-        }
-
-        if (1 === \count($packages)) {
-            return $packages[0];
-        }
-
-        return array_keys(array_flip(\call_user_func_array('array_merge', $packages)));
-    }
-
-    /**
-     * Returns a list of all package names with a specific type e.g. 'library'
-     *
-     * @param  string   $type
-     * @return string[]
-     * @psalm-return list<string>
-     */
-    public static function getInstalledPackagesByType($type)
-    {
-        $packagesByType = array();
-
-        foreach (self::getInstalled() as $installed) {
-            foreach ($installed['versions'] as $name => $package) {
-                if (isset($package['type']) && $package['type'] === $type) {
-                    $packagesByType[] = $name;
-                }
-            }
-        }
-
-        return $packagesByType;
-    }
-
-    /**
-     * Checks whether the given package is installed
-     *
-     * This also returns true if the package name is provided or replaced by another package
-     *
-     * @param  string $packageName
-     * @param  bool   $includeDevRequirements
-     * @return bool
-     */
-    public static function isInstalled($packageName, $includeDevRequirements = true)
-    {
-        foreach (self::getInstalled() as $installed) {
-            if (isset($installed['versions'][$packageName])) {
-                return $includeDevRequirements || !isset($installed['versions'][$packageName]['dev_requirement']) || $installed['versions'][$packageName]['dev_requirement'] === false;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Checks whether the given package satisfies a version constraint
-     *
-     * e.g. If you want to know whether version 2.3+ of package foo/bar is installed, you would call:
-     *
-     *   Composer\InstalledVersions::satisfies(new VersionParser, 'foo/bar', '^2.3')
-     *
-     * @param  VersionParser $parser      Install composer/semver to have access to this class and functionality
-     * @param  string        $packageName
-     * @param  string|null   $constraint  A version constraint to check for, if you pass one you have to make sure composer/semver is required by your package
-     * @return bool
-     */
-    public static function satisfies(VersionParser $parser, $packageName, $constraint)
-    {
-        $constraint = $parser->parseConstraints((string) $constraint);
-        $provided = $parser->parseConstraints(self::getVersionRanges($packageName));
-
-        return $provided->matches($constraint);
-    }
-
-    /**
-     * Returns a version constraint representing all the range(s) which are installed for a given package
-     *
-     * It is easier to use this via isInstalled() with the $constraint argument if you need to check
-     * whether a given version of a package is installed, and not just whether it exists
-     *
-     * @param  string $packageName
-     * @return string Version constraint usable with composer/semver
-     */
-    public static function getVersionRanges($packageName)
-    {
-        foreach (self::getInstalled() as $installed) {
-            if (!isset($installed['versions'][$packageName])) {
-                continue;
-            }
-
-            $ranges = array();
-            if (isset($installed['versions'][$packageName]['pretty_version'])) {
-                $ranges[] = $installed['versions'][$packageName]['pretty_version'];
-            }
-            if (array_key_exists('aliases', $installed['versions'][$packageName])) {
-                $ranges = array_merge($ranges, $installed['versions'][$packageName]['aliases']);
-            }
-            if (array_key_exists('replaced', $installed['versions'][$packageName])) {
-                $ranges = array_merge($ranges, $installed['versions'][$packageName]['replaced']);
-            }
-            if (array_key_exists('provided', $installed['versions'][$packageName])) {
-                $ranges = array_merge($ranges, $installed['versions'][$packageName]['provided']);
-            }
-
-            return implode(' || ', $ranges);
-        }
-
-        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
-    }
-
-    /**
-     * @param  string      $packageName
-     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
-     */
-    public static function getVersion($packageName)
-    {
-        foreach (self::getInstalled() as $installed) {
-            if (!isset($installed['versions'][$packageName])) {
-                continue;
-            }
-
-            if (!isset($installed['versions'][$packageName]['version'])) {
-                return null;
-            }
-
-            return $installed['versions'][$packageName]['version'];
-        }
-
-        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
-    }
-
-    /**
-     * @param  string      $packageName
-     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
-     */
-    public static function getPrettyVersion($packageName)
-    {
-        foreach (self::getInstalled() as $installed) {
-            if (!isset($installed['versions'][$packageName])) {
-                continue;
-            }
-
-            if (!isset($installed['versions'][$packageName]['pretty_version'])) {
-                return null;
-            }
-
-            return $installed['versions'][$packageName]['pretty_version'];
-        }
-
-        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
-    }
-
-    /**
-     * @param  string      $packageName
-     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as reference
-     */
-    public static function getReference($packageName)
-    {
-        foreach (self::getInstalled() as $installed) {
-            if (!isset($installed['versions'][$packageName])) {
-                continue;
-            }
-
-            if (!isset($installed['versions'][$packageName]['reference'])) {
-                return null;
-            }
-
-            return $installed['versions'][$packageName]['reference'];
-        }
-
-        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
-    }
-
-    /**
-     * @param  string      $packageName
-     * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as install path. Packages of type metapackages also have a null install path.
-     */
-    public static function getInstallPath($packageName)
-    {
-        foreach (self::getInstalled() as $installed) {
-            if (!isset($installed['versions'][$packageName])) {
-                continue;
-            }
-
-            return isset($installed['versions'][$packageName]['install_path']) ? $installed['versions'][$packageName]['install_path'] : null;
-        }
-
-        throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');
-    }
-
-    /**
-     * @return array
-     * @psalm-return array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}
-     */
-    public static function getRootPackage()
-    {
-        $installed = self::getInstalled();
-
-        return $installed[0]['root'];
-    }
-
-    /**
-     * Returns the raw installed.php data for custom implementations
-     *
-     * @deprecated Use getAllRawData() instead which returns all datasets for all autoloaders present in the process. getRawData only returns the first dataset loaded, which may not be what you expect.
-     * @return array[]
-     * @psalm-return array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}
-     */
-    public static function getRawData()
-    {
-        @trigger_error('getRawData only returns the first dataset loaded, which may not be what you expect. Use getAllRawData() instead which returns all datasets for all autoloaders present in the process.', E_USER_DEPRECATED);
-
-        if (null === self::$installed) {
-            // only require the installed.php file if this file is loaded from its dumped location,
-            // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
-            if (substr(__DIR__, -8, 1) !== 'C') {
-                self::$installed = include __DIR__ . '/installed.php';
-            } else {
-                self::$installed = array();
-            }
-        }
-
-        return self::$installed;
-    }
-
-    /**
-     * Returns the raw data of all installed.php which are currently loaded for custom implementations
-     *
-     * @return array[]
-     * @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
-     */
-    public static function getAllRawData()
-    {
-        return self::getInstalled();
-    }
-
-    /**
-     * Lets you reload the static array from another file
-     *
-     * This is only useful for complex integrations in which a project needs to use
-     * this class but then also needs to execute another project's autoloader in process,
-     * and wants to ensure both projects have access to their version of installed.php.
-     *
-     * A typical case would be PHPUnit, where it would need to make sure it reads all
-     * the data it needs from this class, then call reload() with
-     * `require $CWD/vendor/composer/installed.php` (or similar) as input to make sure
-     * the project in which it runs can then also use this class safely, without
-     * interference between PHPUnit's dependencies and the project's dependencies.
-     *
-     * @param  array[] $data A vendor/composer/installed.php data set
-     * @return void
-     *
-     * @psalm-param array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $data
-     */
-    public static function reload($data)
-    {
-        self::$installed = $data;
-        self::$installedByVendor = array();
-
-        // when using reload, we disable the duplicate protection to ensure that self::$installed data is
-        // always returned, but we cannot know whether it comes from the installed.php in __DIR__ or not,
-        // so we have to assume it does not, and that may result in duplicate data being returned when listing
-        // all installed packages for example
-        self::$installedIsLocalDir = false;
-    }
-
-    /**
-     * @return string
-     */
-    private static function getSelfDir()
-    {
-        if (self::$selfDir === null) {
-            self::$selfDir = strtr(__DIR__, '\\', '/');
-        }
-
-        return self::$selfDir;
-    }
-
-    /**
-     * @return array[]
-     * @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
-     */
-    private static function getInstalled()
-    {
-        if (null === self::$canGetVendors) {
-            self::$canGetVendors = method_exists('Composer\Autoload\ClassLoader', 'getRegisteredLoaders');
-        }
-
-        $installed = array();
-        $copiedLocalDir = false;
-
-        if (self::$canGetVendors) {
-            $selfDir = self::getSelfDir();
-            foreach (ClassLoader::getRegisteredLoaders() as $vendorDir => $loader) {
-                $vendorDir = strtr($vendorDir, '\\', '/');
-                if (isset(self::$installedByVendor[$vendorDir])) {
-                    $installed[] = self::$installedByVendor[$vendorDir];
-                } elseif (is_file($vendorDir.'/composer/installed.php')) {
-                    /** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $required */
-                    $required = require $vendorDir.'/composer/installed.php';
-                    self::$installedByVendor[$vendorDir] = $required;
-                    $installed[] = $required;
-                    if (self::$installed === null && $vendorDir.'/composer' === $selfDir) {
-                        self::$installed = $required;
-                        self::$installedIsLocalDir = true;
-                    }
-                }
-                if (self::$installedIsLocalDir && $vendorDir.'/composer' === $selfDir) {
-                    $copiedLocalDir = true;
-                }
-            }
-        }
-
-        if (null === self::$installed) {
-            // only require the installed.php file if this file is loaded from its dumped location,
-            // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
-            if (substr(__DIR__, -8, 1) !== 'C') {
-                /** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $required */
-                $required = require __DIR__ . '/installed.php';
-                self::$installed = $required;
-            } else {
-                self::$installed = array();
-            }
-        }
-
-        if (self::$installed !== array() && !$copiedLocalDir) {
-            $installed[] = self::$installed;
-        }
-
-        return $installed;
-    }
-}

vendor/composer/LICENSE

@@ -1,21 +0,0 @@
-
-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.
-

vendor/composer/autoload_classmap.php

@@ -1,10 +0,0 @@
-<?php
-
-// autoload_classmap.php @generated by Composer
-
-$vendorDir = dirname(__DIR__);
-$baseDir = dirname($vendorDir);
-
-return array(
-    'Composer\\InstalledVersions' => $vendorDir . '/composer/InstalledVersions.php',
-);

vendor/composer/autoload_files.php

@@ -1,10 +0,0 @@
-<?php
-
-// autoload_files.php @generated by Composer
-
-$vendorDir = dirname(__DIR__);
-$baseDir = dirname($vendorDir);
-
-return array(
-    'd0629c9e69b7d023623cf02e243b4e2a' => $baseDir . '/src/helpers.php',
-);

vendor/composer/autoload_namespaces.php

@@ -1,9 +0,0 @@
-<?php
-
-// autoload_namespaces.php @generated by Composer
-
-$vendorDir = dirname(__DIR__);
-$baseDir = dirname($vendorDir);
-
-return array(
-);

vendor/composer/autoload_psr4.php

@@ -1,12 +0,0 @@
-<?php
-
-// autoload_psr4.php @generated by Composer
-
-$vendorDir = dirname(__DIR__);
-$baseDir = dirname($vendorDir);
-
-return array(
-    'Firebase\\JWT\\' => array($vendorDir . '/firebase/php-jwt/src'),
-    'Dabestaniha\\AuthenticateBridge\\App\\' => array($baseDir . '/src/app'),
-    'Dabestaniha\\AuthenticateBridge\\' => array($baseDir . '/src'),
-);

vendor/composer/autoload_real.php

@@ -1,50 +0,0 @@
-<?php
-
-// autoload_real.php @generated by Composer
-
-class ComposerAutoloaderInit1e84672d5963a78cf9ba3e25dc66cf6f
-{
-    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;
-        }
-
-        require __DIR__ . '/platform_check.php';
-
-        spl_autoload_register(array('ComposerAutoloaderInit1e84672d5963a78cf9ba3e25dc66cf6f', 'loadClassLoader'), true, true);
-        self::$loader = $loader = new \Composer\Autoload\ClassLoader(\dirname(__DIR__));
-        spl_autoload_unregister(array('ComposerAutoloaderInit1e84672d5963a78cf9ba3e25dc66cf6f', 'loadClassLoader'));
-
-        require __DIR__ . '/autoload_static.php';
-        call_user_func(\Composer\Autoload\ComposerStaticInit1e84672d5963a78cf9ba3e25dc66cf6f::getInitializer($loader));
-
-        $loader->register(true);
-
-        $filesToLoad = \Composer\Autoload\ComposerStaticInit1e84672d5963a78cf9ba3e25dc66cf6f::$files;
-        $requireFile = \Closure::bind(static function ($fileIdentifier, $file) {
-            if (empty($GLOBALS['__composer_autoload_files'][$fileIdentifier])) {
-                $GLOBALS['__composer_autoload_files'][$fileIdentifier] = true;
-
-                require $file;
-            }
-        }, null, null);
-        foreach ($filesToLoad as $fileIdentifier => $file) {
-            $requireFile($fileIdentifier, $file);
-        }
-
-        return $loader;
-    }
-}

vendor/composer/autoload_static.php

@@ -1,53 +0,0 @@
-<?php
-
-// autoload_static.php @generated by Composer
-
-namespace Composer\Autoload;
-
-class ComposerStaticInit1e84672d5963a78cf9ba3e25dc66cf6f
-{
-    public static $files = array (
-        'd0629c9e69b7d023623cf02e243b4e2a' => __DIR__ . '/../..' . '/src/helpers.php',
-    );
-
-    public static $prefixLengthsPsr4 = array (
-        'F' => 
-        array (
-            'Firebase\\JWT\\' => 13,
-        ),
-        'D' => 
-        array (
-            'Dabestaniha\\AuthenticateBridge\\App\\' => 35,
-            'Dabestaniha\\AuthenticateBridge\\' => 31,
-        ),
-    );
-
-    public static $prefixDirsPsr4 = array (
-        'Firebase\\JWT\\' => 
-        array (
-            0 => __DIR__ . '/..' . '/firebase/php-jwt/src',
-        ),
-        'Dabestaniha\\AuthenticateBridge\\App\\' => 
-        array (
-            0 => __DIR__ . '/../..' . '/src/app',
-        ),
-        'Dabestaniha\\AuthenticateBridge\\' => 
-        array (
-            0 => __DIR__ . '/../..' . '/src',
-        ),
-    );
-
-    public static $classMap = array (
-        'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php',
-    );
-
-    public static function getInitializer(ClassLoader $loader)
-    {
-        return \Closure::bind(function () use ($loader) {
-            $loader->prefixLengthsPsr4 = ComposerStaticInit1e84672d5963a78cf9ba3e25dc66cf6f::$prefixLengthsPsr4;
-            $loader->prefixDirsPsr4 = ComposerStaticInit1e84672d5963a78cf9ba3e25dc66cf6f::$prefixDirsPsr4;
-            $loader->classMap = ComposerStaticInit1e84672d5963a78cf9ba3e25dc66cf6f::$classMap;
-
-        }, null, ClassLoader::class);
-    }
-}

vendor/composer/installed.json

@@ -1,72 +0,0 @@
-{
-    "packages": [
-        {
-            "name": "firebase/php-jwt",
-            "version": "v6.11.1",
-            "version_normalized": "6.11.1.0",
-            "source": {
-                "type": "git",
-                "url": "https://github.com/firebase/php-jwt.git",
-                "reference": "d1e91ecf8c598d073d0995afa8cd5c75c6e19e66"
-            },
-            "dist": {
-                "type": "zip",
-                "url": "https://api.github.com/repos/firebase/php-jwt/zipball/d1e91ecf8c598d073d0995afa8cd5c75c6e19e66",
-                "reference": "d1e91ecf8c598d073d0995afa8cd5c75c6e19e66",
-                "shasum": ""
-            },
-            "require": {
-                "php": "^8.0"
-            },
-            "require-dev": {
-                "guzzlehttp/guzzle": "^7.4",
-                "phpspec/prophecy-phpunit": "^2.0",
-                "phpunit/phpunit": "^9.5",
-                "psr/cache": "^2.0||^3.0",
-                "psr/http-client": "^1.0",
-                "psr/http-factory": "^1.0"
-            },
-            "suggest": {
-                "ext-sodium": "Support EdDSA (Ed25519) signatures",
-                "paragonie/sodium_compat": "Support EdDSA (Ed25519) signatures when libsodium is not present"
-            },
-            "time": "2025-04-09T20:32:01+00:00",
-            "type": "library",
-            "installation-source": "dist",
-            "autoload": {
-                "psr-4": {
-                    "Firebase\\JWT\\": "src"
-                }
-            },
-            "notification-url": "https://packagist.org/downloads/",
-            "license": [
-                "BSD-3-Clause"
-            ],
-            "authors": [
-                {
-                    "name": "Neuman Vong",
-                    "email": "neuman+pear@twilio.com",
-                    "role": "Developer"
-                },
-                {
-                    "name": "Anant Narayanan",
-                    "email": "anant@php.net",
-                    "role": "Developer"
-                }
-            ],
-            "description": "A simple library to encode and decode JSON Web Tokens (JWT) in PHP. Should conform to the current spec.",
-            "homepage": "https://github.com/firebase/php-jwt",
-            "keywords": [
-                "jwt",
-                "php"
-            ],
-            "support": {
-                "issues": "https://github.com/firebase/php-jwt/issues",
-                "source": "https://github.com/firebase/php-jwt/tree/v6.11.1"
-            },
-            "install-path": "../firebase/php-jwt"
-        }
-    ],
-    "dev": true,
-    "dev-package-names": []
-}

vendor/composer/installed.php

@@ -1,32 +0,0 @@
-<?php return array(
-    'root' => array(
-        'name' => 'dabestaniha/authenticate-bridge',
-        'pretty_version' => 'dev-main',
-        'version' => 'dev-main',
-        'reference' => '89a7eed84730a7731c7c74cfba53878925b4ccbe',
-        'type' => 'library',
-        'install_path' => __DIR__ . '/../../',
-        'aliases' => array(),
-        'dev' => true,
-    ),
-    'versions' => array(
-        'dabestaniha/authenticate-bridge' => array(
-            'pretty_version' => 'dev-main',
-            'version' => 'dev-main',
-            'reference' => '89a7eed84730a7731c7c74cfba53878925b4ccbe',
-            'type' => 'library',
-            'install_path' => __DIR__ . '/../../',
-            'aliases' => array(),
-            'dev_requirement' => false,
-        ),
-        'firebase/php-jwt' => array(
-            'pretty_version' => 'v6.11.1',
-            'version' => '6.11.1.0',
-            'reference' => 'd1e91ecf8c598d073d0995afa8cd5c75c6e19e66',
-            'type' => 'library',
-            'install_path' => __DIR__ . '/../firebase/php-jwt',
-            'aliases' => array(),
-            'dev_requirement' => false,
-        ),
-    ),
-);

vendor/composer/platform_check.php

@@ -1,25 +0,0 @@
-<?php
-
-// platform_check.php @generated by Composer
-
-$issues = array();
-
-if (!(PHP_VERSION_ID >= 80200)) {
-    $issues[] = 'Your Composer dependencies require a PHP version ">= 8.2.0". 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;
-        }
-    }
-    throw new \RuntimeException(
-        'Composer detected issues in your platform: ' . implode(' ', $issues)
-    );
-}

vendor/firebase/php-jwt/CHANGELOG.md

@@ -1,205 +0,0 @@
-# Changelog
-
-## [6.11.1](https://github.com/firebase/php-jwt/compare/v6.11.0...v6.11.1) (2025-04-09)
-
-
-### Bug Fixes
-
-* update error text for consistency ([#528](https://github.com/firebase/php-jwt/issues/528)) ([c11113a](https://github.com/firebase/php-jwt/commit/c11113afa13265e016a669e75494b9203b8a7775))
-
-## [6.11.0](https://github.com/firebase/php-jwt/compare/v6.10.2...v6.11.0) (2025-01-23)
-
-
-### Features
-
-* support octet typed JWK ([#587](https://github.com/firebase/php-jwt/issues/587)) ([7cb8a26](https://github.com/firebase/php-jwt/commit/7cb8a265fa81edf2fa6ef8098f5bc5ae573c33ad))
-
-
-### Bug Fixes
-
-* refactor constructor Key to use PHP 8.0 syntax ([#577](https://github.com/firebase/php-jwt/issues/577)) ([29fa2ce](https://github.com/firebase/php-jwt/commit/29fa2ce9e0582cd397711eec1e80c05ce20fabca))
-
-## [6.10.2](https://github.com/firebase/php-jwt/compare/v6.10.1...v6.10.2) (2024-11-24)
-
-
-### Bug Fixes
-
-* Mitigate PHP8.4 deprecation warnings ([#570](https://github.com/firebase/php-jwt/issues/570)) ([76808fa](https://github.com/firebase/php-jwt/commit/76808fa227f3811aa5cdb3bf81233714b799a5b5))
-* support php 8.4 ([#583](https://github.com/firebase/php-jwt/issues/583)) ([e3d68b0](https://github.com/firebase/php-jwt/commit/e3d68b044421339443c74199edd020e03fb1887e))
-
-## [6.10.1](https://github.com/firebase/php-jwt/compare/v6.10.0...v6.10.1) (2024-05-18)
-
-
-### Bug Fixes
-
-* ensure ratelimit expiry is set every time ([#556](https://github.com/firebase/php-jwt/issues/556)) ([09cb208](https://github.com/firebase/php-jwt/commit/09cb2081c2c3bc0f61e2f2a5fbea5741f7498648))
-* ratelimit cache expiration ([#550](https://github.com/firebase/php-jwt/issues/550)) ([dda7250](https://github.com/firebase/php-jwt/commit/dda725033585ece30ff8cae8937320d7e9f18bae))
-
-## [6.10.0](https://github.com/firebase/php-jwt/compare/v6.9.0...v6.10.0) (2023-11-28)
-
-
-### Features
-
-* allow typ header override ([#546](https://github.com/firebase/php-jwt/issues/546)) ([79cb30b](https://github.com/firebase/php-jwt/commit/79cb30b729a22931b2fbd6b53f20629a83031ba9))
-
-## [6.9.0](https://github.com/firebase/php-jwt/compare/v6.8.1...v6.9.0) (2023-10-04)
-
-
-### Features
-
-* add payload to jwt exception ([#521](https://github.com/firebase/php-jwt/issues/521)) ([175edf9](https://github.com/firebase/php-jwt/commit/175edf958bb61922ec135b2333acf5622f2238a2))
-
-## [6.8.1](https://github.com/firebase/php-jwt/compare/v6.8.0...v6.8.1) (2023-07-14)
-
-
-### Bug Fixes
-
-* accept float claims but round down to ignore them ([#492](https://github.com/firebase/php-jwt/issues/492)) ([3936842](https://github.com/firebase/php-jwt/commit/39368423beeaacb3002afa7dcb75baebf204fe7e))
-* different BeforeValidException messages for nbf and iat ([#526](https://github.com/firebase/php-jwt/issues/526)) ([0a53cf2](https://github.com/firebase/php-jwt/commit/0a53cf2986e45c2bcbf1a269f313ebf56a154ee4))
-
-## [6.8.0](https://github.com/firebase/php-jwt/compare/v6.7.0...v6.8.0) (2023-06-14)
-
-
-### Features
-
-* add support for P-384 curve ([#515](https://github.com/firebase/php-jwt/issues/515)) ([5de4323](https://github.com/firebase/php-jwt/commit/5de4323f4baf4d70bca8663bd87682a69c656c3d))
-
-
-### Bug Fixes
-
-* handle invalid http responses ([#508](https://github.com/firebase/php-jwt/issues/508)) ([91c39c7](https://github.com/firebase/php-jwt/commit/91c39c72b22fc3e1191e574089552c1f2041c718))
-
-## [6.7.0](https://github.com/firebase/php-jwt/compare/v6.6.0...v6.7.0) (2023-06-14)
-
-
-### Features
-
-* add ed25519 support to JWK (public keys) ([#452](https://github.com/firebase/php-jwt/issues/452)) ([e53979a](https://github.com/firebase/php-jwt/commit/e53979abae927de916a75b9d239cfda8ce32be2a))
-
-## [6.6.0](https://github.com/firebase/php-jwt/compare/v6.5.0...v6.6.0) (2023-06-13)
-
-
-### Features
-
-* allow get headers when decoding token ([#442](https://github.com/firebase/php-jwt/issues/442)) ([fb85f47](https://github.com/firebase/php-jwt/commit/fb85f47cfaeffdd94faf8defdf07164abcdad6c3))
-
-
-### Bug Fixes
-
-* only check iat if nbf is not used ([#493](https://github.com/firebase/php-jwt/issues/493)) ([398ccd2](https://github.com/firebase/php-jwt/commit/398ccd25ea12fa84b9e4f1085d5ff448c21ec797))
-
-## [6.5.0](https://github.com/firebase/php-jwt/compare/v6.4.0...v6.5.0) (2023-05-12)
-
-
-### Bug Fixes
-
-* allow KID of '0' ([#505](https://github.com/firebase/php-jwt/issues/505)) ([9dc46a9](https://github.com/firebase/php-jwt/commit/9dc46a9c3e5801294249cfd2554c5363c9f9326a))
-
-
-### Miscellaneous Chores
-
-* drop support for PHP 7.3 ([#495](https://github.com/firebase/php-jwt/issues/495))
-
-## [6.4.0](https://github.com/firebase/php-jwt/compare/v6.3.2...v6.4.0) (2023-02-08)
-
-
-### Features
-
-* add support for W3C ES256K ([#462](https://github.com/firebase/php-jwt/issues/462)) ([213924f](https://github.com/firebase/php-jwt/commit/213924f51936291fbbca99158b11bd4ae56c2c95))
-* improve caching by only decoding jwks when necessary ([#486](https://github.com/firebase/php-jwt/issues/486)) ([78d3ed1](https://github.com/firebase/php-jwt/commit/78d3ed1073553f7d0bbffa6c2010009a0d483d5c))
-
-## [6.3.2](https://github.com/firebase/php-jwt/compare/v6.3.1...v6.3.2) (2022-11-01)
-
-
-### Bug Fixes
-
-* check kid before using as array index ([bad1b04](https://github.com/firebase/php-jwt/commit/bad1b040d0c736bbf86814c6b5ae614f517cf7bd))
-
-## [6.3.1](https://github.com/firebase/php-jwt/compare/v6.3.0...v6.3.1) (2022-11-01)
-
-
-### Bug Fixes
-
-* casing of GET for PSR compat ([#451](https://github.com/firebase/php-jwt/issues/451)) ([60b52b7](https://github.com/firebase/php-jwt/commit/60b52b71978790eafcf3b95cfbd83db0439e8d22))
-* string interpolation format for php 8.2 ([#446](https://github.com/firebase/php-jwt/issues/446)) ([2e07d8a](https://github.com/firebase/php-jwt/commit/2e07d8a1524d12b69b110ad649f17461d068b8f2))
-
-## 6.3.0 / 2022-07-15
-
- - Added ES256 support to JWK parsing ([#399](https://github.com/firebase/php-jwt/pull/399))
- - Fixed potential caching error in `CachedKeySet` by caching jwks as strings ([#435](https://github.com/firebase/php-jwt/pull/435))
-
-## 6.2.0 / 2022-05-14
-
- - Added `CachedKeySet` ([#397](https://github.com/firebase/php-jwt/pull/397))
- - Added `$defaultAlg` parameter to `JWT::parseKey` and `JWT::parseKeySet` ([#426](https://github.com/firebase/php-jwt/pull/426)).
-
-## 6.1.0 / 2022-03-23
-
- - Drop support for PHP 5.3, 5.4, 5.5, 5.6, and 7.0
- - Add parameter typing and return types where possible
-
-## 6.0.0 / 2022-01-24
-
- - **Backwards-Compatibility Breaking Changes**: See the [Release Notes](https://github.com/firebase/php-jwt/releases/tag/v6.0.0) for more information.
- - New Key object to prevent key/algorithm type confusion (#365)
- - Add JWK support (#273)
- - Add ES256 support (#256)
- - Add ES384 support (#324)
- - Add Ed25519 support (#343)
-
-## 5.0.0 / 2017-06-26
-- Support RS384 and RS512.
-  See [#117](https://github.com/firebase/php-jwt/pull/117). Thanks [@joostfaassen](https://github.com/joostfaassen)!
-- Add an example for RS256 openssl.
-  See [#125](https://github.com/firebase/php-jwt/pull/125). Thanks [@akeeman](https://github.com/akeeman)!
-- Detect invalid Base64 encoding in signature.
-  See [#162](https://github.com/firebase/php-jwt/pull/162). Thanks [@psignoret](https://github.com/psignoret)!
-- Update `JWT::verify` to handle OpenSSL errors.
-  See [#159](https://github.com/firebase/php-jwt/pull/159). Thanks [@bshaffer](https://github.com/bshaffer)!
-- Add `array` type hinting to `decode` method
-  See [#101](https://github.com/firebase/php-jwt/pull/101). Thanks [@hywak](https://github.com/hywak)!
-- Add all JSON error types.
-  See [#110](https://github.com/firebase/php-jwt/pull/110). Thanks [@gbalduzzi](https://github.com/gbalduzzi)!
-- Bugfix 'kid' not in given key list.
-  See [#129](https://github.com/firebase/php-jwt/pull/129). Thanks [@stampycode](https://github.com/stampycode)!
-- Miscellaneous cleanup, documentation and test fixes.
-  See [#107](https://github.com/firebase/php-jwt/pull/107), [#115](https://github.com/firebase/php-jwt/pull/115),
-  [#160](https://github.com/firebase/php-jwt/pull/160), [#161](https://github.com/firebase/php-jwt/pull/161), and
-  [#165](https://github.com/firebase/php-jwt/pull/165). Thanks [@akeeman](https://github.com/akeeman),
-  [@chinedufn](https://github.com/chinedufn), and [@bshaffer](https://github.com/bshaffer)!
-
-## 4.0.0 / 2016-07-17
-- Add support for late static binding. See [#88](https://github.com/firebase/php-jwt/pull/88) for details. Thanks to [@chappy84](https://github.com/chappy84)!
-- Use static `$timestamp` instead of `time()` to improve unit testing. See [#93](https://github.com/firebase/php-jwt/pull/93) for details. Thanks to [@josephmcdermott](https://github.com/josephmcdermott)!
-- Fixes to exceptions classes. See [#81](https://github.com/firebase/php-jwt/pull/81) for details. Thanks to [@Maks3w](https://github.com/Maks3w)!
-- Fixes to PHPDoc. See [#76](https://github.com/firebase/php-jwt/pull/76) for details. Thanks to [@akeeman](https://github.com/akeeman)!
-
-## 3.0.0 / 2015-07-22
-- Minimum PHP version updated from `5.2.0` to `5.3.0`.
-- Add `\Firebase\JWT` namespace. See
-[#59](https://github.com/firebase/php-jwt/pull/59) for details. Thanks to
-[@Dashron](https://github.com/Dashron)!
-- Require a non-empty key to decode and verify a JWT. See
-[#60](https://github.com/firebase/php-jwt/pull/60) for details. Thanks to
-[@sjones608](https://github.com/sjones608)!
-- Cleaner documentation blocks in the code. See
-[#62](https://github.com/firebase/php-jwt/pull/62) for details. Thanks to
-[@johanderuijter](https://github.com/johanderuijter)!
-
-## 2.2.0 / 2015-06-22
-- Add support for adding custom, optional JWT headers to `JWT::encode()`. See
-[#53](https://github.com/firebase/php-jwt/pull/53/files) for details. Thanks to
-[@mcocaro](https://github.com/mcocaro)!
-
-## 2.1.0 / 2015-05-20
-- Add support for adding a leeway to `JWT:decode()` that accounts for clock skew
-between signing and verifying entities. Thanks to [@lcabral](https://github.com/lcabral)!
-- Add support for passing an object implementing the `ArrayAccess` interface for
-`$keys` argument in `JWT::decode()`. Thanks to [@aztech-dev](https://github.com/aztech-dev)!
-
-## 2.0.0 / 2015-04-01
-- **Note**: It is strongly recommended that you update to > v2.0.0 to address
-  known security vulnerabilities in prior versions when both symmetric and
-  asymmetric keys are used together.
-- Update signature for `JWT::decode(...)` to require an array of supported
-  algorithms to use when verifying token signatures.

vendor/firebase/php-jwt/LICENSE

@@ -1,30 +0,0 @@
-Copyright (c) 2011, Neuman Vong
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * Neither the name of the copyright holder nor the names of other
-      contributors may be used to endorse or promote products derived
-      from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/firebase/php-jwt/README.md

@@ -1,425 +0,0 @@
-![Build Status](https://github.com/firebase/php-jwt/actions/workflows/tests.yml/badge.svg)
-[![Latest Stable Version](https://poser.pugx.org/firebase/php-jwt/v/stable)](https://packagist.org/packages/firebase/php-jwt)
-[![Total Downloads](https://poser.pugx.org/firebase/php-jwt/downloads)](https://packagist.org/packages/firebase/php-jwt)
-[![License](https://poser.pugx.org/firebase/php-jwt/license)](https://packagist.org/packages/firebase/php-jwt)
-
-PHP-JWT
-=======
-A simple library to encode and decode JSON Web Tokens (JWT) in PHP, conforming to [RFC 7519](https://tools.ietf.org/html/rfc7519).
-
-Installation
-------------
-
-Use composer to manage your dependencies and download PHP-JWT:
-
-```bash
-composer require firebase/php-jwt
-```
-
-Optionally, install the `paragonie/sodium_compat` package from composer if your
-php env does not have libsodium installed:
-
-```bash
-composer require paragonie/sodium_compat
-```
-
-Example
--------
-```php
-use Firebase\JWT\JWT;
-use Firebase\JWT\Key;
-
-$key = 'example_key';
-$payload = [
-    'iss' => 'http://example.org',
-    'aud' => 'http://example.com',
-    'iat' => 1356999524,
-    'nbf' => 1357000000
-];
-
-/**
- * IMPORTANT:
- * You must specify supported algorithms for your application. See
- * https://tools.ietf.org/html/draft-ietf-jose-json-web-algorithms-40
- * for a list of spec-compliant algorithms.
- */
-$jwt = JWT::encode($payload, $key, 'HS256');
-$decoded = JWT::decode($jwt, new Key($key, 'HS256'));
-print_r($decoded);
-
-// Pass a stdClass in as the third parameter to get the decoded header values
-$headers = new stdClass();
-$decoded = JWT::decode($jwt, new Key($key, 'HS256'), $headers);
-print_r($headers);
-
-/*
- NOTE: This will now be an object instead of an associative array. To get
- an associative array, you will need to cast it as such:
-*/
-
-$decoded_array = (array) $decoded;
-
-/**
- * You can add a leeway to account for when there is a clock skew times between
- * the signing and verifying servers. It is recommended that this leeway should
- * not be bigger than a few minutes.
- *
- * Source: http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html#nbfDef
- */
-JWT::$leeway = 60; // $leeway in seconds
-$decoded = JWT::decode($jwt, new Key($key, 'HS256'));
-```
-Example encode/decode headers
--------
-Decoding the JWT headers without verifying the JWT first is NOT recommended, and is not supported by
-this library. This is because without verifying the JWT, the header values could have been tampered with.
-Any value pulled from an unverified header should be treated as if it could be any string sent in from an
-attacker.  If this is something you still want to do in your application for whatever reason, it's possible to
-decode the header values manually simply by calling `json_decode` and `base64_decode` on the JWT
-header part:
-```php
-use Firebase\JWT\JWT;
-
-$key = 'example_key';
-$payload = [
-    'iss' => 'http://example.org',
-    'aud' => 'http://example.com',
-    'iat' => 1356999524,
-    'nbf' => 1357000000
-];
-
-$headers = [
-    'x-forwarded-for' => 'www.google.com'
-];
-
-// Encode headers in the JWT string
-$jwt = JWT::encode($payload, $key, 'HS256', null, $headers);
-
-// Decode headers from the JWT string WITHOUT validation
-// **IMPORTANT**: This operation is vulnerable to attacks, as the JWT has not yet been verified.
-// These headers could be any value sent by an attacker.
-list($headersB64, $payloadB64, $sig) = explode('.', $jwt);
-$decoded = json_decode(base64_decode($headersB64), true);
-
-print_r($decoded);
-```
-Example with RS256 (openssl)
-----------------------------
-```php
-use Firebase\JWT\JWT;
-use Firebase\JWT\Key;
-
-$privateKey = <<<EOD
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAuzWHNM5f+amCjQztc5QTfJfzCC5J4nuW+L/aOxZ4f8J3Frew
-M2c/dufrnmedsApb0By7WhaHlcqCh/ScAPyJhzkPYLae7bTVro3hok0zDITR8F6S
-JGL42JAEUk+ILkPI+DONM0+3vzk6Kvfe548tu4czCuqU8BGVOlnp6IqBHhAswNMM
-78pos/2z0CjPM4tbeXqSTTbNkXRboxjU29vSopcT51koWOgiTf3C7nJUoMWZHZI5
-HqnIhPAG9yv8HAgNk6CMk2CadVHDo4IxjxTzTTqo1SCSH2pooJl9O8at6kkRYsrZ
-WwsKlOFE2LUce7ObnXsYihStBUDoeBQlGG/BwQIDAQABAoIBAFtGaOqNKGwggn9k
-6yzr6GhZ6Wt2rh1Xpq8XUz514UBhPxD7dFRLpbzCrLVpzY80LbmVGJ9+1pJozyWc
-VKeCeUdNwbqkr240Oe7GTFmGjDoxU+5/HX/SJYPpC8JZ9oqgEA87iz+WQX9hVoP2
-oF6EB4ckDvXmk8FMwVZW2l2/kd5mrEVbDaXKxhvUDf52iVD+sGIlTif7mBgR99/b
-c3qiCnxCMmfYUnT2eh7Vv2LhCR/G9S6C3R4lA71rEyiU3KgsGfg0d82/XWXbegJW
-h3QbWNtQLxTuIvLq5aAryV3PfaHlPgdgK0ft6ocU2de2FagFka3nfVEyC7IUsNTK
-bq6nhAECgYEA7d/0DPOIaItl/8BWKyCuAHMss47j0wlGbBSHdJIiS55akMvnAG0M
-39y22Qqfzh1at9kBFeYeFIIU82ZLF3xOcE3z6pJZ4Dyvx4BYdXH77odo9uVK9s1l
-3T3BlMcqd1hvZLMS7dviyH79jZo4CXSHiKzc7pQ2YfK5eKxKqONeXuECgYEAyXlG
-vonaus/YTb1IBei9HwaccnQ/1HRn6MvfDjb7JJDIBhNClGPt6xRlzBbSZ73c2QEC
-6Fu9h36K/HZ2qcLd2bXiNyhIV7b6tVKk+0Psoj0dL9EbhsD1OsmE1nTPyAc9XZbb
-OPYxy+dpBCUA8/1U9+uiFoCa7mIbWcSQ+39gHuECgYAz82pQfct30aH4JiBrkNqP
-nJfRq05UY70uk5k1u0ikLTRoVS/hJu/d4E1Kv4hBMqYCavFSwAwnvHUo51lVCr/y
-xQOVYlsgnwBg2MX4+GjmIkqpSVCC8D7j/73MaWb746OIYZervQ8dbKahi2HbpsiG
-8AHcVSA/agxZr38qvWV54QKBgCD5TlDE8x18AuTGQ9FjxAAd7uD0kbXNz2vUYg9L
-hFL5tyL3aAAtUrUUw4xhd9IuysRhW/53dU+FsG2dXdJu6CxHjlyEpUJl2iZu/j15
-YnMzGWHIEX8+eWRDsw/+Ujtko/B7TinGcWPz3cYl4EAOiCeDUyXnqnO1btCEUU44
-DJ1BAoGBAJuPD27ErTSVtId90+M4zFPNibFP50KprVdc8CR37BE7r8vuGgNYXmnI
-RLnGP9p3pVgFCktORuYS2J/6t84I3+A17nEoB4xvhTLeAinAW/uTQOUmNicOP4Ek
-2MsLL2kHgL8bLTmvXV4FX+PXphrDKg1XxzOYn0otuoqdAQrkK4og
------END RSA PRIVATE KEY-----
-EOD;
-
-$publicKey = <<<EOD
------BEGIN PUBLIC KEY-----
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzWHNM5f+amCjQztc5QT
-fJfzCC5J4nuW+L/aOxZ4f8J3FrewM2c/dufrnmedsApb0By7WhaHlcqCh/ScAPyJ
-hzkPYLae7bTVro3hok0zDITR8F6SJGL42JAEUk+ILkPI+DONM0+3vzk6Kvfe548t
-u4czCuqU8BGVOlnp6IqBHhAswNMM78pos/2z0CjPM4tbeXqSTTbNkXRboxjU29vS
-opcT51koWOgiTf3C7nJUoMWZHZI5HqnIhPAG9yv8HAgNk6CMk2CadVHDo4IxjxTz
-TTqo1SCSH2pooJl9O8at6kkRYsrZWwsKlOFE2LUce7ObnXsYihStBUDoeBQlGG/B
-wQIDAQAB
------END PUBLIC KEY-----
-EOD;
-
-$payload = [
-    'iss' => 'example.org',
-    'aud' => 'example.com',
-    'iat' => 1356999524,
-    'nbf' => 1357000000
-];
-
-$jwt = JWT::encode($payload, $privateKey, 'RS256');
-echo "Encode:\n" . print_r($jwt, true) . "\n";
-
-$decoded = JWT::decode($jwt, new Key($publicKey, 'RS256'));
-
-/*
- NOTE: This will now be an object instead of an associative array. To get
- an associative array, you will need to cast it as such:
-*/
-
-$decoded_array = (array) $decoded;
-echo "Decode:\n" . print_r($decoded_array, true) . "\n";
-```
-
-Example with a passphrase
--------------------------
-
-```php
-use Firebase\JWT\JWT;
-use Firebase\JWT\Key;
-
-// Your passphrase
-$passphrase = '[YOUR_PASSPHRASE]';
-
-// Your private key file with passphrase
-// Can be generated with "ssh-keygen -t rsa -m pem"
-$privateKeyFile = '/path/to/key-with-passphrase.pem';
-
-// Create a private key of type "resource"
-$privateKey = openssl_pkey_get_private(
-    file_get_contents($privateKeyFile),
-    $passphrase
-);
-
-$payload = [
-    'iss' => 'example.org',
-    'aud' => 'example.com',
-    'iat' => 1356999524,
-    'nbf' => 1357000000
-];
-
-$jwt = JWT::encode($payload, $privateKey, 'RS256');
-echo "Encode:\n" . print_r($jwt, true) . "\n";
-
-// Get public key from the private key, or pull from from a file.
-$publicKey = openssl_pkey_get_details($privateKey)['key'];
-
-$decoded = JWT::decode($jwt, new Key($publicKey, 'RS256'));
-echo "Decode:\n" . print_r((array) $decoded, true) . "\n";
-```
-
-Example with EdDSA (libsodium and Ed25519 signature)
-----------------------------
-```php
-use Firebase\JWT\JWT;
-use Firebase\JWT\Key;
-
-// Public and private keys are expected to be Base64 encoded. The last
-// non-empty line is used so that keys can be generated with
-// sodium_crypto_sign_keypair(). The secret keys generated by other tools may
-// need to be adjusted to match the input expected by libsodium.
-
-$keyPair = sodium_crypto_sign_keypair();
-
-$privateKey = base64_encode(sodium_crypto_sign_secretkey($keyPair));
-
-$publicKey = base64_encode(sodium_crypto_sign_publickey($keyPair));
-
-$payload = [
-    'iss' => 'example.org',
-    'aud' => 'example.com',
-    'iat' => 1356999524,
-    'nbf' => 1357000000
-];
-
-$jwt = JWT::encode($payload, $privateKey, 'EdDSA');
-echo "Encode:\n" . print_r($jwt, true) . "\n";
-
-$decoded = JWT::decode($jwt, new Key($publicKey, 'EdDSA'));
-echo "Decode:\n" . print_r((array) $decoded, true) . "\n";
-````
-
-Example with multiple keys
---------------------------
-```php
-use Firebase\JWT\JWT;
-use Firebase\JWT\Key;
-
-// Example RSA keys from previous example
-// $privateKey1 = '...';
-// $publicKey1 = '...';
-
-// Example EdDSA keys from previous example
-// $privateKey2 = '...';
-// $publicKey2 = '...';
-
-$payload = [
-    'iss' => 'example.org',
-    'aud' => 'example.com',
-    'iat' => 1356999524,
-    'nbf' => 1357000000
-];
-
-$jwt1 = JWT::encode($payload, $privateKey1, 'RS256', 'kid1');
-$jwt2 = JWT::encode($payload, $privateKey2, 'EdDSA', 'kid2');
-echo "Encode 1:\n" . print_r($jwt1, true) . "\n";
-echo "Encode 2:\n" . print_r($jwt2, true) . "\n";
-
-$keys = [
-    'kid1' => new Key($publicKey1, 'RS256'),
-    'kid2' => new Key($publicKey2, 'EdDSA'),
-];
-
-$decoded1 = JWT::decode($jwt1, $keys);
-$decoded2 = JWT::decode($jwt2, $keys);
-
-echo "Decode 1:\n" . print_r((array) $decoded1, true) . "\n";
-echo "Decode 2:\n" . print_r((array) $decoded2, true) . "\n";
-```
-
-Using JWKs
-----------
-
-```php
-use Firebase\JWT\JWK;
-use Firebase\JWT\JWT;
-
-// Set of keys. The "keys" key is required. For example, the JSON response to
-// this endpoint: https://www.gstatic.com/iap/verify/public_key-jwk
-$jwks = ['keys' => []];
-
-// JWK::parseKeySet($jwks) returns an associative array of **kid** to Firebase\JWT\Key
-// objects. Pass this as the second parameter to JWT::decode.
-JWT::decode($jwt, JWK::parseKeySet($jwks));
-```
-
-Using Cached Key Sets
----------------------
-
-The `CachedKeySet` class can be used to fetch and cache JWKS (JSON Web Key Sets) from a public URI.
-This has the following advantages:
-
-1. The results are cached for performance.
-2. If an unrecognized key is requested, the cache is refreshed, to accomodate for key rotation.
-3. If rate limiting is enabled, the JWKS URI will not make more than 10 requests a second.
-
-```php
-use Firebase\JWT\CachedKeySet;
-use Firebase\JWT\JWT;
-
-// The URI for the JWKS you wish to cache the results from
-$jwksUri = 'https://www.gstatic.com/iap/verify/public_key-jwk';
-
-// Create an HTTP client (can be any PSR-7 compatible HTTP client)
-$httpClient = new GuzzleHttp\Client();
-
-// Create an HTTP request factory (can be any PSR-17 compatible HTTP request factory)
-$httpFactory = new GuzzleHttp\Psr\HttpFactory();
-
-// Create a cache item pool (can be any PSR-6 compatible cache item pool)
-$cacheItemPool = Phpfastcache\CacheManager::getInstance('files');
-
-$keySet = new CachedKeySet(
-    $jwksUri,
-    $httpClient,
-    $httpFactory,
-    $cacheItemPool,
-    null, // $expiresAfter int seconds to set the JWKS to expire
-    true  // $rateLimit    true to enable rate limit of 10 RPS on lookup of invalid keys
-);
-
-$jwt = 'eyJhbGci...'; // Some JWT signed by a key from the $jwkUri above
-$decoded = JWT::decode($jwt, $keySet);
-```
-
-Miscellaneous
--------------
-
-#### Exception Handling
-
-When a call to `JWT::decode` is invalid, it will throw one of the following exceptions:
-
-```php
-use Firebase\JWT\JWT;
-use Firebase\JWT\SignatureInvalidException;
-use Firebase\JWT\BeforeValidException;
-use Firebase\JWT\ExpiredException;
-use DomainException;
-use InvalidArgumentException;
-use UnexpectedValueException;
-
-try {
-    $decoded = JWT::decode($jwt, $keys);
-} catch (InvalidArgumentException $e) {
-    // provided key/key-array is empty or malformed.
-} catch (DomainException $e) {
-    // provided algorithm is unsupported OR
-    // provided key is invalid OR
-    // unknown error thrown in openSSL or libsodium OR
-    // libsodium is required but not available.
-} catch (SignatureInvalidException $e) {
-    // provided JWT signature verification failed.
-} catch (BeforeValidException $e) {
-    // provided JWT is trying to be used before "nbf" claim OR
-    // provided JWT is trying to be used before "iat" claim.
-} catch (ExpiredException $e) {
-    // provided JWT is trying to be used after "exp" claim.
-} catch (UnexpectedValueException $e) {
-    // provided JWT is malformed OR
-    // provided JWT is missing an algorithm / using an unsupported algorithm OR
-    // provided JWT algorithm does not match provided key OR
-    // provided key ID in key/key-array is empty or invalid.
-}
-```
-
-All exceptions in the `Firebase\JWT` namespace extend `UnexpectedValueException`, and can be simplified
-like this:
-
-```php
-use Firebase\JWT\JWT;
-use UnexpectedValueException;
-try {
-    $decoded = JWT::decode($jwt, $keys);
-} catch (LogicException $e) {
-    // errors having to do with environmental setup or malformed JWT Keys
-} catch (UnexpectedValueException $e) {
-    // errors having to do with JWT signature and claims
-}
-```
-
-#### Casting to array
-
-The return value of `JWT::decode` is the generic PHP object `stdClass`. If you'd like to handle with arrays
-instead, you can do the following:
-
-```php
-// return type is stdClass
-$decoded = JWT::decode($jwt, $keys);
-
-// cast to array
-$decoded = json_decode(json_encode($decoded), true);
-```
-
-Tests
------
-Run the tests using phpunit:
-
-```bash
-$ pear install PHPUnit
-$ phpunit --configuration phpunit.xml.dist
-PHPUnit 3.7.10 by Sebastian Bergmann.
-.....
-Time: 0 seconds, Memory: 2.50Mb
-OK (5 tests, 5 assertions)
-```
-
-New Lines in private keys
------
-
-If your private key contains `\n` characters, be sure to wrap it in double quotes `""`
-and not single quotes `''` in order to properly interpret the escaped characters.
-
-License
--------
-[3-Clause BSD](http://opensource.org/licenses/BSD-3-Clause).

vendor/firebase/php-jwt/composer.json

@@ -1,42 +0,0 @@
-{
-    "name": "firebase/php-jwt",
-    "description": "A simple library to encode and decode JSON Web Tokens (JWT) in PHP. Should conform to the current spec.",
-    "homepage": "https://github.com/firebase/php-jwt",
-    "keywords": [
-        "php",
-        "jwt"
-    ],
-    "authors": [
-        {
-            "name": "Neuman Vong",
-            "email": "neuman+pear@twilio.com",
-            "role": "Developer"
-        },
-        {
-            "name": "Anant Narayanan",
-            "email": "anant@php.net",
-            "role": "Developer"
-        }
-    ],
-    "license": "BSD-3-Clause",
-    "require": {
-        "php": "^8.0"
-    },
-    "suggest": {
-        "paragonie/sodium_compat": "Support EdDSA (Ed25519) signatures when libsodium is not present",
-        "ext-sodium": "Support EdDSA (Ed25519) signatures"
-    },
-    "autoload": {
-        "psr-4": {
-            "Firebase\\JWT\\": "src"
-        }
-    },
-    "require-dev": {
-        "guzzlehttp/guzzle": "^7.4",
-        "phpspec/prophecy-phpunit": "^2.0",
-        "phpunit/phpunit": "^9.5",
-        "psr/cache": "^2.0||^3.0",
-        "psr/http-client": "^1.0",
-        "psr/http-factory": "^1.0"
-    }
-}

vendor/firebase/php-jwt/src/BeforeValidException.php

@@ -1,18 +0,0 @@
-<?php
-
-namespace Firebase\JWT;
-
-class BeforeValidException extends \UnexpectedValueException implements JWTExceptionWithPayloadInterface
-{
-    private object $payload;
-
-    public function setPayload(object $payload): void
-    {
-        $this->payload = $payload;
-    }
-
-    public function getPayload(): object
-    {
-        return $this->payload;
-    }
-}

vendor/firebase/php-jwt/src/CachedKeySet.php

@@ -1,274 +0,0 @@
-<?php
-
-namespace Firebase\JWT;
-
-use ArrayAccess;
-use InvalidArgumentException;
-use LogicException;
-use OutOfBoundsException;
-use Psr\Cache\CacheItemInterface;
-use Psr\Cache\CacheItemPoolInterface;
-use Psr\Http\Client\ClientInterface;
-use Psr\Http\Message\RequestFactoryInterface;
-use RuntimeException;
-use UnexpectedValueException;
-
-/**
- * @implements ArrayAccess<string, Key>
- */
-class CachedKeySet implements ArrayAccess
-{
-    /**
-     * @var string
-     */
-    private $jwksUri;
-    /**
-     * @var ClientInterface
-     */
-    private $httpClient;
-    /**
-     * @var RequestFactoryInterface
-     */
-    private $httpFactory;
-    /**
-     * @var CacheItemPoolInterface
-     */
-    private $cache;
-    /**
-     * @var ?int
-     */
-    private $expiresAfter;
-    /**
-     * @var ?CacheItemInterface
-     */
-    private $cacheItem;
-    /**
-     * @var array<string, array<mixed>>
-     */
-    private $keySet;
-    /**
-     * @var string
-     */
-    private $cacheKey;
-    /**
-     * @var string
-     */
-    private $cacheKeyPrefix = 'jwks';
-    /**
-     * @var int
-     */
-    private $maxKeyLength = 64;
-    /**
-     * @var bool
-     */
-    private $rateLimit;
-    /**
-     * @var string
-     */
-    private $rateLimitCacheKey;
-    /**
-     * @var int
-     */
-    private $maxCallsPerMinute = 10;
-    /**
-     * @var string|null
-     */
-    private $defaultAlg;
-
-    public function __construct(
-        string $jwksUri,
-        ClientInterface $httpClient,
-        RequestFactoryInterface $httpFactory,
-        CacheItemPoolInterface $cache,
-        ?int $expiresAfter = null,
-        bool $rateLimit = false,
-        ?string $defaultAlg = null
-    ) {
-        $this->jwksUri = $jwksUri;
-        $this->httpClient = $httpClient;
-        $this->httpFactory = $httpFactory;
-        $this->cache = $cache;
-        $this->expiresAfter = $expiresAfter;
-        $this->rateLimit = $rateLimit;
-        $this->defaultAlg = $defaultAlg;
-        $this->setCacheKeys();
-    }
-
-    /**
-     * @param string $keyId
-     * @return Key
-     */
-    public function offsetGet($keyId): Key
-    {
-        if (!$this->keyIdExists($keyId)) {
-            throw new OutOfBoundsException('Key ID not found');
-        }
-        return JWK::parseKey($this->keySet[$keyId], $this->defaultAlg);
-    }
-
-    /**
-     * @param string $keyId
-     * @return bool
-     */
-    public function offsetExists($keyId): bool
-    {
-        return $this->keyIdExists($keyId);
-    }
-
-    /**
-     * @param string $offset
-     * @param Key $value
-     */
-    public function offsetSet($offset, $value): void
-    {
-        throw new LogicException('Method not implemented');
-    }
-
-    /**
-     * @param string $offset
-     */
-    public function offsetUnset($offset): void
-    {
-        throw new LogicException('Method not implemented');
-    }
-
-    /**
-     * @return array<mixed>
-     */
-    private function formatJwksForCache(string $jwks): array
-    {
-        $jwks = json_decode($jwks, true);
-
-        if (!isset($jwks['keys'])) {
-            throw new UnexpectedValueException('"keys" member must exist in the JWK Set');
-        }
-
-        if (empty($jwks['keys'])) {
-            throw new InvalidArgumentException('JWK Set did not contain any keys');
-        }
-
-        $keys = [];
-        foreach ($jwks['keys'] as $k => $v) {
-            $kid = isset($v['kid']) ? $v['kid'] : $k;
-            $keys[(string) $kid] = $v;
-        }
-
-        return $keys;
-    }
-
-    private function keyIdExists(string $keyId): bool
-    {
-        if (null === $this->keySet) {
-            $item = $this->getCacheItem();
-            // Try to load keys from cache
-            if ($item->isHit()) {
-                // item found! retrieve it
-                $this->keySet = $item->get();
-                // If the cached item is a string, the JWKS response was cached (previous behavior).
-                // Parse this into expected format array<kid, jwk> instead.
-                if (\is_string($this->keySet)) {
-                    $this->keySet = $this->formatJwksForCache($this->keySet);
-                }
-            }
-        }
-
-        if (!isset($this->keySet[$keyId])) {
-            if ($this->rateLimitExceeded()) {
-                return false;
-            }
-            $request = $this->httpFactory->createRequest('GET', $this->jwksUri);
-            $jwksResponse = $this->httpClient->sendRequest($request);
-            if ($jwksResponse->getStatusCode() !== 200) {
-                throw new UnexpectedValueException(
-                    \sprintf('HTTP Error: %d %s for URI "%s"',
-                        $jwksResponse->getStatusCode(),
-                        $jwksResponse->getReasonPhrase(),
-                        $this->jwksUri,
-                    ),
-                    $jwksResponse->getStatusCode()
-                );
-            }
-            $this->keySet = $this->formatJwksForCache((string) $jwksResponse->getBody());
-
-            if (!isset($this->keySet[$keyId])) {
-                return false;
-            }
-
-            $item = $this->getCacheItem();
-            $item->set($this->keySet);
-            if ($this->expiresAfter) {
-                $item->expiresAfter($this->expiresAfter);
-            }
-            $this->cache->save($item);
-        }
-
-        return true;
-    }
-
-    private function rateLimitExceeded(): bool
-    {
-        if (!$this->rateLimit) {
-            return false;
-        }
-
-        $cacheItem = $this->cache->getItem($this->rateLimitCacheKey);
-
-        $cacheItemData = [];
-        if ($cacheItem->isHit() && \is_array($data = $cacheItem->get())) {
-            $cacheItemData = $data;
-        }
-
-        $callsPerMinute = $cacheItemData['callsPerMinute'] ?? 0;
-        $expiry = $cacheItemData['expiry'] ?? new \DateTime('+60 seconds', new \DateTimeZone('UTC'));
-
-        if (++$callsPerMinute > $this->maxCallsPerMinute) {
-            return true;
-        }
-
-        $cacheItem->set(['expiry' => $expiry, 'callsPerMinute' => $callsPerMinute]);
-        $cacheItem->expiresAt($expiry);
-        $this->cache->save($cacheItem);
-        return false;
-    }
-
-    private function getCacheItem(): CacheItemInterface
-    {
-        if (\is_null($this->cacheItem)) {
-            $this->cacheItem = $this->cache->getItem($this->cacheKey);
-        }
-
-        return $this->cacheItem;
-    }
-
-    private function setCacheKeys(): void
-    {
-        if (empty($this->jwksUri)) {
-            throw new RuntimeException('JWKS URI is empty');
-        }
-
-        // ensure we do not have illegal characters
-        $key = preg_replace('|[^a-zA-Z0-9_\.!]|', '', $this->jwksUri);
-
-        // add prefix
-        $key = $this->cacheKeyPrefix . $key;
-
-        // Hash keys if they exceed $maxKeyLength of 64
-        if (\strlen($key) > $this->maxKeyLength) {
-            $key = substr(hash('sha256', $key), 0, $this->maxKeyLength);
-        }
-
-        $this->cacheKey = $key;
-
-        if ($this->rateLimit) {
-            // add prefix
-            $rateLimitKey = $this->cacheKeyPrefix . 'ratelimit' . $key;
-
-            // Hash keys if they exceed $maxKeyLength of 64
-            if (\strlen($rateLimitKey) > $this->maxKeyLength) {
-                $rateLimitKey = substr(hash('sha256', $rateLimitKey), 0, $this->maxKeyLength);
-            }
-
-            $this->rateLimitCacheKey = $rateLimitKey;
-        }
-    }
-}

vendor/firebase/php-jwt/src/ExpiredException.php

@@ -1,18 +0,0 @@
-<?php
-
-namespace Firebase\JWT;
-
-class ExpiredException extends \UnexpectedValueException implements JWTExceptionWithPayloadInterface
-{
-    private object $payload;
-
-    public function setPayload(object $payload): void
-    {
-        $this->payload = $payload;
-    }
-
-    public function getPayload(): object
-    {
-        return $this->payload;
-    }
-}

vendor/firebase/php-jwt/src/JWK.php

@@ -1,355 +0,0 @@
-<?php
-
-namespace Firebase\JWT;
-
-use DomainException;
-use InvalidArgumentException;
-use UnexpectedValueException;
-
-/**
- * JSON Web Key implementation, based on this spec:
- * https://tools.ietf.org/html/draft-ietf-jose-json-web-key-41
- *
- * PHP version 5
- *
- * @category Authentication
- * @package  Authentication_JWT
- * @author   Bui Sy Nguyen <nguyenbs@gmail.com>
- * @license  http://opensource.org/licenses/BSD-3-Clause 3-clause BSD
- * @link     https://github.com/firebase/php-jwt
- */
-class JWK
-{
-    private const OID = '1.2.840.10045.2.1';
-    private const ASN1_OBJECT_IDENTIFIER = 0x06;
-    private const ASN1_SEQUENCE = 0x10; // also defined in JWT
-    private const ASN1_BIT_STRING = 0x03;
-    private const EC_CURVES = [
-        'P-256' => '1.2.840.10045.3.1.7', // Len: 64
-        'secp256k1' => '1.3.132.0.10', // Len: 64
-        'P-384' => '1.3.132.0.34', // Len: 96
-        // 'P-521' => '1.3.132.0.35', // Len: 132 (not supported)
-    ];
-
-    // For keys with "kty" equal to "OKP" (Octet Key Pair), the "crv" parameter must contain the key subtype.
-    // This library supports the following subtypes:
-    private const OKP_SUBTYPES = [
-        'Ed25519' => true, // RFC 8037
-    ];
-
-    /**
-     * Parse a set of JWK keys
-     *
-     * @param array<mixed> $jwks The JSON Web Key Set as an associative array
-     * @param string       $defaultAlg The algorithm for the Key object if "alg" is not set in the
-     *                                 JSON Web Key Set
-     *
-     * @return array<string, Key> An associative array of key IDs (kid) to Key objects
-     *
-     * @throws InvalidArgumentException     Provided JWK Set is empty
-     * @throws UnexpectedValueException     Provided JWK Set was invalid
-     * @throws DomainException              OpenSSL failure
-     *
-     * @uses parseKey
-     */
-    public static function parseKeySet(array $jwks, ?string $defaultAlg = null): array
-    {
-        $keys = [];
-
-        if (!isset($jwks['keys'])) {
-            throw new UnexpectedValueException('"keys" member must exist in the JWK Set');
-        }
-
-        if (empty($jwks['keys'])) {
-            throw new InvalidArgumentException('JWK Set did not contain any keys');
-        }
-
-        foreach ($jwks['keys'] as $k => $v) {
-            $kid = isset($v['kid']) ? $v['kid'] : $k;
-            if ($key = self::parseKey($v, $defaultAlg)) {
-                $keys[(string) $kid] = $key;
-            }
-        }
-
-        if (0 === \count($keys)) {
-            throw new UnexpectedValueException('No supported algorithms found in JWK Set');
-        }
-
-        return $keys;
-    }
-
-    /**
-     * Parse a JWK key
-     *
-     * @param array<mixed> $jwk An individual JWK
-     * @param string       $defaultAlg The algorithm for the Key object if "alg" is not set in the
-     *                                 JSON Web Key Set
-     *
-     * @return Key The key object for the JWK
-     *
-     * @throws InvalidArgumentException     Provided JWK is empty
-     * @throws UnexpectedValueException     Provided JWK was invalid
-     * @throws DomainException              OpenSSL failure
-     *
-     * @uses createPemFromModulusAndExponent
-     */
-    public static function parseKey(array $jwk, ?string $defaultAlg = null): ?Key
-    {
-        if (empty($jwk)) {
-            throw new InvalidArgumentException('JWK must not be empty');
-        }
-
-        if (!isset($jwk['kty'])) {
-            throw new UnexpectedValueException('JWK must contain a "kty" parameter');
-        }
-
-        if (!isset($jwk['alg'])) {
-            if (\is_null($defaultAlg)) {
-                // The "alg" parameter is optional in a KTY, but an algorithm is required
-                // for parsing in this library. Use the $defaultAlg parameter when parsing the
-                // key set in order to prevent this error.
-                // @see https://datatracker.ietf.org/doc/html/rfc7517#section-4.4
-                throw new UnexpectedValueException('JWK must contain an "alg" parameter');
-            }
-            $jwk['alg'] = $defaultAlg;
-        }
-
-        switch ($jwk['kty']) {
-            case 'RSA':
-                if (!empty($jwk['d'])) {
-                    throw new UnexpectedValueException('RSA private keys are not supported');
-                }
-                if (!isset($jwk['n']) || !isset($jwk['e'])) {
-                    throw new UnexpectedValueException('RSA keys must contain values for both "n" and "e"');
-                }
-
-                $pem = self::createPemFromModulusAndExponent($jwk['n'], $jwk['e']);
-                $publicKey = \openssl_pkey_get_public($pem);
-                if (false === $publicKey) {
-                    throw new DomainException(
-                        'OpenSSL error: ' . \openssl_error_string()
-                    );
-                }
-                return new Key($publicKey, $jwk['alg']);
-            case 'EC':
-                if (isset($jwk['d'])) {
-                    // The key is actually a private key
-                    throw new UnexpectedValueException('Key data must be for a public key');
-                }
-
-                if (empty($jwk['crv'])) {
-                    throw new UnexpectedValueException('crv not set');
-                }
-
-                if (!isset(self::EC_CURVES[$jwk['crv']])) {
-                    throw new DomainException('Unrecognised or unsupported EC curve');
-                }
-
-                if (empty($jwk['x']) || empty($jwk['y'])) {
-                    throw new UnexpectedValueException('x and y not set');
-                }
-
-                $publicKey = self::createPemFromCrvAndXYCoordinates($jwk['crv'], $jwk['x'], $jwk['y']);
-                return new Key($publicKey, $jwk['alg']);
-            case 'OKP':
-                if (isset($jwk['d'])) {
-                    // The key is actually a private key
-                    throw new UnexpectedValueException('Key data must be for a public key');
-                }
-
-                if (!isset($jwk['crv'])) {
-                    throw new UnexpectedValueException('crv not set');
-                }
-
-                if (empty(self::OKP_SUBTYPES[$jwk['crv']])) {
-                    throw new DomainException('Unrecognised or unsupported OKP key subtype');
-                }
-
-                if (empty($jwk['x'])) {
-                    throw new UnexpectedValueException('x not set');
-                }
-
-                // This library works internally with EdDSA keys (Ed25519) encoded in standard base64.
-                $publicKey = JWT::convertBase64urlToBase64($jwk['x']);
-                return new Key($publicKey, $jwk['alg']);
-            case 'oct':
-                if (!isset($jwk['k'])) {
-                    throw new UnexpectedValueException('k not set');
-                }
-
-                return new Key(JWT::urlsafeB64Decode($jwk['k']), $jwk['alg']);
-            default:
-                break;
-        }
-
-        return null;
-    }
-
-    /**
-     * Converts the EC JWK values to pem format.
-     *
-     * @param   string  $crv The EC curve (only P-256 & P-384 is supported)
-     * @param   string  $x   The EC x-coordinate
-     * @param   string  $y   The EC y-coordinate
-     *
-     * @return  string
-     */
-    private static function createPemFromCrvAndXYCoordinates(string $crv, string $x, string $y): string
-    {
-        $pem =
-            self::encodeDER(
-                self::ASN1_SEQUENCE,
-                self::encodeDER(
-                    self::ASN1_SEQUENCE,
-                    self::encodeDER(
-                        self::ASN1_OBJECT_IDENTIFIER,
-                        self::encodeOID(self::OID)
-                    )
-                    . self::encodeDER(
-                        self::ASN1_OBJECT_IDENTIFIER,
-                        self::encodeOID(self::EC_CURVES[$crv])
-                    )
-                ) .
-                self::encodeDER(
-                    self::ASN1_BIT_STRING,
-                    \chr(0x00) . \chr(0x04)
-                    . JWT::urlsafeB64Decode($x)
-                    . JWT::urlsafeB64Decode($y)
-                )
-            );
-
-        return \sprintf(
-            "-----BEGIN PUBLIC KEY-----\n%s\n-----END PUBLIC KEY-----\n",
-            wordwrap(base64_encode($pem), 64, "\n", true)
-        );
-    }
-
-    /**
-     * Create a public key represented in PEM format from RSA modulus and exponent information
-     *
-     * @param string $n The RSA modulus encoded in Base64
-     * @param string $e The RSA exponent encoded in Base64
-     *
-     * @return string The RSA public key represented in PEM format
-     *
-     * @uses encodeLength
-     */
-    private static function createPemFromModulusAndExponent(
-        string $n,
-        string $e
-    ): string {
-        $mod = JWT::urlsafeB64Decode($n);
-        $exp = JWT::urlsafeB64Decode($e);
-
-        $modulus = \pack('Ca*a*', 2, self::encodeLength(\strlen($mod)), $mod);
-        $publicExponent = \pack('Ca*a*', 2, self::encodeLength(\strlen($exp)), $exp);
-
-        $rsaPublicKey = \pack(
-            'Ca*a*a*',
-            48,
-            self::encodeLength(\strlen($modulus) + \strlen($publicExponent)),
-            $modulus,
-            $publicExponent
-        );
-
-        // sequence(oid(1.2.840.113549.1.1.1), null)) = rsaEncryption.
-        $rsaOID = \pack('H*', '300d06092a864886f70d0101010500'); // hex version of MA0GCSqGSIb3DQEBAQUA
-        $rsaPublicKey = \chr(0) . $rsaPublicKey;
-        $rsaPublicKey = \chr(3) . self::encodeLength(\strlen($rsaPublicKey)) . $rsaPublicKey;
-
-        $rsaPublicKey = \pack(
-            'Ca*a*',
-            48,
-            self::encodeLength(\strlen($rsaOID . $rsaPublicKey)),
-            $rsaOID . $rsaPublicKey
-        );
-
-        return "-----BEGIN PUBLIC KEY-----\r\n" .
-            \chunk_split(\base64_encode($rsaPublicKey), 64) .
-            '-----END PUBLIC KEY-----';
-    }
-
-    /**
-     * DER-encode the length
-     *
-     * DER supports lengths up to (2**8)**127, however, we'll only support lengths up to (2**8)**4.  See
-     * {@link http://itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf#p=13 X.690 paragraph 8.1.3} for more information.
-     *
-     * @param int $length
-     * @return string
-     */
-    private static function encodeLength(int $length): string
-    {
-        if ($length <= 0x7F) {
-            return \chr($length);
-        }
-
-        $temp = \ltrim(\pack('N', $length), \chr(0));
-
-        return \pack('Ca*', 0x80 | \strlen($temp), $temp);
-    }
-
-    /**
-     * Encodes a value into a DER object.
-     * Also defined in Firebase\JWT\JWT
-     *
-     * @param   int     $type DER tag
-     * @param   string  $value the value to encode
-     * @return  string  the encoded object
-     */
-    private static function encodeDER(int $type, string $value): string
-    {
-        $tag_header = 0;
-        if ($type === self::ASN1_SEQUENCE) {
-            $tag_header |= 0x20;
-        }
-
-        // Type
-        $der = \chr($tag_header | $type);
-
-        // Length
-        $der .= \chr(\strlen($value));
-
-        return $der . $value;
-    }
-
-    /**
-     * Encodes a string into a DER-encoded OID.
-     *
-     * @param   string $oid the OID string
-     * @return  string the binary DER-encoded OID
-     */
-    private static function encodeOID(string $oid): string
-    {
-        $octets = explode('.', $oid);
-
-        // Get the first octet
-        $first = (int) array_shift($octets);
-        $second = (int) array_shift($octets);
-        $oid = \chr($first * 40 + $second);
-
-        // Iterate over subsequent octets
-        foreach ($octets as $octet) {
-            if ($octet == 0) {
-                $oid .= \chr(0x00);
-                continue;
-            }
-            $bin = '';
-
-            while ($octet) {
-                $bin .= \chr(0x80 | ($octet & 0x7f));
-                $octet >>= 7;
-            }
-            $bin[0] = $bin[0] & \chr(0x7f);
-
-            // Convert to big endian if necessary
-            if (pack('V', 65534) == pack('L', 65534)) {
-                $oid .= strrev($bin);
-            } else {
-                $oid .= $bin;
-            }
-        }
-
-        return $oid;
-    }
-}

vendor/firebase/php-jwt/src/JWT.php

@@ -1,667 +0,0 @@
-<?php
-
-namespace Firebase\JWT;
-
-use ArrayAccess;
-use DateTime;
-use DomainException;
-use Exception;
-use InvalidArgumentException;
-use OpenSSLAsymmetricKey;
-use OpenSSLCertificate;
-use stdClass;
-use UnexpectedValueException;
-
-/**
- * JSON Web Token implementation, based on this spec:
- * https://tools.ietf.org/html/rfc7519
- *
- * PHP version 5
- *
- * @category Authentication
- * @package  Authentication_JWT
- * @author   Neuman Vong <neuman@twilio.com>
- * @author   Anant Narayanan <anant@php.net>
- * @license  http://opensource.org/licenses/BSD-3-Clause 3-clause BSD
- * @link     https://github.com/firebase/php-jwt
- */
-class JWT
-{
-    private const ASN1_INTEGER = 0x02;
-    private const ASN1_SEQUENCE = 0x10;
-    private const ASN1_BIT_STRING = 0x03;
-
-    /**
-     * When checking nbf, iat or expiration times,
-     * we want to provide some extra leeway time to
-     * account for clock skew.
-     *
-     * @var int
-     */
-    public static $leeway = 0;
-
-    /**
-     * Allow the current timestamp to be specified.
-     * Useful for fixing a value within unit testing.
-     * Will default to PHP time() value if null.
-     *
-     * @var ?int
-     */
-    public static $timestamp = null;
-
-    /**
-     * @var array<string, string[]>
-     */
-    public static $supported_algs = [
-        'ES384' => ['openssl', 'SHA384'],
-        'ES256' => ['openssl', 'SHA256'],
-        'ES256K' => ['openssl', 'SHA256'],
-        'HS256' => ['hash_hmac', 'SHA256'],
-        'HS384' => ['hash_hmac', 'SHA384'],
-        'HS512' => ['hash_hmac', 'SHA512'],
-        'RS256' => ['openssl', 'SHA256'],
-        'RS384' => ['openssl', 'SHA384'],
-        'RS512' => ['openssl', 'SHA512'],
-        'EdDSA' => ['sodium_crypto', 'EdDSA'],
-    ];
-
-    /**
-     * Decodes a JWT string into a PHP object.
-     *
-     * @param string                 $jwt            The JWT
-     * @param Key|ArrayAccess<string,Key>|array<string,Key> $keyOrKeyArray  The Key or associative array of key IDs
-     *                                                                      (kid) to Key objects.
-     *                                                                      If the algorithm used is asymmetric, this is
-     *                                                                      the public key.
-     *                                                                      Each Key object contains an algorithm and
-     *                                                                      matching key.
-     *                                                                      Supported algorithms are 'ES384','ES256',
-     *                                                                      'HS256', 'HS384', 'HS512', 'RS256', 'RS384'
-     *                                                                      and 'RS512'.
-     * @param stdClass               $headers                               Optional. Populates stdClass with headers.
-     *
-     * @return stdClass The JWT's payload as a PHP object
-     *
-     * @throws InvalidArgumentException     Provided key/key-array was empty or malformed
-     * @throws DomainException              Provided JWT is malformed
-     * @throws UnexpectedValueException     Provided JWT was invalid
-     * @throws SignatureInvalidException    Provided JWT was invalid because the signature verification failed
-     * @throws BeforeValidException         Provided JWT is trying to be used before it's eligible as defined by 'nbf'
-     * @throws BeforeValidException         Provided JWT is trying to be used before it's been created as defined by 'iat'
-     * @throws ExpiredException             Provided JWT has since expired, as defined by the 'exp' claim
-     *
-     * @uses jsonDecode
-     * @uses urlsafeB64Decode
-     */
-    public static function decode(
-        string $jwt,
-        $keyOrKeyArray,
-        ?stdClass &$headers = null
-    ): stdClass {
-        // Validate JWT
-        $timestamp = \is_null(static::$timestamp) ? \time() : static::$timestamp;
-
-        if (empty($keyOrKeyArray)) {
-            throw new InvalidArgumentException('Key may not be empty');
-        }
-        $tks = \explode('.', $jwt);
-        if (\count($tks) !== 3) {
-            throw new UnexpectedValueException('Wrong number of segments');
-        }
-        list($headb64, $bodyb64, $cryptob64) = $tks;
-        $headerRaw = static::urlsafeB64Decode($headb64);
-        if (null === ($header = static::jsonDecode($headerRaw))) {
-            throw new UnexpectedValueException('Invalid header encoding');
-        }
-        if ($headers !== null) {
-            $headers = $header;
-        }
-        $payloadRaw = static::urlsafeB64Decode($bodyb64);
-        if (null === ($payload = static::jsonDecode($payloadRaw))) {
-            throw new UnexpectedValueException('Invalid claims encoding');
-        }
-        if (\is_array($payload)) {
-            // prevent PHP Fatal Error in edge-cases when payload is empty array
-            $payload = (object) $payload;
-        }
-        if (!$payload instanceof stdClass) {
-            throw new UnexpectedValueException('Payload must be a JSON object');
-        }
-        $sig = static::urlsafeB64Decode($cryptob64);
-        if (empty($header->alg)) {
-            throw new UnexpectedValueException('Empty algorithm');
-        }
-        if (empty(static::$supported_algs[$header->alg])) {
-            throw new UnexpectedValueException('Algorithm not supported');
-        }
-
-        $key = self::getKey($keyOrKeyArray, property_exists($header, 'kid') ? $header->kid : null);
-
-        // Check the algorithm
-        if (!self::constantTimeEquals($key->getAlgorithm(), $header->alg)) {
-            // See issue #351
-            throw new UnexpectedValueException('Incorrect key for this algorithm');
-        }
-        if (\in_array($header->alg, ['ES256', 'ES256K', 'ES384'], true)) {
-            // OpenSSL expects an ASN.1 DER sequence for ES256/ES256K/ES384 signatures
-            $sig = self::signatureToDER($sig);
-        }
-        if (!self::verify("{$headb64}.{$bodyb64}", $sig, $key->getKeyMaterial(), $header->alg)) {
-            throw new SignatureInvalidException('Signature verification failed');
-        }
-
-        // Check the nbf if it is defined. This is the time that the
-        // token can actually be used. If it's not yet that time, abort.
-        if (isset($payload->nbf) && floor($payload->nbf) > ($timestamp + static::$leeway)) {
-            $ex = new BeforeValidException(
-                'Cannot handle token with nbf prior to ' . \date(DateTime::ISO8601, (int) floor($payload->nbf))
-            );
-            $ex->setPayload($payload);
-            throw $ex;
-        }
-
-        // Check that this token has been created before 'now'. This prevents
-        // using tokens that have been created for later use (and haven't
-        // correctly used the nbf claim).
-        if (!isset($payload->nbf) && isset($payload->iat) && floor($payload->iat) > ($timestamp + static::$leeway)) {
-            $ex = new BeforeValidException(
-                'Cannot handle token with iat prior to ' . \date(DateTime::ISO8601, (int) floor($payload->iat))
-            );
-            $ex->setPayload($payload);
-            throw $ex;
-        }
-
-        // Check if this token has expired.
-        if (isset($payload->exp) && ($timestamp - static::$leeway) >= $payload->exp) {
-            $ex = new ExpiredException('Expired token');
-            $ex->setPayload($payload);
-            throw $ex;
-        }
-
-        return $payload;
-    }
-
-    /**
-     * Converts and signs a PHP array into a JWT string.
-     *
-     * @param array<mixed>          $payload PHP array
-     * @param string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate $key The secret key.
-     * @param string                $alg     Supported algorithms are 'ES384','ES256', 'ES256K', 'HS256',
-     *                                       'HS384', 'HS512', 'RS256', 'RS384', and 'RS512'
-     * @param string                $keyId
-     * @param array<string, string> $head    An array with header elements to attach
-     *
-     * @return string A signed JWT
-     *
-     * @uses jsonEncode
-     * @uses urlsafeB64Encode
-     */
-    public static function encode(
-        array $payload,
-        $key,
-        string $alg,
-        ?string $keyId = null,
-        ?array $head = null
-    ): string {
-        $header = ['typ' => 'JWT'];
-        if (isset($head)) {
-            $header = \array_merge($header, $head);
-        }
-        $header['alg'] = $alg;
-        if ($keyId !== null) {
-            $header['kid'] = $keyId;
-        }
-        $segments = [];
-        $segments[] = static::urlsafeB64Encode((string) static::jsonEncode($header));
-        $segments[] = static::urlsafeB64Encode((string) static::jsonEncode($payload));
-        $signing_input = \implode('.', $segments);
-
-        $signature = static::sign($signing_input, $key, $alg);
-        $segments[] = static::urlsafeB64Encode($signature);
-
-        return \implode('.', $segments);
-    }
-
-    /**
-     * Sign a string with a given key and algorithm.
-     *
-     * @param string $msg  The message to sign
-     * @param string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate  $key  The secret key.
-     * @param string $alg  Supported algorithms are 'EdDSA', 'ES384', 'ES256', 'ES256K', 'HS256',
-     *                    'HS384', 'HS512', 'RS256', 'RS384', and 'RS512'
-     *
-     * @return string An encrypted message
-     *
-     * @throws DomainException Unsupported algorithm or bad key was specified
-     */
-    public static function sign(
-        string $msg,
-        $key,
-        string $alg
-    ): string {
-        if (empty(static::$supported_algs[$alg])) {
-            throw new DomainException('Algorithm not supported');
-        }
-        list($function, $algorithm) = static::$supported_algs[$alg];
-        switch ($function) {
-            case 'hash_hmac':
-                if (!\is_string($key)) {
-                    throw new InvalidArgumentException('key must be a string when using hmac');
-                }
-                return \hash_hmac($algorithm, $msg, $key, true);
-            case 'openssl':
-                $signature = '';
-                if (!\is_resource($key) && !openssl_pkey_get_private($key)) {
-                    throw new DomainException('OpenSSL unable to validate key');
-                }
-                $success = \openssl_sign($msg, $signature, $key, $algorithm); // @phpstan-ignore-line
-                if (!$success) {
-                    throw new DomainException('OpenSSL unable to sign data');
-                }
-                if ($alg === 'ES256' || $alg === 'ES256K') {
-                    $signature = self::signatureFromDER($signature, 256);
-                } elseif ($alg === 'ES384') {
-                    $signature = self::signatureFromDER($signature, 384);
-                }
-                return $signature;
-            case 'sodium_crypto':
-                if (!\function_exists('sodium_crypto_sign_detached')) {
-                    throw new DomainException('libsodium is not available');
-                }
-                if (!\is_string($key)) {
-                    throw new InvalidArgumentException('key must be a string when using EdDSA');
-                }
-                try {
-                    // The last non-empty line is used as the key.
-                    $lines = array_filter(explode("\n", $key));
-                    $key = base64_decode((string) end($lines));
-                    if (\strlen($key) === 0) {
-                        throw new DomainException('Key cannot be empty string');
-                    }
-                    return sodium_crypto_sign_detached($msg, $key);
-                } catch (Exception $e) {
-                    throw new DomainException($e->getMessage(), 0, $e);
-                }
-        }
-
-        throw new DomainException('Algorithm not supported');
-    }
-
-    /**
-     * Verify a signature with the message, key and method. Not all methods
-     * are symmetric, so we must have a separate verify and sign method.
-     *
-     * @param string $msg         The original message (header and body)
-     * @param string $signature   The original signature
-     * @param string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate  $keyMaterial For Ed*, ES*, HS*, a string key works. for RS*, must be an instance of OpenSSLAsymmetricKey
-     * @param string $alg         The algorithm
-     *
-     * @return bool
-     *
-     * @throws DomainException Invalid Algorithm, bad key, or OpenSSL failure
-     */
-    private static function verify(
-        string $msg,
-        string $signature,
-        $keyMaterial,
-        string $alg
-    ): bool {
-        if (empty(static::$supported_algs[$alg])) {
-            throw new DomainException('Algorithm not supported');
-        }
-
-        list($function, $algorithm) = static::$supported_algs[$alg];
-        switch ($function) {
-            case 'openssl':
-                $success = \openssl_verify($msg, $signature, $keyMaterial, $algorithm); // @phpstan-ignore-line
-                if ($success === 1) {
-                    return true;
-                }
-                if ($success === 0) {
-                    return false;
-                }
-                // returns 1 on success, 0 on failure, -1 on error.
-                throw new DomainException(
-                    'OpenSSL error: ' . \openssl_error_string()
-                );
-            case 'sodium_crypto':
-                if (!\function_exists('sodium_crypto_sign_verify_detached')) {
-                    throw new DomainException('libsodium is not available');
-                }
-                if (!\is_string($keyMaterial)) {
-                    throw new InvalidArgumentException('key must be a string when using EdDSA');
-                }
-                try {
-                    // The last non-empty line is used as the key.
-                    $lines = array_filter(explode("\n", $keyMaterial));
-                    $key = base64_decode((string) end($lines));
-                    if (\strlen($key) === 0) {
-                        throw new DomainException('Key cannot be empty string');
-                    }
-                    if (\strlen($signature) === 0) {
-                        throw new DomainException('Signature cannot be empty string');
-                    }
-                    return sodium_crypto_sign_verify_detached($signature, $msg, $key);
-                } catch (Exception $e) {
-                    throw new DomainException($e->getMessage(), 0, $e);
-                }
-            case 'hash_hmac':
-            default:
-                if (!\is_string($keyMaterial)) {
-                    throw new InvalidArgumentException('key must be a string when using hmac');
-                }
-                $hash = \hash_hmac($algorithm, $msg, $keyMaterial, true);
-                return self::constantTimeEquals($hash, $signature);
-        }
-    }
-
-    /**
-     * Decode a JSON string into a PHP object.
-     *
-     * @param string $input JSON string
-     *
-     * @return mixed The decoded JSON string
-     *
-     * @throws DomainException Provided string was invalid JSON
-     */
-    public static function jsonDecode(string $input)
-    {
-        $obj = \json_decode($input, false, 512, JSON_BIGINT_AS_STRING);
-
-        if ($errno = \json_last_error()) {
-            self::handleJsonError($errno);
-        } elseif ($obj === null && $input !== 'null') {
-            throw new DomainException('Null result with non-null input');
-        }
-        return $obj;
-    }
-
-    /**
-     * Encode a PHP array into a JSON string.
-     *
-     * @param array<mixed> $input A PHP array
-     *
-     * @return string JSON representation of the PHP array
-     *
-     * @throws DomainException Provided object could not be encoded to valid JSON
-     */
-    public static function jsonEncode(array $input): string
-    {
-        $json = \json_encode($input, \JSON_UNESCAPED_SLASHES);
-        if ($errno = \json_last_error()) {
-            self::handleJsonError($errno);
-        } elseif ($json === 'null') {
-            throw new DomainException('Null result with non-null input');
-        }
-        if ($json === false) {
-            throw new DomainException('Provided object could not be encoded to valid JSON');
-        }
-        return $json;
-    }
-
-    /**
-     * Decode a string with URL-safe Base64.
-     *
-     * @param string $input A Base64 encoded string
-     *
-     * @return string A decoded string
-     *
-     * @throws InvalidArgumentException invalid base64 characters
-     */
-    public static function urlsafeB64Decode(string $input): string
-    {
-        return \base64_decode(self::convertBase64UrlToBase64($input));
-    }
-
-    /**
-     * Convert a string in the base64url (URL-safe Base64) encoding to standard base64.
-     *
-     * @param string $input A Base64 encoded string with URL-safe characters (-_ and no padding)
-     *
-     * @return string A Base64 encoded string with standard characters (+/) and padding (=), when
-     * needed.
-     *
-     * @see https://www.rfc-editor.org/rfc/rfc4648
-     */
-    public static function convertBase64UrlToBase64(string $input): string
-    {
-        $remainder = \strlen($input) % 4;
-        if ($remainder) {
-            $padlen = 4 - $remainder;
-            $input .= \str_repeat('=', $padlen);
-        }
-        return \strtr($input, '-_', '+/');
-    }
-
-    /**
-     * Encode a string with URL-safe Base64.
-     *
-     * @param string $input The string you want encoded
-     *
-     * @return string The base64 encode of what you passed in
-     */
-    public static function urlsafeB64Encode(string $input): string
-    {
-        return \str_replace('=', '', \strtr(\base64_encode($input), '+/', '-_'));
-    }
-
-
-    /**
-     * Determine if an algorithm has been provided for each Key
-     *
-     * @param Key|ArrayAccess<string,Key>|array<string,Key> $keyOrKeyArray
-     * @param string|null            $kid
-     *
-     * @throws UnexpectedValueException
-     *
-     * @return Key
-     */
-    private static function getKey(
-        $keyOrKeyArray,
-        ?string $kid
-    ): Key {
-        if ($keyOrKeyArray instanceof Key) {
-            return $keyOrKeyArray;
-        }
-
-        if (empty($kid) && $kid !== '0') {
-            throw new UnexpectedValueException('"kid" empty, unable to lookup correct key');
-        }
-
-        if ($keyOrKeyArray instanceof CachedKeySet) {
-            // Skip "isset" check, as this will automatically refresh if not set
-            return $keyOrKeyArray[$kid];
-        }
-
-        if (!isset($keyOrKeyArray[$kid])) {
-            throw new UnexpectedValueException('"kid" invalid, unable to lookup correct key');
-        }
-
-        return $keyOrKeyArray[$kid];
-    }
-
-    /**
-     * @param string $left  The string of known length to compare against
-     * @param string $right The user-supplied string
-     * @return bool
-     */
-    public static function constantTimeEquals(string $left, string $right): bool
-    {
-        if (\function_exists('hash_equals')) {
-            return \hash_equals($left, $right);
-        }
-        $len = \min(self::safeStrlen($left), self::safeStrlen($right));
-
-        $status = 0;
-        for ($i = 0; $i < $len; $i++) {
-            $status |= (\ord($left[$i]) ^ \ord($right[$i]));
-        }
-        $status |= (self::safeStrlen($left) ^ self::safeStrlen($right));
-
-        return ($status === 0);
-    }
-
-    /**
-     * Helper method to create a JSON error.
-     *
-     * @param int $errno An error number from json_last_error()
-     *
-     * @throws DomainException
-     *
-     * @return void
-     */
-    private static function handleJsonError(int $errno): void
-    {
-        $messages = [
-            JSON_ERROR_DEPTH => 'Maximum stack depth exceeded',
-            JSON_ERROR_STATE_MISMATCH => 'Invalid or malformed JSON',
-            JSON_ERROR_CTRL_CHAR => 'Unexpected control character found',
-            JSON_ERROR_SYNTAX => 'Syntax error, malformed JSON',
-            JSON_ERROR_UTF8 => 'Malformed UTF-8 characters' //PHP >= 5.3.3
-        ];
-        throw new DomainException(
-            isset($messages[$errno])
-            ? $messages[$errno]
-            : 'Unknown JSON error: ' . $errno
-        );
-    }
-
-    /**
-     * Get the number of bytes in cryptographic strings.
-     *
-     * @param string $str
-     *
-     * @return int
-     */
-    private static function safeStrlen(string $str): int
-    {
-        if (\function_exists('mb_strlen')) {
-            return \mb_strlen($str, '8bit');
-        }
-        return \strlen($str);
-    }
-
-    /**
-     * Convert an ECDSA signature to an ASN.1 DER sequence
-     *
-     * @param   string $sig The ECDSA signature to convert
-     * @return  string The encoded DER object
-     */
-    private static function signatureToDER(string $sig): string
-    {
-        // Separate the signature into r-value and s-value
-        $length = max(1, (int) (\strlen($sig) / 2));
-        list($r, $s) = \str_split($sig, $length);
-
-        // Trim leading zeros
-        $r = \ltrim($r, "\x00");
-        $s = \ltrim($s, "\x00");
-
-        // Convert r-value and s-value from unsigned big-endian integers to
-        // signed two's complement
-        if (\ord($r[0]) > 0x7f) {
-            $r = "\x00" . $r;
-        }
-        if (\ord($s[0]) > 0x7f) {
-            $s = "\x00" . $s;
-        }
-
-        return self::encodeDER(
-            self::ASN1_SEQUENCE,
-            self::encodeDER(self::ASN1_INTEGER, $r) .
-            self::encodeDER(self::ASN1_INTEGER, $s)
-        );
-    }
-
-    /**
-     * Encodes a value into a DER object.
-     *
-     * @param   int     $type DER tag
-     * @param   string  $value the value to encode
-     *
-     * @return  string  the encoded object
-     */
-    private static function encodeDER(int $type, string $value): string
-    {
-        $tag_header = 0;
-        if ($type === self::ASN1_SEQUENCE) {
-            $tag_header |= 0x20;
-        }
-
-        // Type
-        $der = \chr($tag_header | $type);
-
-        // Length
-        $der .= \chr(\strlen($value));
-
-        return $der . $value;
-    }
-
-    /**
-     * Encodes signature from a DER object.
-     *
-     * @param   string  $der binary signature in DER format
-     * @param   int     $keySize the number of bits in the key
-     *
-     * @return  string  the signature
-     */
-    private static function signatureFromDER(string $der, int $keySize): string
-    {
-        // OpenSSL returns the ECDSA signatures as a binary ASN.1 DER SEQUENCE
-        list($offset, $_) = self::readDER($der);
-        list($offset, $r) = self::readDER($der, $offset);
-        list($offset, $s) = self::readDER($der, $offset);
-
-        // Convert r-value and s-value from signed two's compliment to unsigned
-        // big-endian integers
-        $r = \ltrim($r, "\x00");
-        $s = \ltrim($s, "\x00");
-
-        // Pad out r and s so that they are $keySize bits long
-        $r = \str_pad($r, $keySize / 8, "\x00", STR_PAD_LEFT);
-        $s = \str_pad($s, $keySize / 8, "\x00", STR_PAD_LEFT);
-
-        return $r . $s;
-    }
-
-    /**
-     * Reads binary DER-encoded data and decodes into a single object
-     *
-     * @param string $der the binary data in DER format
-     * @param int $offset the offset of the data stream containing the object
-     * to decode
-     *
-     * @return array{int, string|null} the new offset and the decoded object
-     */
-    private static function readDER(string $der, int $offset = 0): array
-    {
-        $pos = $offset;
-        $size = \strlen($der);
-        $constructed = (\ord($der[$pos]) >> 5) & 0x01;
-        $type = \ord($der[$pos++]) & 0x1f;
-
-        // Length
-        $len = \ord($der[$pos++]);
-        if ($len & 0x80) {
-            $n = $len & 0x1f;
-            $len = 0;
-            while ($n-- && $pos < $size) {
-                $len = ($len << 8) | \ord($der[$pos++]);
-            }
-        }
-
-        // Value
-        if ($type === self::ASN1_BIT_STRING) {
-            $pos++; // Skip the first contents octet (padding indicator)
-            $data = \substr($der, $pos, $len - 1);
-            $pos += $len - 1;
-        } elseif (!$constructed) {
-            $data = \substr($der, $pos, $len);
-            $pos += $len;
-        } else {
-            $data = null;
-        }
-
-        return [$pos, $data];
-    }
-}

vendor/firebase/php-jwt/src/JWTExceptionWithPayloadInterface.php

@@ -1,20 +0,0 @@
-<?php
-namespace Firebase\JWT;
-
-interface JWTExceptionWithPayloadInterface
-{
-    /**
-     * Get the payload that caused this exception.
-     *
-     * @return object
-     */
-    public function getPayload(): object;
-
-    /**
-     * Get the payload that caused this exception.
-     *
-     * @param object $payload
-     * @return void
-     */
-    public function setPayload(object $payload): void;
-}

vendor/firebase/php-jwt/src/Key.php

@@ -1,55 +0,0 @@
-<?php
-
-namespace Firebase\JWT;
-
-use InvalidArgumentException;
-use OpenSSLAsymmetricKey;
-use OpenSSLCertificate;
-use TypeError;
-
-class Key
-{
-    /**
-     * @param string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate $keyMaterial
-     * @param string $algorithm
-     */
-    public function __construct(
-        private $keyMaterial,
-        private string $algorithm
-    ) {
-        if (
-            !\is_string($keyMaterial)
-            && !$keyMaterial instanceof OpenSSLAsymmetricKey
-            && !$keyMaterial instanceof OpenSSLCertificate
-            && !\is_resource($keyMaterial)
-        ) {
-            throw new TypeError('Key material must be a string, resource, or OpenSSLAsymmetricKey');
-        }
-
-        if (empty($keyMaterial)) {
-            throw new InvalidArgumentException('Key material must not be empty');
-        }
-
-        if (empty($algorithm)) {
-            throw new InvalidArgumentException('Algorithm must not be empty');
-        }
-    }
-
-    /**
-     * Return the algorithm valid for this key
-     *
-     * @return string
-     */
-    public function getAlgorithm(): string
-    {
-        return $this->algorithm;
-    }
-
-    /**
-     * @return string|resource|OpenSSLAsymmetricKey|OpenSSLCertificate
-     */
-    public function getKeyMaterial()
-    {
-        return $this->keyMaterial;
-    }
-}

vendor/firebase/php-jwt/src/SignatureInvalidException.php

@@ -1,7 +0,0 @@
-<?php
-
-namespace Firebase\JWT;
-
-class SignatureInvalidException extends \UnexpectedValueException
-{
-}