Simple Route

exam/vendor/pecee/simple-router/src/Pecee/Http/Exceptions/MalformedUrlException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Pecee\Http\Exceptions;
+
+use Exception;
+
+class MalformedUrlException extends Exception
+{
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Input/IInputItem.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Pecee\Http\Input;
+
+interface IInputItem
+{
+
+    public function getIndex(): string;
+
+    public function setIndex(string $index): self;
+
+    public function getName(): ?string;
+
+    public function setName(string $name): self;
+
+    /**
+     * @return mixed
+     */
+    public function getValue();
+
+    /**
+     * @param mixed $value
+     */
+    public function setValue($value): self;
+
+    public function __toString(): string;
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Input/InputFile.php

@@ -0,0 +1,319 @@
+<?php
+
+namespace Pecee\Http\Input;
+
+use Pecee\Exceptions\InvalidArgumentException;
+
+class InputFile implements IInputItem
+{
+    /**
+     * @var string
+     */
+    public string $index;
+
+    /**
+     * @var string
+     */
+    public string $name;
+
+    /**
+     * @var string|null
+     */
+    public ?string $filename = null;
+
+    /**
+     * @var int|null
+     */
+    public ?int $size = null;
+
+    /**
+     * @var string|null
+     */
+    public ?string $type = null;
+
+    /**
+     * @var int
+     */
+    public int $errors = 0;
+
+    /**
+     * @var string|null
+     */
+    public ?string $tmpName = null;
+
+    public function __construct(string $index)
+    {
+        $this->index = $index;
+
+        $this->errors = 0;
+
+        // Make the name human friendly, by replace _ with space
+        $this->name = ucfirst(str_replace('_', ' ', strtolower($this->index)));
+    }
+
+    /**
+     * Create from array
+     *
+     * @param array $values
+     * @throws InvalidArgumentException
+     * @return static
+     */
+    public static function createFromArray(array $values): self
+    {
+        if (isset($values['index']) === false) {
+            throw new InvalidArgumentException('Index key is required');
+        }
+
+        /* Easy way of ensuring that all indexes-are set and not filling the screen with isset() */
+
+        $values += [
+            'tmp_name' => null,
+            'type'     => null,
+            'size'     => null,
+            'name'     => null,
+            'error'    => null,
+        ];
+
+        return (new self($values['index']))
+            ->setSize((int)$values['size'])
+            ->setError((int)$values['error'])
+            ->setType($values['type'])
+            ->setTmpName($values['tmp_name'])
+            ->setFilename($values['name']);
+
+    }
+
+    /**
+     * @return string
+     */
+    public function getIndex(): string
+    {
+        return $this->index;
+    }
+
+    /**
+     * Set input index
+     * @param string $index
+     * @return static
+     */
+    public function setIndex(string $index): IInputItem
+    {
+        $this->index = $index;
+
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    public function getSize(): ?int
+    {
+        return $this->size;
+    }
+
+    /**
+     * Set file size
+     * @param int $size
+     * @return static
+     */
+    public function setSize(int $size): IInputItem
+    {
+        $this->size = $size;
+
+        return $this;
+    }
+
+    /**
+     * Get mime-type of file
+     * @return string
+     */
+    public function getMime(): string
+    {
+        return $this->getType();
+    }
+
+    /**
+     * @return string
+     */
+    public function getType(): string
+    {
+        return $this->type;
+    }
+
+    /**
+     * Set type
+     * @param string $type
+     * @return static
+     */
+    public function setType(string $type): IInputItem
+    {
+        $this->type = $type;
+
+        return $this;
+    }
+
+    /**
+     * Returns extension without "."
+     *
+     * @return string
+     */
+    public function getExtension(): string
+    {
+        return pathinfo($this->getFilename(), PATHINFO_EXTENSION);
+    }
+
+    /**
+     * Get human friendly name
+     *
+     * @return string
+     */
+    public function getName(): ?string
+    {
+        return $this->name;
+    }
+
+    /**
+     * Set human friendly name.
+     * Useful for adding validation etc.
+     *
+     * @param string $name
+     * @return static
+     */
+    public function setName(string $name): IInputItem
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    /**
+     * Set filename
+     *
+     * @param string $name
+     * @return static
+     */
+    public function setFilename(string $name): IInputItem
+    {
+        $this->filename = $name;
+
+        return $this;
+    }
+
+    /**
+     * Get filename
+     *
+     * @return string mixed
+     */
+    public function getFilename(): ?string
+    {
+        return $this->filename;
+    }
+
+    /**
+     * Move the uploaded temporary file to it's new home
+     *
+     * @param string $destination
+     * @return bool
+     */
+    public function move(string $destination): bool
+    {
+        return move_uploaded_file($this->tmpName, $destination);
+    }
+
+    /**
+     * Get file contents
+     *
+     * @return string
+     */
+    public function getContents(): string
+    {
+        return file_get_contents($this->tmpName);
+    }
+
+    /**
+     * Return true if an upload error occurred.
+     *
+     * @return bool
+     */
+    public function hasError(): bool
+    {
+        return ($this->getError() !== 0);
+    }
+
+    /**
+     * Get upload-error code.
+     *
+     * @return int|null
+     */
+    public function getError(): ?int
+    {
+        return $this->errors;
+    }
+
+    /**
+     * Set error
+     *
+     * @param int|null $error
+     * @return static
+     */
+    public function setError(?int $error): IInputItem
+    {
+        $this->errors = (int)$error;
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTmpName(): string
+    {
+        return $this->tmpName;
+    }
+
+    /**
+     * Set file temp. name
+     * @param string $name
+     * @return static
+     */
+    public function setTmpName(string $name): IInputItem
+    {
+        $this->tmpName = $name;
+
+        return $this;
+    }
+
+    public function __toString(): string
+    {
+        return $this->getTmpName();
+    }
+
+    public function getValue(): string
+    {
+        return $this->getFilename();
+    }
+
+    /**
+     * @param mixed $value
+     * @return static
+     */
+    public function setValue($value): IInputItem
+    {
+        $this->filename = $value;
+
+        return $this;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'tmp_name' => $this->tmpName,
+            'type'     => $this->type,
+            'size'     => $this->size,
+            'name'     => $this->name,
+            'error'    => $this->errors,
+            'filename' => $this->filename,
+        ];
+    }
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Input/InputHandler.php

@@ -0,0 +1,474 @@
+<?php
+
+namespace Pecee\Http\Input;
+
+use Pecee\Exceptions\InvalidArgumentException;
+use Pecee\Http\Request;
+
+class InputHandler
+{
+    /**
+     * @var array
+     */
+    protected array $get = [];
+
+    /**
+     * @var array
+     */
+    protected array $post = [];
+
+    /**
+     * @var array
+     */
+    protected array $file = [];
+
+    /**
+     * @var Request
+     */
+    protected Request $request;
+
+    /**
+     * Original post variables
+     * @var array
+     */
+    protected array $originalPost = [];
+
+    /**
+     * Original get/params variables
+     * @var array
+     */
+    protected array $originalParams = [];
+
+    /**
+     * Get original file variables
+     * @var array
+     */
+    protected array $originalFile = [];
+
+    /**
+     * Input constructor.
+     * @param Request $request
+     */
+    public function __construct(Request $request)
+    {
+        $this->request = $request;
+
+        $this->parseInputs();
+    }
+
+    /**
+     * Parse input values
+     *
+     */
+    public function parseInputs(): void
+    {
+        /* Parse get requests */
+        if (count($_GET) !== 0) {
+            $this->originalParams = $_GET;
+            $this->get = $this->parseInputItem($this->originalParams);
+        }
+
+        /* Parse post requests */
+        $this->originalPost = $_POST;
+
+        if ($this->request->isPostBack() === true) {
+
+            $contents = file_get_contents('php://input');
+
+            // Append any PHP-input json
+            if (strpos(trim($contents), '{') === 0) {
+                $post = json_decode($contents, true);
+
+                if ($post !== false) {
+                    $this->originalPost += $post;
+                }
+            } else {
+                $post = [];
+                parse_str($contents, $post);
+                $this->originalPost += $post;
+            }
+        }
+
+        if (count($this->originalPost) !== 0) {
+            $this->post = $this->parseInputItem($this->originalPost);
+        }
+
+        /* Parse get requests */
+        if (count($_FILES) !== 0) {
+            $this->originalFile = $_FILES;
+            $this->file = $this->parseFiles($this->originalFile);
+        }
+    }
+
+    /**
+     * @param array $files Array with files to parse
+     * @param string|null $parentKey Key from parent (used when parsing nested array).
+     * @return array
+     */
+    public function parseFiles(array $files, ?string $parentKey = null): array
+    {
+        $list = [];
+
+        foreach ($files as $key => $value) {
+
+            // Parse multi dept file array
+            if (isset($value['name']) === false && is_array($value) === true) {
+                $list[$key] = $this->parseFiles($value, $key);
+                continue;
+            }
+
+            // Handle array input
+            if (is_array($value['name']) === false) {
+                $values = ['index' => $parentKey ?? $key];
+
+                try {
+                    $list[$key] = InputFile::createFromArray($values + $value);
+                } catch (InvalidArgumentException $e) {
+
+                }
+                continue;
+            }
+
+            $keys = [$key];
+            $files = $this->rearrangeFile($value['name'], $keys, $value);
+
+            if (isset($list[$key]) === true) {
+                $list[$key][] = $files;
+            } else {
+                $list[$key] = $files;
+            }
+
+        }
+
+        return $list;
+    }
+
+    /**
+     * Rearrange multi-dimensional file object created by PHP.
+     *
+     * @param array $values
+     * @param array $index
+     * @param array|null $original
+     * @return array
+     */
+    protected function rearrangeFile(array $values, array &$index, ?array $original): array
+    {
+        $originalIndex = $index[0];
+        array_shift($index);
+
+        $output = [];
+
+        foreach ($values as $key => $value) {
+
+            if (is_array($original['name'][$key]) === false) {
+
+                try {
+
+                    $file = InputFile::createFromArray([
+                        'index' => ($key === '' && $originalIndex !== '') ? $originalIndex : $key,
+                        'name' => $original['name'][$key],
+                        'error' => $original['error'][$key],
+                        'tmp_name' => $original['tmp_name'][$key],
+                        'type' => $original['type'][$key],
+                        'size' => $original['size'][$key],
+                    ]);
+
+                    if (isset($output[$key]) === true) {
+                        $output[$key][] = $file;
+                        continue;
+                    }
+
+                    $output[$key] = $file;
+                    continue;
+
+                } catch (InvalidArgumentException $e) {
+
+                }
+            }
+
+            $index[] = $key;
+
+            $files = $this->rearrangeFile($value, $index, $original);
+
+            if (isset($output[$key]) === true) {
+                $output[$key][] = $files;
+            } else {
+                $output[$key] = $files;
+            }
+
+        }
+
+        return $output;
+    }
+
+    /**
+     * Parse input item from array
+     *
+     * @param array $array
+     * @return array
+     */
+    protected function parseInputItem(array $array): array
+    {
+        $list = [];
+
+        foreach ($array as $key => $value) {
+
+            // Handle array input
+            if (is_array($value) === true) {
+                $value = $this->parseInputItem($value);
+            }
+
+            $list[$key] = new InputItem($key, $value);
+        }
+
+        return $list;
+    }
+
+    /**
+     * Find input object
+     *
+     * @param string $index
+     * @param array ...$methods
+     * @return IInputItem|array|null
+     */
+    public function find(string $index, ...$methods)
+    {
+        $element = null;
+
+        if (count($methods) > 0) {
+            $methods = is_array(...$methods) ? array_values(...$methods) : $methods;
+        }
+
+        if (count($methods) === 0 || in_array(Request::REQUEST_TYPE_GET, $methods, true) === true) {
+            $element = $this->get($index);
+        }
+
+        if (($element === null && count($methods) === 0) || (count($methods) !== 0 && in_array(Request::REQUEST_TYPE_POST, $methods, true) === true)) {
+            $element = $this->post($index);
+        }
+
+        if (($element === null && count($methods) === 0) || (count($methods) !== 0 && in_array('file', $methods, true) === true)) {
+            $element = $this->file($index);
+        }
+
+        return $element;
+    }
+
+    protected function getValueFromArray(array $array): array
+    {
+        $output = [];
+        /* @var $item InputItem */
+        foreach ($array as $key => $item) {
+
+            if ($item instanceof IInputItem) {
+                $item = $item->getValue();
+            }
+
+            $output[$key] = is_array($item) ? $this->getValueFromArray($item) : $item;
+        }
+
+        return $output;
+    }
+
+    /**
+     * Get input element value matching index
+     *
+     * @param string $index
+     * @param string|mixed|null $defaultValue
+     * @param array ...$methods
+     * @return string|array
+     */
+    public function value(string $index, $defaultValue = null, ...$methods)
+    {
+        $input = $this->find($index, ...$methods);
+
+        if ($input instanceof IInputItem) {
+            $input = $input->getValue();
+        }
+
+        /* Handle collection */
+        if (is_array($input) === true) {
+            $output = $this->getValueFromArray($input);
+
+            return (count($output) === 0) ? $defaultValue : $output;
+        }
+
+        return ($input === null || (is_string($input) && trim($input) === '')) ? $defaultValue : $input;
+    }
+
+    /**
+     * Check if a input-item exist.
+     * If an array is as $index parameter the method returns true if all elements exist.
+     *
+     * @param string|array $index
+     * @param array ...$methods
+     * @return bool
+     */
+    public function exists($index, ...$methods): bool
+    {
+        // Check array
+        if (is_array($index) === true) {
+            foreach ($index as $key) {
+                if ($this->value($key, null, ...$methods) === null) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        return $this->value($index, null, ...$methods) !== null;
+    }
+
+    /**
+     * Find post-value by index or return default value.
+     *
+     * @param string $index
+     * @param mixed|null $defaultValue
+     * @return InputItem|array|string|null
+     */
+    public function post(string $index, $defaultValue = null)
+    {
+        return $this->post[$index] ?? $defaultValue;
+    }
+
+    /**
+     * Find file by index or return default value.
+     *
+     * @param string $index
+     * @param mixed|null $defaultValue
+     * @return InputFile|array|string|null
+     */
+    public function file(string $index, $defaultValue = null)
+    {
+        return $this->file[$index] ?? $defaultValue;
+    }
+
+    /**
+     * Find parameter/query-string by index or return default value.
+     *
+     * @param string $index
+     * @param mixed|null $defaultValue
+     * @return InputItem|array|string|null
+     */
+    public function get(string $index, $defaultValue = null)
+    {
+        return $this->get[$index] ?? $defaultValue;
+    }
+
+    /**
+     * Get all get/post items
+     * @param array $filter Only take items in filter
+     * @return array
+     */
+    public function all(array $filter = []): array
+    {
+        $output = $this->originalParams + $this->originalPost + $this->originalFile;
+        $output = (count($filter) > 0) ? array_intersect_key($output, array_flip($filter)) : $output;
+
+        foreach ($filter as $filterKey) {
+            if (array_key_exists($filterKey, $output) === false) {
+                $output[$filterKey] = null;
+            }
+        }
+
+        return $output;
+    }
+
+    /**
+     * Add GET parameter
+     *
+     * @param string $key
+     * @param InputItem $item
+     */
+    public function addGet(string $key, InputItem $item): void
+    {
+        $this->get[$key] = $item;
+    }
+
+    /**
+     * Add POST parameter
+     *
+     * @param string $key
+     * @param InputItem $item
+     */
+    public function addPost(string $key, InputItem $item): void
+    {
+        $this->post[$key] = $item;
+    }
+
+    /**
+     * Add FILE parameter
+     *
+     * @param string $key
+     * @param InputFile $item
+     */
+    public function addFile(string $key, InputFile $item): void
+    {
+        $this->file[$key] = $item;
+    }
+
+    /**
+     * Get original post variables
+     * @return array
+     */
+    public function getOriginalPost(): array
+    {
+        return $this->originalPost;
+    }
+
+    /**
+     * Set original post variables
+     * @param array $post
+     * @return static $this
+     */
+    public function setOriginalPost(array $post): self
+    {
+        $this->originalPost = $post;
+
+        return $this;
+    }
+
+    /**
+     * Get original get variables
+     * @return array
+     */
+    public function getOriginalParams(): array
+    {
+        return $this->originalParams;
+    }
+
+    /**
+     * Set original get-variables
+     * @param array $params
+     * @return static $this
+     */
+    public function setOriginalParams(array $params): self
+    {
+        $this->originalParams = $params;
+
+        return $this;
+    }
+
+    /**
+     * Get original file variables
+     * @return array
+     */
+    public function getOriginalFile(): array
+    {
+        return $this->originalFile;
+    }
+
+    /**
+     * Set original file posts variables
+     * @param array $file
+     * @return static $this
+     */
+    public function setOriginalFile(array $file): self
+    {
+        $this->originalFile = $file;
+
+        return $this;
+    }
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Input/InputItem.php

@@ -0,0 +1,123 @@
+<?php
+
+namespace Pecee\Http\Input;
+
+use ArrayAccess;
+use ArrayIterator;
+use IteratorAggregate;
+
+class InputItem implements ArrayAccess, IInputItem, IteratorAggregate
+{
+    public string $index;
+    public string $name;
+
+    /**
+     * @var mixed|null
+     */
+    public $value;
+
+    /**
+     * @param string $index
+     * @param mixed $value
+     */
+    public function __construct(string $index, $value = null)
+    {
+        $this->index = $index;
+        $this->value = $value;
+
+        // Make the name human friendly, by replace _ with space
+        $this->name = ucfirst(str_replace('_', ' ', strtolower($this->index)));
+    }
+
+    /**
+     * @return string
+     */
+    public function getIndex(): string
+    {
+        return $this->index;
+    }
+
+    public function setIndex(string $index): IInputItem
+    {
+        $this->index = $index;
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getName(): ?string
+    {
+        return $this->name;
+    }
+
+    /**
+     * Set input name
+     * @param string $name
+     * @return static
+     */
+    public function setName(string $name): IInputItem
+    {
+        $this->name = $name;
+
+        return $this;
+    }
+
+    /**
+     * @return mixed
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Set input value
+     * @param mixed $value
+     * @return static
+     */
+    public function setValue($value): IInputItem
+    {
+        $this->value = $value;
+
+        return $this;
+    }
+
+    public function offsetExists($offset): bool
+    {
+        return isset($this->value[$offset]);
+    }
+
+    #[\ReturnTypeWillChange]
+    public function offsetGet($offset): ?self
+    {
+        if ($this->offsetExists($offset) === true) {
+            return $this->value[$offset];
+        }
+
+        return null;
+    }
+
+    public function offsetSet($offset, $value): void
+    {
+        $this->value[$offset] = $value;
+    }
+
+    public function offsetUnset($offset): void
+    {
+        unset($this->value[$offset]);
+    }
+
+    public function __toString(): string
+    {
+        $value = $this->getValue();
+
+        return (is_array($value) === true) ? json_encode($value) : $value;
+    }
+
+    public function getIterator(): ArrayIterator
+    {
+        return new ArrayIterator($this->getValue());
+    }
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Middleware/BaseCsrfVerifier.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Pecee\Http\Middleware;
+
+use Pecee\Http\Middleware\Exceptions\TokenMismatchException;
+use Pecee\Http\Request;
+use Pecee\Http\Security\CookieTokenProvider;
+use Pecee\Http\Security\ITokenProvider;
+
+class BaseCsrfVerifier implements IMiddleware
+{
+    public const POST_KEY = 'csrf_token';
+    public const HEADER_KEY = 'X-CSRF-TOKEN';
+
+    /**
+     * Urls to ignore. You can use * to exclude all sub-urls on a given path.
+     * For example: /admin/*
+     * @var array|null
+     */
+    protected array $except = [];
+
+    /**
+     * Urls to include. Can be used to include urls from a certain path.
+     * @var array|null
+     */
+    protected array $include = [];
+
+    /**
+     * @var ITokenProvider
+     */
+    protected ITokenProvider $tokenProvider;
+
+    /**
+     * BaseCsrfVerifier constructor.
+     */
+    public function __construct()
+    {
+        $this->tokenProvider = new CookieTokenProvider();
+    }
+
+    protected function isIncluded(Request $request): bool
+    {
+        if (count($this->include) > 0) {
+            foreach ($this->include as $includeUrl) {
+                $includeUrl = rtrim($includeUrl, '/');
+                if ($includeUrl[strlen($includeUrl) - 1] === '*') {
+                    $includeUrl = rtrim($includeUrl, '*');
+                    return $request->getUrl()->contains($includeUrl);
+                }
+
+                return ($includeUrl === rtrim($request->getUrl()->getRelativeUrl(false), '/'));
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if the url matches the urls in the except property
+     * @param Request $request
+     * @return bool
+     */
+    protected function skip(Request $request): bool
+    {
+        if (count($this->except) === 0) {
+            return false;
+        }
+
+        foreach ($this->except as $url) {
+            $url = rtrim($url, '/');
+            if ($url[strlen($url) - 1] === '*') {
+                $url = rtrim($url, '*');
+                $skip = $request->getUrl()->contains($url);
+            } else {
+                $skip = ($url === rtrim($request->getUrl()->getRelativeUrl(false), '/'));
+            }
+
+            if ($skip === true) {
+
+                $skip = !$this->isIncluded($request);
+
+                if ($skip === false) {
+                    continue;
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Handle request
+     *
+     * @param Request $request
+     * @throws TokenMismatchException
+     */
+    public function handle(Request $request): void
+    {
+        if ($this->skip($request) === false && ($request->isPostBack() === true || $request->isPostBack() === true && $this->isIncluded($request) === true)) {
+
+            $token = $request->getInputHandler()->value(
+                static::POST_KEY,
+                $request->getHeader(static::HEADER_KEY),
+            );
+
+            if ($this->tokenProvider->validate((string)$token) === false) {
+                throw new TokenMismatchException('Invalid CSRF-token.');
+            }
+
+        }
+
+        // Refresh existing token
+        $this->tokenProvider->refresh();
+    }
+
+    public function getTokenProvider(): ITokenProvider
+    {
+        return $this->tokenProvider;
+    }
+
+    /**
+     * Set token provider
+     * @param ITokenProvider $provider
+     */
+    public function setTokenProvider(ITokenProvider $provider): void
+    {
+        $this->tokenProvider = $provider;
+    }
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Middleware/Exceptions/TokenMismatchException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Pecee\Http\Middleware\Exceptions;
+
+use Exception;
+
+class TokenMismatchException extends Exception
+{
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Middleware/IMiddleware.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Pecee\Http\Middleware;
+
+use Pecee\Http\Request;
+
+interface IMiddleware
+{
+    /**
+     * @param Request $request
+     */
+    public function handle(Request $request): void;
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Middleware/IpRestrictAccess.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Pecee\Http\Middleware;
+
+use Pecee\Http\Request;
+use Pecee\SimpleRouter\Exceptions\HttpException;
+
+abstract class IpRestrictAccess implements IMiddleware
+{
+    protected array $ipBlacklist = [];
+    protected array $ipWhitelist = [];
+
+    protected function validate(string $ip): bool
+    {
+        // Accept ip that is in white-list
+        if(in_array($ip, $this->ipWhitelist, true) === true) {
+            return true;
+        }
+
+        foreach ($this->ipBlacklist as $blackIp) {
+
+            // Blocks range (8.8.*)
+            if ($blackIp[strlen($blackIp) - 1] === '*' && strpos($ip, trim($blackIp, '*')) === 0) {
+                return false;
+            }
+
+            // Blocks exact match
+            if ($blackIp === $ip) {
+                return false;
+            }
+
+        }
+
+        return true;
+    }
+
+    /**
+     * @param Request $request
+     * @throws HttpException
+     */
+    public function handle(Request $request): void
+    {
+        if($this->validate((string)$request->getIp()) === false) {
+            throw new HttpException(sprintf('Restricted ip. Access to %s has been blocked', $request->getIp()), 403);
+        }
+    }
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Request.php

@@ -0,0 +1,564 @@
+<?php
+
+namespace Pecee\Http;
+
+use Pecee\Http\Exceptions\MalformedUrlException;
+use Pecee\Http\Input\InputHandler;
+use Pecee\Http\Middleware\BaseCsrfVerifier;
+use Pecee\SimpleRouter\Route\ILoadableRoute;
+use Pecee\SimpleRouter\Route\RouteUrl;
+use Pecee\SimpleRouter\SimpleRouter;
+
+class Request
+{
+    public const REQUEST_TYPE_GET = 'get';
+    public const REQUEST_TYPE_POST = 'post';
+    public const REQUEST_TYPE_PUT = 'put';
+    public const REQUEST_TYPE_PATCH = 'patch';
+    public const REQUEST_TYPE_OPTIONS = 'options';
+    public const REQUEST_TYPE_DELETE = 'delete';
+    public const REQUEST_TYPE_HEAD = 'head';
+
+    public const CONTENT_TYPE_JSON = 'application/json';
+    public const CONTENT_TYPE_FORM_DATA = 'multipart/form-data';
+    public const CONTENT_TYPE_X_FORM_ENCODED = 'application/x-www-form-urlencoded';
+
+    public const FORCE_METHOD_KEY = '_method';
+
+    /**
+     * All request-types
+     * @var string[]
+     */
+    public static array $requestTypes = [
+        self::REQUEST_TYPE_GET,
+        self::REQUEST_TYPE_POST,
+        self::REQUEST_TYPE_PUT,
+        self::REQUEST_TYPE_PATCH,
+        self::REQUEST_TYPE_OPTIONS,
+        self::REQUEST_TYPE_DELETE,
+        self::REQUEST_TYPE_HEAD,
+    ];
+
+    /**
+     * Post request-types.
+     * @var string[]
+     */
+    public static array $requestTypesPost = [
+        self::REQUEST_TYPE_POST,
+        self::REQUEST_TYPE_PUT,
+        self::REQUEST_TYPE_PATCH,
+        self::REQUEST_TYPE_DELETE,
+    ];
+
+    /**
+     * Additional data
+     *
+     * @var array
+     */
+    private array $data = [];
+
+    /**
+     * Server headers
+     * @var array
+     */
+    protected array $headers = [];
+
+    /**
+     * Request ContentType
+     * @var string
+     */
+    protected string $contentType;
+
+    /**
+     * Request host
+     * @var string|null
+     */
+    protected ?string $host;
+
+    /**
+     * Current request url
+     * @var Url
+     */
+    protected Url $url;
+
+    /**
+     * Request method
+     * @var string
+     */
+    protected string $method;
+
+    /**
+     * Input handler
+     * @var InputHandler
+     */
+    protected InputHandler $inputHandler;
+
+    /**
+     * Defines if request has pending rewrite
+     * @var bool
+     */
+    protected bool $hasPendingRewrite = false;
+
+    /**
+     * @var ILoadableRoute|null
+     */
+    protected ?ILoadableRoute $rewriteRoute = null;
+
+    /**
+     * Rewrite url
+     * @var string|null
+     */
+    protected ?string $rewriteUrl = null;
+
+    /**
+     * @var array
+     */
+    protected array $loadedRoutes = [];
+
+    /**
+     * Request constructor.
+     * @throws MalformedUrlException
+     */
+    public function __construct()
+    {
+        foreach ($_SERVER as $key => $value) {
+            $this->headers[strtolower($key)] = $value;
+            $this->headers[str_replace('_', '-', strtolower($key))] = $value;
+        }
+
+        $this->setHost($this->getHeader('http-host'));
+
+        // Check if special IIS header exist, otherwise use default.
+        $url = $this->getHeader('unencoded-url');
+        if ($url !== null) {
+            $this->setUrl(new Url($url));
+        } else {
+            $this->setUrl(new Url(urldecode((string)$this->getHeader('request-uri'))));
+        }
+        $this->setContentType((string)$this->getHeader('content-type'));
+        $this->setMethod((string)($_POST[static::FORCE_METHOD_KEY] ?? $this->getHeader('request-method')));
+        $this->inputHandler = new InputHandler($this);
+    }
+
+    public function isSecure(): bool
+    {
+        return $this->getHeader('http-x-forwarded-proto') === 'https' || $this->getHeader('https') !== null || (int)$this->getHeader('server-port') === 443;
+    }
+
+    /**
+     * @return Url
+     */
+    public function getUrl(): Url
+    {
+        return $this->url;
+    }
+
+    /**
+     * Copy url object
+     *
+     * @return Url
+     */
+    public function getUrlCopy(): Url
+    {
+        return clone $this->url;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getHost(): ?string
+    {
+        return $this->host;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getMethod(): ?string
+    {
+        return $this->method;
+    }
+
+    /**
+     * Get http basic auth user
+     * @return string|null
+     */
+    public function getUser(): ?string
+    {
+        return $this->getHeader('php-auth-user');
+    }
+
+    /**
+     * Get http basic auth password
+     * @return string|null
+     */
+    public function getPassword(): ?string
+    {
+        return $this->getHeader('php-auth-pw');
+    }
+
+    /**
+     * Get the csrf token
+     * @return string|null
+     */
+    public function getCsrfToken(): ?string
+    {
+        return $this->getHeader(BaseCsrfVerifier::HEADER_KEY);
+    }
+
+    /**
+     * Get all headers
+     * @return array
+     */
+    public function getHeaders(): array
+    {
+        return $this->headers;
+    }
+
+    /**
+     * Get id address
+     * If $safe is false, this function will detect Proxys. But the user can edit this header to whatever he wants!
+     * https://stackoverflow.com/questions/3003145/how-to-get-the-client-ip-address-in-php#comment-25086804
+     * @param bool $safeMode When enabled, only safe non-spoofable headers will be returned. Note this can cause issues when using proxy.
+     * @return string|null
+     */
+    public function getIp(bool $safeMode = false): ?string
+    {
+        $headers = [];
+        if ($safeMode === false) {
+            $headers = [
+                'http-cf-connecting-ip',
+                'http-client-ip',
+                'http-x-forwarded-for',
+            ];
+        }
+
+        $headers[] = 'remote-addr';
+
+        return $this->getFirstHeader($headers);
+    }
+
+    /**
+     * Get remote address/ip
+     *
+     * @alias static::getIp
+     * @return string|null
+     */
+    public function getRemoteAddr(): ?string
+    {
+        return $this->getIp();
+    }
+
+    /**
+     * Get referer
+     * @return string|null
+     */
+    public function getReferer(): ?string
+    {
+        return $this->getHeader('http-referer');
+    }
+
+    /**
+     * Get user agent
+     * @return string|null
+     */
+    public function getUserAgent(): ?string
+    {
+        return $this->getHeader('http-user-agent');
+    }
+
+    /**
+     * Get header value by name
+     *
+     * @param string $name Name of the header.
+     * @param string|mixed|null $defaultValue Value to be returned if header is not found.
+     * @param bool $tryParse When enabled the method will try to find the header from both from client (http) and server-side variants, if the header is not found.
+     *
+     * @return string|null
+     */
+    public function getHeader(string $name, $defaultValue = null, bool $tryParse = true): ?string
+    {
+        $name = strtolower($name);
+        $header = $this->headers[$name] ?? null;
+
+        if ($tryParse === true && $header === null) {
+            if (strpos($name, 'http-') === 0) {
+                // Trying to find client header variant which was not found, searching for header variant without http- prefix.
+                $header = $this->headers[str_replace('http-', '', $name)] ?? null;
+            } else {
+                // Trying to find server variant which was not found, searching for client variant with http- prefix.
+                $header = $this->headers['http-' . $name] ?? null;
+            }
+        }
+
+        return $header ?? $defaultValue;
+    }
+
+    /**
+     * Will try to find first header from list of headers.
+     *
+     * @param array $headers
+     * @param mixed|null $defaultValue
+     * @return mixed|null
+     */
+    public function getFirstHeader(array $headers, $defaultValue = null)
+    {
+        foreach ($headers as $header) {
+            $header = $this->getHeader($header);
+            if ($header !== null) {
+                return $header;
+            }
+        }
+
+        return $defaultValue;
+    }
+
+    /**
+     * Get request content-type
+     * @return string|null
+     */
+    public function getContentType(): ?string
+    {
+        return $this->contentType;
+    }
+
+    /**
+     * Set request content-type
+     * @param string $contentType
+     * @return $this
+     */
+    protected function setContentType(string $contentType): self
+    {
+        if (strpos($contentType, ';') > 0) {
+            $this->contentType = strtolower(substr($contentType, 0, strpos($contentType, ';')));
+        } else {
+            $this->contentType = strtolower($contentType);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get input class
+     * @return InputHandler
+     */
+    public function getInputHandler(): InputHandler
+    {
+        return $this->inputHandler;
+    }
+
+    /**
+     * Is format accepted
+     *
+     * @param string $format
+     *
+     * @return bool
+     */
+    public function isFormatAccepted(string $format): bool
+    {
+        return ($this->getHeader('http-accept') !== null && stripos($this->getHeader('http-accept'), $format) !== false);
+    }
+
+    /**
+     * Returns true if the request is made through Ajax
+     *
+     * @return bool
+     */
+    public function isAjax(): bool
+    {
+        return (strtolower((string)$this->getHeader('http-x-requested-with')) === 'xmlhttprequest');
+    }
+
+    /**
+     * Returns true when request-method is type that could contain data in the page body.
+     *
+     * @return bool
+     */
+    public function isPostBack(): bool
+    {
+        return in_array($this->getMethod(), static::$requestTypesPost, true);
+    }
+
+    /**
+     * Get accept formats
+     * @return array
+     */
+    public function getAcceptFormats(): array
+    {
+        return explode(',', $this->getHeader('http-accept'));
+    }
+
+    /**
+     * @param Url $url
+     */
+    public function setUrl(Url $url): void
+    {
+        $this->url = $url;
+
+        if ($this->isSecure() === true) {
+            $this->url->setScheme('https');
+        }
+    }
+
+    /**
+     * @param string|null $host
+     */
+    public function setHost(?string $host): void
+    {
+        // Strip any potential ports from hostname
+        if (strpos((string)$host, ':') !== false) {
+            $host = strstr($host, strrchr($host, ':'), true);
+        }
+
+        $this->host = $host;
+    }
+
+    /**
+     * @param string $method
+     */
+    public function setMethod(string $method): void
+    {
+        $this->method = strtolower($method);
+    }
+
+    /**
+     * Set rewrite route
+     *
+     * @param ILoadableRoute $route
+     * @return static
+     */
+    public function setRewriteRoute(ILoadableRoute $route): self
+    {
+        $this->hasPendingRewrite = true;
+        $this->rewriteRoute = SimpleRouter::addDefaultNamespace($route);
+
+        return $this;
+    }
+
+    /**
+     * Get rewrite route
+     *
+     * @return ILoadableRoute|null
+     */
+    public function getRewriteRoute(): ?ILoadableRoute
+    {
+        return $this->rewriteRoute;
+    }
+
+    /**
+     * Get rewrite url
+     *
+     * @return string|null
+     */
+    public function getRewriteUrl(): ?string
+    {
+        return $this->rewriteUrl;
+    }
+
+    /**
+     * Set rewrite url
+     *
+     * @param string $rewriteUrl
+     * @return static
+     */
+    public function setRewriteUrl(string $rewriteUrl): self
+    {
+        $this->hasPendingRewrite = true;
+        $this->rewriteUrl = rtrim($rewriteUrl, '/') . '/';
+
+        return $this;
+    }
+
+    /**
+     * Set rewrite callback
+     * @param string|\Closure $callback
+     * @return static
+     */
+    public function setRewriteCallback($callback): self
+    {
+        $this->hasPendingRewrite = true;
+
+        return $this->setRewriteRoute(new RouteUrl($this->getUrl()->getPath(), $callback));
+    }
+
+    /**
+     * Get loaded route
+     * @return ILoadableRoute|null
+     */
+    public function getLoadedRoute(): ?ILoadableRoute
+    {
+        return (count($this->loadedRoutes) > 0) ? end($this->loadedRoutes) : null;
+    }
+
+    /**
+     * Get all loaded routes
+     *
+     * @return array
+     */
+    public function getLoadedRoutes(): array
+    {
+        return $this->loadedRoutes;
+    }
+
+    /**
+     * Set loaded routes
+     *
+     * @param array $routes
+     * @return static
+     */
+    public function setLoadedRoutes(array $routes): self
+    {
+        $this->loadedRoutes = $routes;
+        return $this;
+    }
+
+    /**
+     * Added loaded route
+     *
+     * @param ILoadableRoute $route
+     * @return static
+     */
+    public function addLoadedRoute(ILoadableRoute $route): self
+    {
+        $this->loadedRoutes[] = $route;
+        return $this;
+    }
+
+    /**
+     * Returns true if the request contains a rewrite
+     *
+     * @return bool
+     */
+    public function hasPendingRewrite(): bool
+    {
+        return $this->hasPendingRewrite;
+    }
+
+    /**
+     * Defines if the current request contains a rewrite.
+     *
+     * @param bool $boolean
+     * @return Request
+     */
+    public function setHasPendingRewrite(bool $boolean): self
+    {
+        $this->hasPendingRewrite = $boolean;
+        return $this;
+    }
+
+    public function __isset($name): bool
+    {
+        return array_key_exists($name, $this->data) === true;
+    }
+
+    public function __set($name, $value = null)
+    {
+        $this->data[$name] = $value;
+    }
+
+    public function __get($name)
+    {
+        return $this->data[$name] ?? null;
+    }
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Response.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Pecee\Http;
+
+use JsonSerializable;
+use Pecee\Exceptions\InvalidArgumentException;
+
+class Response
+{
+    protected Request $request;
+
+    public function __construct(Request $request)
+    {
+        $this->request = $request;
+    }
+
+    /**
+     * Set the http status code
+     *
+     * @param int $code
+     * @return static
+     */
+    public function httpCode(int $code): self
+    {
+        http_response_code($code);
+
+        return $this;
+    }
+
+    /**
+     * Redirect the response
+     *
+     * @param string $url
+     * @param ?int $httpCode
+     *
+     * @return never
+     */
+    public function redirect(string $url, ?int $httpCode = null): void
+    {
+        if ($httpCode !== null) {
+            $this->httpCode($httpCode);
+        }
+
+        $this->header('location: ' . $url);
+        exit(0);
+    }
+
+    public function refresh(): void
+    {
+        $this->redirect($this->request->getUrl()->getOriginalUrl());
+    }
+
+    /**
+     * Add http authorisation
+     * @param string $name
+     * @return static
+     */
+    public function auth(string $name = ''): self
+    {
+        $this->headers([
+            'WWW-Authenticate: Basic realm="' . $name . '"',
+            'HTTP/1.0 401 Unauthorized',
+        ]);
+
+        return $this;
+    }
+
+    public function cache(string $eTag, int $lastModifiedTime = 2592000): self
+    {
+        $this->headers([
+            'Cache-Control: public',
+            sprintf('Last-Modified: %s GMT', gmdate('D, d M Y H:i:s', $lastModifiedTime)),
+            sprintf('Etag: %s', $eTag),
+        ]);
+
+        $httpModified = $this->request->getHeader('http-if-modified-since');
+        $httpIfNoneMatch = $this->request->getHeader('http-if-none-match');
+
+        if (($httpIfNoneMatch !== null && $httpIfNoneMatch === $eTag) || ($httpModified !== null && strtotime($httpModified) === $lastModifiedTime)) {
+
+            $this->header('HTTP/1.1 304 Not Modified');
+            exit(0);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Json encode
+     * @param array|JsonSerializable $value
+     * @param int $options JSON options Bitmask consisting of JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT, JSON_PRESERVE_ZERO_FRACTION, JSON_UNESCAPED_UNICODE, JSON_PARTIAL_OUTPUT_ON_ERROR.
+     * @param int $dept JSON debt.
+     * @throws InvalidArgumentException
+     */
+    public function json($value, int $options = 0, int $dept = 512): void
+    {
+        if (($value instanceof JsonSerializable) === false && is_array($value) === false) {
+            throw new InvalidArgumentException('Invalid type for parameter "value". Must be of type array or object implementing the \JsonSerializable interface.');
+        }
+
+        $this->header('Content-Type: application/json; charset=utf-8');
+        echo json_encode($value, $options, $dept);
+        exit(0);
+    }
+
+    /**
+     * Add header to response
+     * @param string $value
+     * @return static
+     */
+    public function header(string $value): self
+    {
+        header($value);
+
+        return $this;
+    }
+
+    /**
+     * Add multiple headers to response
+     * @param array $headers
+     * @return static
+     */
+    public function headers(array $headers): self
+    {
+        foreach ($headers as $header) {
+            $this->header($header);
+        }
+
+        return $this;
+    }
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Security/CookieTokenProvider.php

@@ -0,0 +1,124 @@
+<?php
+
+namespace Pecee\Http\Security;
+
+use Exception;
+use Pecee\Http\Security\Exceptions\SecurityException;
+
+class CookieTokenProvider implements ITokenProvider
+{
+    public const CSRF_KEY = 'CSRF-TOKEN';
+
+    /**
+     * @var string
+     */
+    protected ?string $token = null;
+
+    /**
+     * @var int
+     */
+    protected int $cookieTimeoutMinutes = 120;
+
+    /**
+     * CookieTokenProvider constructor.
+     * @throws SecurityException
+     */
+    public function __construct()
+    {
+        $this->token = ($this->hasToken() === true) ? $_COOKIE[static::CSRF_KEY] : null;
+
+        if ($this->token === null) {
+            $this->token = $this->generateToken();
+        }
+    }
+
+    /**
+     * Generate random identifier for CSRF token
+     *
+     * @return string
+     * @throws SecurityException
+     */
+    public function generateToken(): string
+    {
+        try {
+            return bin2hex(random_bytes(32));
+        } catch (Exception $e) {
+            throw new SecurityException($e->getMessage(), (int)$e->getCode(), $e->getPrevious());
+        }
+    }
+
+    /**
+     * Validate valid CSRF token
+     *
+     * @param string $token
+     * @return bool
+     */
+    public function validate(string $token): bool
+    {
+        if ($this->getToken() !== null) {
+            return hash_equals($token, $this->getToken());
+        }
+
+        return false;
+    }
+
+    /**
+     * Set csrf token cookie
+     * Overwrite this method to save the token to another storage like session etc.
+     *
+     * @param string $token
+     */
+    public function setToken(string $token): void
+    {
+        $this->token = $token;
+        setcookie(static::CSRF_KEY, $token, time() + (60 * $this->cookieTimeoutMinutes), '/', ini_get('session.cookie_domain'), ini_get('session.cookie_secure'), ini_get('session.cookie_httponly'));
+    }
+
+    /**
+     * Get csrf token
+     * @param string|null $defaultValue
+     * @return string|null
+     */
+    public function getToken(?string $defaultValue = null): ?string
+    {
+        return $this->token ?? $defaultValue;
+    }
+
+    /**
+     * Refresh existing token
+     */
+    public function refresh(): void
+    {
+        if ($this->token !== null) {
+            $this->setToken($this->token);
+        }
+    }
+
+    /**
+     * Returns whether the csrf token has been defined
+     * @return bool
+     */
+    public function hasToken(): bool
+    {
+        return isset($_COOKIE[static::CSRF_KEY]);
+    }
+
+    /**
+     * Get timeout for cookie in minutes
+     * @return int
+     */
+    public function getCookieTimeoutMinutes(): int
+    {
+        return $this->cookieTimeoutMinutes;
+    }
+
+    /**
+     * Set cookie timeout in minutes
+     * @param int $minutes
+     */
+    public function setCookieTimeoutMinutes(int $minutes): void
+    {
+        $this->cookieTimeoutMinutes = $minutes;
+    }
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Security/Exceptions/SecurityException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Pecee\Http\Security\Exceptions;
+
+use Exception;
+
+class SecurityException extends Exception
+{
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Security/ITokenProvider.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Pecee\Http\Security;
+
+interface ITokenProvider
+{
+
+    /**
+     * Refresh existing token
+     */
+    public function refresh(): void;
+
+    /**
+     * Validate valid CSRF token
+     *
+     * @param string $token
+     * @return bool
+     */
+    public function validate(string $token): bool;
+
+    /**
+     * Get token token
+     *
+     * @param string|null $defaultValue
+     * @return string|null
+     */
+    public function getToken(?string $defaultValue = null): ?string;
+
+}

exam/vendor/pecee/simple-router/src/Pecee/Http/Url.php

@@ -0,0 +1,547 @@
+<?php
+
+namespace Pecee\Http;
+
+use JsonSerializable;
+use Pecee\Http\Exceptions\MalformedUrlException;
+
+class Url implements JsonSerializable
+{
+    /**
+     * @var string|null
+     */
+    private ?string $originalUrl = null;
+
+    /**
+     * @var string|null
+     */
+    private ?string $scheme = null;
+
+    /**
+     * @var string|null
+     */
+    private ?string $host = null;
+
+    /**
+     * @var int|null
+     */
+    private ?int $port = null;
+
+    /**
+     * @var string|null
+     */
+    private ?string $username = null;
+
+    /**
+     * @var string|null
+     */
+    private ?string $password = null;
+
+    /**
+     * @var string|null
+     */
+    private ?string $path = null;
+
+    /**
+     * Original path with no sanitization to ending slash
+     * @var string|null
+     */
+    private ?string $originalPath = null;
+
+    /**
+     * @var array
+     */
+    private array $params = [];
+
+    /**
+     * @var string|null
+     */
+    private ?string $fragment = null;
+
+    /**
+     * Url constructor.
+     *
+     * @param ?string $url
+     * @throws MalformedUrlException
+     */
+    public function __construct(?string $url)
+    {
+        $this->originalUrl = $url;
+        $this->parse($url, true);
+    }
+
+    public function parse(?string $url, bool $setOriginalPath = false): self
+    {
+        if ($url !== null) {
+            $data = $this->parseUrl($url);
+
+            $this->scheme = $data['scheme'] ?? null;
+            $this->host = $data['host'] ?? null;
+            $this->port = $data['port'] ?? null;
+            $this->username = $data['user'] ?? null;
+            $this->password = $data['pass'] ?? null;
+
+            if (isset($data['path']) === true) {
+                $this->setPath($data['path']);
+
+                if ($setOriginalPath === true) {
+                    $this->originalPath = $data['path'];
+                }
+            }
+
+            $this->fragment = $data['fragment'] ?? null;
+
+            if (isset($data['query']) === true) {
+                $this->setQueryString($data['query']);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Check if url is using a secure protocol like https
+     *
+     * @return bool
+     */
+    public function isSecure(): bool
+    {
+        return (strtolower($this->getScheme()) === 'https');
+    }
+
+    /**
+     * Checks if url is relative
+     *
+     * @return bool
+     */
+    public function isRelative(): bool
+    {
+        return ($this->getHost() === null);
+    }
+
+    /**
+     * Get url scheme
+     *
+     * @return string|null
+     */
+    public function getScheme(): ?string
+    {
+        return $this->scheme;
+    }
+
+    /**
+     * Set the scheme of the url
+     *
+     * @param string $scheme
+     * @return static
+     */
+    public function setScheme(string $scheme): self
+    {
+        $this->scheme = $scheme;
+
+        return $this;
+    }
+
+    /**
+     * Get url host
+     *
+     * @param bool $includeTrails Prepend // in front of hostname
+     * @return string|null
+     */
+    public function getHost(bool $includeTrails = false): ?string
+    {
+        if ((string)$this->host !== '' && $includeTrails === true) {
+            return '//' . $this->host;
+        }
+
+        return $this->host;
+    }
+
+    /**
+     * Set the host of the url
+     *
+     * @param string $host
+     * @return static
+     */
+    public function setHost(string $host): self
+    {
+        $this->host = $host;
+
+        return $this;
+    }
+
+    /**
+     * Get url port
+     *
+     * @return int|null
+     */
+    public function getPort(): ?int
+    {
+        return ($this->port !== null) ? (int)$this->port : null;
+    }
+
+    /**
+     * Set the port of the url
+     *
+     * @param int $port
+     * @return static
+     */
+    public function setPort(int $port): self
+    {
+        $this->port = $port;
+
+        return $this;
+    }
+
+    /**
+     * Parse username from url
+     *
+     * @return string|null
+     */
+    public function getUsername(): ?string
+    {
+        return $this->username;
+    }
+
+    /**
+     * Set the username of the url
+     *
+     * @param string $username
+     * @return static
+     */
+    public function setUsername(string $username): self
+    {
+        $this->username = $username;
+
+        return $this;
+    }
+
+    /**
+     * Parse password from url
+     * @return string|null
+     */
+    public function getPassword(): ?string
+    {
+        return $this->password;
+    }
+
+    /**
+     * Set the url password
+     *
+     * @param string $password
+     * @return static
+     */
+    public function setPassword(string $password): self
+    {
+        $this->password = $password;
+
+        return $this;
+    }
+
+    /**
+     * Get path from url
+     * @return string
+     */
+    public function getPath(): ?string
+    {
+        return $this->path ?? '/';
+    }
+
+    /**
+     * Get original path with no sanitization of ending trail/slash.
+     * @return string|null
+     */
+    public function getOriginalPath(): ?string
+    {
+        return $this->originalPath;
+    }
+
+    /**
+     * Set the url path
+     *
+     * @param string $path
+     * @return static
+     */
+    public function setPath(string $path): self
+    {
+        $this->path = rtrim($path, '/') . '/';
+
+        return $this;
+    }
+
+    /**
+     * Get query-string from url
+     *
+     * @return array
+     */
+    public function getParams(): array
+    {
+        return $this->params;
+    }
+
+    /**
+     * Merge parameters array
+     *
+     * @param array $params
+     * @return static
+     */
+    public function mergeParams(array $params): self
+    {
+        return $this->setParams(array_merge($this->getParams(), $params));
+    }
+
+    /**
+     * Set the url params
+     *
+     * @param array $params
+     * @return static
+     */
+    public function setParams(array $params): self
+    {
+        $this->params = $params;
+
+        return $this;
+    }
+
+    /**
+     * Set raw query-string parameters as string
+     *
+     * @param string $queryString
+     * @return static
+     */
+    public function setQueryString(string $queryString): self
+    {
+        $params = [];
+        parse_str($queryString, $params);
+
+        if (count($params) > 0) {
+            return $this->setParams($params);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get query-string params as string
+     *
+     * @return string
+     */
+    public function getQueryString(): string
+    {
+        return static::arrayToParams($this->getParams());
+    }
+
+    /**
+     * Get fragment from url (everything after #)
+     *
+     * @return string|null
+     */
+    public function getFragment(): ?string
+    {
+        return $this->fragment;
+    }
+
+    /**
+     * Set url fragment
+     *
+     * @param string $fragment
+     * @return static
+     */
+    public function setFragment(string $fragment): self
+    {
+        $this->fragment = $fragment;
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getOriginalUrl(): string
+    {
+        return $this->originalUrl;
+    }
+
+    /**
+     * Get position of value.
+     * Returns -1 on failure.
+     *
+     * @param string $value
+     * @return int
+     */
+    public function indexOf(string $value): int
+    {
+        $index = stripos($this->getOriginalUrl(), $value);
+
+        return ($index === false) ? -1 : $index;
+    }
+
+    /**
+     * Check if url contains value.
+     *
+     * @param string $value
+     * @return bool
+     */
+    public function contains(string $value): bool
+    {
+        return (stripos($this->getOriginalUrl(), $value) !== false);
+    }
+
+    /**
+     * Check if url contains parameter/query string.
+     *
+     * @param string $name
+     * @return bool
+     */
+    public function hasParam(string $name): bool
+    {
+        return array_key_exists($name, $this->getParams());
+    }
+
+    /**
+     * Removes multiple parameters from the query-string
+     *
+     * @param array ...$names
+     * @return static
+     */
+    public function removeParams(...$names): self
+    {
+        $params = array_diff_key($this->getParams(), array_flip(...$names));
+        $this->setParams($params);
+
+        return $this;
+    }
+
+    /**
+     * Removes parameter from the query-string
+     *
+     * @param string $name
+     * @return static
+     */
+    public function removeParam(string $name): self
+    {
+        $params = $this->getParams();
+        unset($params[$name]);
+        $this->setParams($params);
+
+        return $this;
+    }
+
+    /**
+     * Get parameter by name.
+     * Returns parameter value or default value.
+     *
+     * @param string $name
+     * @param string|null $defaultValue
+     * @return string|null
+     */
+    public function getParam(string $name, ?string $defaultValue = null): ?string
+    {
+        return (isset($this->getParams()[$name]) === true) ? $this->getParams()[$name] : $defaultValue;
+    }
+
+    /**
+     * UTF-8 aware parse_url() replacement.
+     * @param string $url
+     * @param int $component
+     * @return array
+     * @throws MalformedUrlException
+     */
+    public function parseUrl(string $url, int $component = -1): array
+    {
+        $encodedUrl = preg_replace_callback(
+            '/[^:\/@?&=#]+/u',
+            static function ($matches): string {
+                return urlencode($matches[0]);
+            },
+            $url
+        );
+
+        $parts = parse_url($encodedUrl, $component);
+
+        if ($parts === false) {
+            throw new MalformedUrlException(sprintf('Failed to parse url: "%s"', $url));
+        }
+
+        return array_map('urldecode', $parts);
+    }
+
+    /**
+     * Convert array to query-string params
+     *
+     * @param array $getParams
+     * @param bool $includeEmpty
+     * @return string
+     */
+    public static function arrayToParams(array $getParams = [], bool $includeEmpty = true): string
+    {
+        if (count($getParams) !== 0) {
+
+            if ($includeEmpty === false) {
+                $getParams = array_filter($getParams, static function ($item): bool {
+                    return (trim($item) !== '');
+                });
+            }
+
+            return http_build_query($getParams);
+        }
+
+        return '';
+    }
+
+    /**
+     * Returns the relative url
+     *
+     * @param bool $includeParams
+     * @return string
+     */
+    public function getRelativeUrl(bool $includeParams = true): string
+    {
+        $path = $this->path ?? '/';
+
+        if ($includeParams === false) {
+            return $path;
+        }
+
+        $query = $this->getQueryString() !== '' ? '?' . $this->getQueryString() : '';
+        $fragment = $this->fragment !== null ? '#' . $this->fragment : '';
+
+        return $path . $query . $fragment;
+    }
+
+    /**
+     * Returns the absolute url
+     *
+     * @param bool $includeParams
+     * @return string
+     */
+    public function getAbsoluteUrl(bool $includeParams = true): string
+    {
+        $scheme = $this->scheme !== null ? $this->scheme . '://' : '';
+        $host = $this->host ?? '';
+        $port = $this->port !== null ? ':' . $this->port : '';
+        $user = $this->username ?? '';
+        $pass = $this->password !== null ? ':' . $this->password : '';
+        $pass = ($user !== '' || $pass !== '') ? $pass . '@' : '';
+
+        return $scheme . $user . $pass . $host . $port . $this->getRelativeUrl($includeParams);
+    }
+
+    /**
+     * Specify data which should be serialized to JSON
+     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
+     * @return string data which can be serialized by <b>json_encode</b>,
+     * which is a value of any type other than a resource.
+     * @since 5.4.0
+     */
+    public function jsonSerialize(): string
+    {
+        return $this->getHost(true) . $this->getRelativeUrl();
+    }
+
+    public function __toString(): string
+    {
+        return $this->getHost(true) . $this->getRelativeUrl();
+    }
+
+}