summaryrefslogtreecommitdiff
path: root/vendor/league/uri
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/league/uri')
-rw-r--r--vendor/league/uri/LICENSE20
-rw-r--r--vendor/league/uri/composer.json107
-rw-r--r--vendor/league/uri/src/Exceptions/TemplateCanNotBeExpanded.php30
-rw-r--r--vendor/league/uri/src/Http.php335
-rw-r--r--vendor/league/uri/src/HttpFactory.php25
-rw-r--r--vendor/league/uri/src/Uri.php1333
-rw-r--r--vendor/league/uri/src/UriInfo.php215
-rw-r--r--vendor/league/uri/src/UriResolver.php376
-rw-r--r--vendor/league/uri/src/UriString.php467
-rw-r--r--vendor/league/uri/src/UriTemplate.php134
-rw-r--r--vendor/league/uri/src/UriTemplate/Expression.php329
-rw-r--r--vendor/league/uri/src/UriTemplate/Template.php126
-rw-r--r--vendor/league/uri/src/UriTemplate/VarSpecifier.php96
-rw-r--r--vendor/league/uri/src/UriTemplate/VariableBag.php114
14 files changed, 3707 insertions, 0 deletions
diff --git a/vendor/league/uri/LICENSE b/vendor/league/uri/LICENSE
new file mode 100644
index 0000000..3b52528
--- /dev/null
+++ b/vendor/league/uri/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 ignace nyamagana butera
+
+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.
diff --git a/vendor/league/uri/composer.json b/vendor/league/uri/composer.json
new file mode 100644
index 0000000..28edbd8
--- /dev/null
+++ b/vendor/league/uri/composer.json
@@ -0,0 +1,107 @@
+{
+ "name": "league/uri",
+ "type": "library",
+ "description" : "URI manipulation library",
+ "keywords": [
+ "url",
+ "uri",
+ "rfc3986",
+ "rfc3987",
+ "rfc6570",
+ "psr-7",
+ "parse_url",
+ "http",
+ "https",
+ "ws",
+ "ftp",
+ "data-uri",
+ "file-uri",
+ "middleware",
+ "parse_str",
+ "query-string",
+ "querystring",
+ "hostname",
+ "uri-template"
+ ],
+ "license": "MIT",
+ "homepage": "https://uri.thephpleague.com",
+ "authors": [
+ {
+ "name" : "Ignace Nyamagana Butera",
+ "email" : "[email protected]",
+ "homepage" : "https://nyamsprod.com"
+ }
+ ],
+ "support": {
+ "forum": "https://thephpleague.slack.com",
+ "docs": "https://uri.thephpleague.com",
+ "issues": "https://github.com/thephpleague/uri/issues"
+ },
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/nyamsprod"
+ }
+ ],
+ "require": {
+ "php": "^7.4 || ^8.0",
+ "ext-json": "*",
+ "psr/http-message": "^1.0",
+ "league/uri-interfaces": "^2.3"
+ },
+ "require-dev": {
+ "friendsofphp/php-cs-fixer": "^v3.3.2",
+ "nyholm/psr7": "^1.5",
+ "php-http/psr7-integration-tests": "^1.1",
+ "phpstan/phpstan": "^1.2.0",
+ "phpstan/phpstan-deprecation-rules": "^1.0",
+ "phpstan/phpstan-phpunit": "^1.0.0",
+ "phpstan/phpstan-strict-rules": "^1.1.0",
+ "phpunit/phpunit": "^9.5.10",
+ "psr/http-factory": "^1.0"
+ },
+ "autoload": {
+ "psr-4": {
+ "League\\Uri\\": "src"
+ }
+ },
+ "autoload-dev": {
+ "psr-4": {
+ "LeagueTest\\Uri\\": "tests"
+ }
+ },
+ "conflict": {
+ "league/uri-schemes": "^1.0"
+ },
+ "scripts": {
+ "phpcs": "php-cs-fixer fix -v --diff --dry-run --allow-risky=yes --ansi",
+ "phpcs:fix": "php-cs-fixer fix -vvv --allow-risky=yes --ansi",
+ "phpstan": "phpstan analyse -l max -c phpstan.neon src --ansi --memory-limit=256M",
+ "phpunit": "XDEBUG_MODE=coverage phpunit --coverage-text",
+ "test": [
+ "@phpunit",
+ "@phpstan",
+ "@phpcs"
+ ]
+ },
+ "scripts-descriptions": {
+ "phpcs": "Runs coding style test suite",
+ "phpstan": "Runs complete codebase static analysis",
+ "phpunit": "Runs unit and functional testing",
+ "test": "Runs full test suite"
+ },
+ "suggest": {
+ "league/uri-components" : "Needed to easily manipulate URI objects",
+ "ext-intl" : "Needed to improve host validation",
+ "ext-fileinfo": "Needed to create Data URI from a filepath",
+ "psr/http-factory": "Needed to use the URI factory"
+ },
+ "extra": {
+ "branch-alias": {
+ "dev-master": "6.x-dev"
+ }
+ },
+ "config": {
+ "sort-packages": true
+ }
+}
diff --git a/vendor/league/uri/src/Exceptions/TemplateCanNotBeExpanded.php b/vendor/league/uri/src/Exceptions/TemplateCanNotBeExpanded.php
new file mode 100644
index 0000000..7c24b94
--- /dev/null
+++ b/vendor/league/uri/src/Exceptions/TemplateCanNotBeExpanded.php
@@ -0,0 +1,30 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\Exceptions;
+
+use InvalidArgumentException;
+use League\Uri\Contracts\UriException;
+
+class TemplateCanNotBeExpanded extends InvalidArgumentException implements UriException
+{
+ public static function dueToUnableToProcessValueListWithPrefix(string $variableName): self
+ {
+ return new self('The ":" modifier can not be applied on "'.$variableName.'" since it is a list of values.');
+ }
+
+ public static function dueToNestedListOfValue(string $variableName): self
+ {
+ return new self('The "'.$variableName.'" can not be a nested list.');
+ }
+}
diff --git a/vendor/league/uri/src/Http.php b/vendor/league/uri/src/Http.php
new file mode 100644
index 0000000..daf29c8
--- /dev/null
+++ b/vendor/league/uri/src/Http.php
@@ -0,0 +1,335 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri;
+
+use JsonSerializable;
+use League\Uri\Contracts\UriInterface;
+use League\Uri\Exceptions\SyntaxError;
+use Psr\Http\Message\UriInterface as Psr7UriInterface;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+use function sprintf;
+
+final class Http implements Psr7UriInterface, JsonSerializable
+{
+ private UriInterface $uri;
+
+ private function __construct(UriInterface $uri)
+ {
+ $this->validate($uri);
+ $this->uri = $uri;
+ }
+
+ /**
+ * Validate the submitted uri against PSR-7 UriInterface.
+ *
+ * @throws SyntaxError if the given URI does not follow PSR-7 UriInterface rules
+ */
+ private function validate(UriInterface $uri): void
+ {
+ $scheme = $uri->getScheme();
+ if (null === $scheme && '' === $uri->getHost()) {
+ throw new SyntaxError(sprintf('an URI without scheme can not contains a empty host string according to PSR-7: %s', (string) $uri));
+ }
+
+ $port = $uri->getPort();
+ if (null !== $port && ($port < 0 || $port > 65535)) {
+ throw new SyntaxError(sprintf('The URI port is outside the established TCP and UDP port ranges: %s', (string) $uri->getPort()));
+ }
+ }
+
+ /**
+ * Static method called by PHP's var export.
+ */
+ public static function __set_state(array $components): self
+ {
+ return new self($components['uri']);
+ }
+
+ /**
+ * Create a new instance from a string.
+ *
+ * @param string|mixed $uri
+ */
+ public static function createFromString($uri = ''): self
+ {
+ return new self(Uri::createFromString($uri));
+ }
+
+ /**
+ * Create a new instance from a hash of parse_url parts.
+ *
+ * @param array $components a hash representation of the URI similar
+ * to PHP parse_url function result
+ */
+ public static function createFromComponents(array $components): self
+ {
+ return new self(Uri::createFromComponents($components));
+ }
+
+ /**
+ * Create a new instance from the environment.
+ */
+ public static function createFromServer(array $server): self
+ {
+ return new self(Uri::createFromServer($server));
+ }
+
+ /**
+ * Create a new instance from a URI and a Base URI.
+ *
+ * The returned URI must be absolute.
+ *
+ * @param mixed $uri the input URI to create
+ * @param mixed $base_uri the base URI used for reference
+ */
+ public static function createFromBaseUri($uri, $base_uri = null): self
+ {
+ return new self(Uri::createFromBaseUri($uri, $base_uri));
+ }
+
+ /**
+ * Create a new instance from a URI object.
+ *
+ * @param Psr7UriInterface|UriInterface $uri the input URI to create
+ */
+ public static function createFromUri($uri): self
+ {
+ if ($uri instanceof UriInterface) {
+ return new self($uri);
+ }
+
+ return new self(Uri::createFromUri($uri));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getScheme(): string
+ {
+ return (string) $this->uri->getScheme();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getAuthority(): string
+ {
+ return (string) $this->uri->getAuthority();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getUserInfo(): string
+ {
+ return (string) $this->uri->getUserInfo();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getHost(): string
+ {
+ return (string) $this->uri->getHost();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getPort(): ?int
+ {
+ return $this->uri->getPort();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getPath(): string
+ {
+ return $this->uri->getPath();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getQuery(): string
+ {
+ return (string) $this->uri->getQuery();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getFragment(): string
+ {
+ return (string) $this->uri->getFragment();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withScheme($scheme): self
+ {
+ /** @var string $scheme */
+ $scheme = $this->filterInput($scheme);
+ if ('' === $scheme) {
+ $scheme = null;
+ }
+
+ $uri = $this->uri->withScheme($scheme);
+ if ($uri->getScheme() === $this->uri->getScheme()) {
+ return $this;
+ }
+
+ return new self($uri);
+ }
+
+ /**
+ * Safely stringify input when possible.
+ *
+ * @param mixed $str the value to evaluate as a string
+ *
+ * @throws SyntaxError if the submitted data can not be converted to string
+ *
+ * @return string|mixed
+ */
+ private function filterInput($str)
+ {
+ if (is_scalar($str) || (is_object($str) && method_exists($str, '__toString'))) {
+ return (string) $str;
+ }
+
+ return $str;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withUserInfo($user, $password = null): self
+ {
+ /** @var string $user */
+ $user = $this->filterInput($user);
+ if ('' === $user) {
+ $user = null;
+ }
+
+ $uri = $this->uri->withUserInfo($user, $password);
+ if ($uri->getUserInfo() === $this->uri->getUserInfo()) {
+ return $this;
+ }
+
+ return new self($uri);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withHost($host): self
+ {
+ /** @var string $host */
+ $host = $this->filterInput($host);
+ if ('' === $host) {
+ $host = null;
+ }
+
+ $uri = $this->uri->withHost($host);
+ if ($uri->getHost() === $this->uri->getHost()) {
+ return $this;
+ }
+
+ return new self($uri);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withPort($port): self
+ {
+ $uri = $this->uri->withPort($port);
+ if ($uri->getPort() === $this->uri->getPort()) {
+ return $this;
+ }
+
+ return new self($uri);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withPath($path): self
+ {
+ $uri = $this->uri->withPath($path);
+ if ($uri->getPath() === $this->uri->getPath()) {
+ return $this;
+ }
+
+ return new self($uri);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withQuery($query): self
+ {
+ /** @var string $query */
+ $query = $this->filterInput($query);
+ if ('' === $query) {
+ $query = null;
+ }
+
+ $uri = $this->uri->withQuery($query);
+ if ($uri->getQuery() === $this->uri->getQuery()) {
+ return $this;
+ }
+
+ return new self($uri);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withFragment($fragment): self
+ {
+ /** @var string $fragment */
+ $fragment = $this->filterInput($fragment);
+ if ('' === $fragment) {
+ $fragment = null;
+ }
+
+ $uri = $this->uri->withFragment($fragment);
+ if ($uri->getFragment() === $this->uri->getFragment()) {
+ return $this;
+ }
+
+ return new self($uri);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function __toString(): string
+ {
+ return $this->uri->__toString();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function jsonSerialize(): string
+ {
+ return $this->uri->__toString();
+ }
+}
diff --git a/vendor/league/uri/src/HttpFactory.php b/vendor/league/uri/src/HttpFactory.php
new file mode 100644
index 0000000..fc3bcfa
--- /dev/null
+++ b/vendor/league/uri/src/HttpFactory.php
@@ -0,0 +1,25 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri;
+
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+
+final class HttpFactory implements UriFactoryInterface
+{
+ public function createUri(string $uri = ''): UriInterface
+ {
+ return Http::createFromString($uri);
+ }
+}
diff --git a/vendor/league/uri/src/Uri.php b/vendor/league/uri/src/Uri.php
new file mode 100644
index 0000000..4212730
--- /dev/null
+++ b/vendor/league/uri/src/Uri.php
@@ -0,0 +1,1333 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri;
+
+use finfo;
+use League\Uri\Contracts\UriInterface;
+use League\Uri\Exceptions\FileinfoSupportMissing;
+use League\Uri\Exceptions\IdnaConversionFailed;
+use League\Uri\Exceptions\IdnSupportMissing;
+use League\Uri\Exceptions\SyntaxError;
+use League\Uri\Idna\Idna;
+use Psr\Http\Message\UriInterface as Psr7UriInterface;
+use TypeError;
+use function array_filter;
+use function array_map;
+use function base64_decode;
+use function base64_encode;
+use function count;
+use function explode;
+use function file_get_contents;
+use function filter_var;
+use function implode;
+use function in_array;
+use function inet_pton;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+use function preg_match;
+use function preg_replace;
+use function preg_replace_callback;
+use function rawurlencode;
+use function sprintf;
+use function str_replace;
+use function strlen;
+use function strpos;
+use function strspn;
+use function strtolower;
+use function substr;
+use const FILEINFO_MIME;
+use const FILTER_FLAG_IPV4;
+use const FILTER_FLAG_IPV6;
+use const FILTER_NULL_ON_FAILURE;
+use const FILTER_VALIDATE_BOOLEAN;
+use const FILTER_VALIDATE_IP;
+
+final class Uri implements UriInterface
+{
+ /**
+ * RFC3986 invalid characters.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-2.2
+ *
+ * @var string
+ */
+ private const REGEXP_INVALID_CHARS = '/[\x00-\x1f\x7f]/';
+
+ /**
+ * RFC3986 Sub delimiter characters regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-2.2
+ *
+ * @var string
+ */
+ private const REGEXP_CHARS_SUBDELIM = "\!\$&'\(\)\*\+,;\=%";
+
+ /**
+ * RFC3986 unreserved characters regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-2.3
+ *
+ * @var string
+ */
+ private const REGEXP_CHARS_UNRESERVED = 'A-Za-z0-9_\-\.~';
+
+ /**
+ * RFC3986 schema regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.1
+ */
+ private const REGEXP_SCHEME = ',^[a-z]([-a-z0-9+.]+)?$,i';
+
+ /**
+ * RFC3986 host identified by a registered name regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ */
+ private const REGEXP_HOST_REGNAME = '/^(
+ (?<unreserved>[a-z0-9_~\-\.])|
+ (?<sub_delims>[!$&\'()*+,;=])|
+ (?<encoded>%[A-F0-9]{2})
+ )+$/x';
+
+ /**
+ * RFC3986 delimiters of the generic URI components regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-2.2
+ */
+ private const REGEXP_HOST_GEN_DELIMS = '/[:\/?#\[\]@ ]/'; // Also includes space.
+
+ /**
+ * RFC3986 IPvFuture regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ */
+ private const REGEXP_HOST_IPFUTURE = '/^
+ v(?<version>[A-F0-9])+\.
+ (?:
+ (?<unreserved>[a-z0-9_~\-\.])|
+ (?<sub_delims>[!$&\'()*+,;=:]) # also include the : character
+ )+
+ $/ix';
+
+ /**
+ * RFC3986 IPvFuture host and port component.
+ */
+ private const REGEXP_HOST_PORT = ',^(?<host>(\[.*]|[^:])*)(:(?<port>[^/?#]*))?$,x';
+
+ /**
+ * Significant 10 bits of IP to detect Zone ID regular expression pattern.
+ */
+ private const HOST_ADDRESS_BLOCK = "\xfe\x80";
+
+ /**
+ * Regular expression pattern to for file URI.
+ * <volume> contains the volume but not the volume separator.
+ * The volume separator may be URL-encoded (`|` as `%7C`) by ::formatPath(),
+ * so we account for that here.
+ */
+ private const REGEXP_FILE_PATH = ',^(?<delim>/)?(?<volume>[a-zA-Z])(?:[:|\|]|%7C)(?<rest>.*)?,';
+
+ /**
+ * Mimetype regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc2397
+ */
+ private const REGEXP_MIMETYPE = ',^\w+/[-.\w]+(?:\+[-.\w]+)?$,';
+
+ /**
+ * Base64 content regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc2397
+ */
+ private const REGEXP_BINARY = ',(;|^)base64$,';
+
+ /**
+ * Windows file path string regular expression pattern.
+ * <root> contains both the volume and volume separator.
+ */
+ private const REGEXP_WINDOW_PATH = ',^(?<root>[a-zA-Z][:|\|]),';
+
+ /**
+ * Supported schemes and corresponding default port.
+ *
+ * @var array<string, int|null>
+ */
+ private const SCHEME_DEFAULT_PORT = [
+ 'data' => null,
+ 'file' => null,
+ 'ftp' => 21,
+ 'gopher' => 70,
+ 'http' => 80,
+ 'https' => 443,
+ 'ws' => 80,
+ 'wss' => 443,
+ ];
+
+ /**
+ * URI validation methods per scheme.
+ *
+ * @var array<string>
+ */
+ private const SCHEME_VALIDATION_METHOD = [
+ 'data' => 'isUriWithSchemeAndPathOnly',
+ 'file' => 'isUriWithSchemeHostAndPathOnly',
+ 'ftp' => 'isNonEmptyHostUriWithoutFragmentAndQuery',
+ 'gopher' => 'isNonEmptyHostUriWithoutFragmentAndQuery',
+ 'http' => 'isNonEmptyHostUri',
+ 'https' => 'isNonEmptyHostUri',
+ 'ws' => 'isNonEmptyHostUriWithoutFragment',
+ 'wss' => 'isNonEmptyHostUriWithoutFragment',
+ ];
+
+ /**
+ * All ASCII letters sorted by typical frequency of occurrence.
+ *
+ * @var string
+ */
+ private const ASCII = "\x20\x65\x69\x61\x73\x6E\x74\x72\x6F\x6C\x75\x64\x5D\x5B\x63\x6D\x70\x27\x0A\x67\x7C\x68\x76\x2E\x66\x62\x2C\x3A\x3D\x2D\x71\x31\x30\x43\x32\x2A\x79\x78\x29\x28\x4C\x39\x41\x53\x2F\x50\x22\x45\x6A\x4D\x49\x6B\x33\x3E\x35\x54\x3C\x44\x34\x7D\x42\x7B\x38\x46\x77\x52\x36\x37\x55\x47\x4E\x3B\x4A\x7A\x56\x23\x48\x4F\x57\x5F\x26\x21\x4B\x3F\x58\x51\x25\x59\x5C\x09\x5A\x2B\x7E\x5E\x24\x40\x60\x7F\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x0D\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
+
+ private ?string $scheme;
+ private ?string $user_info;
+ private ?string $host;
+ private ?int $port;
+ private ?string $authority;
+ private string $path = '';
+ private ?string $query;
+ private ?string $fragment;
+ private ?string $uri;
+
+ private function __construct(
+ ?string $scheme,
+ ?string $user,
+ ?string $pass,
+ ?string $host,
+ ?int $port,
+ string $path,
+ ?string $query,
+ ?string $fragment
+ ) {
+ $this->scheme = $this->formatScheme($scheme);
+ $this->user_info = $this->formatUserInfo($user, $pass);
+ $this->host = $this->formatHost($host);
+ $this->port = $this->formatPort($port);
+ $this->authority = $this->setAuthority();
+ $this->path = $this->formatPath($path);
+ $this->query = $this->formatQueryAndFragment($query);
+ $this->fragment = $this->formatQueryAndFragment($fragment);
+ $this->assertValidState();
+ }
+
+ /**
+ * Format the Scheme and Host component.
+ *
+ * @param ?string $scheme
+ * @throws SyntaxError if the scheme is invalid
+ */
+ private function formatScheme(?string $scheme): ?string
+ {
+ if (null === $scheme) {
+ return $scheme;
+ }
+
+ $formatted_scheme = strtolower($scheme);
+ if (1 === preg_match(self::REGEXP_SCHEME, $formatted_scheme)) {
+ return $formatted_scheme;
+ }
+
+ throw new SyntaxError(sprintf('The scheme `%s` is invalid.', $scheme));
+ }
+
+ /**
+ * Set the UserInfo component.
+ * @param ?string $user
+ * @param ?string $password
+ */
+ private function formatUserInfo(?string $user, ?string $password): ?string
+ {
+ if (null === $user) {
+ return $user;
+ }
+
+ static $user_pattern = '/(?:[^%'.self::REGEXP_CHARS_UNRESERVED.self::REGEXP_CHARS_SUBDELIM.']++|%(?![A-Fa-f0-9]{2}))/';
+ $user = preg_replace_callback($user_pattern, [Uri::class, 'urlEncodeMatch'], $user);
+ if (null === $password) {
+ return $user;
+ }
+
+ static $password_pattern = '/(?:[^%:'.self::REGEXP_CHARS_UNRESERVED.self::REGEXP_CHARS_SUBDELIM.']++|%(?![A-Fa-f0-9]{2}))/';
+
+ return $user.':'.preg_replace_callback($password_pattern, [Uri::class, 'urlEncodeMatch'], $password);
+ }
+
+ /**
+ * Returns the RFC3986 encoded string matched.
+ */
+ private static function urlEncodeMatch(array $matches): string
+ {
+ return rawurlencode($matches[0]);
+ }
+
+ /**
+ * Validate and Format the Host component.
+ * @param ?string $host
+ */
+ private function formatHost(?string $host): ?string
+ {
+ if (null === $host || '' === $host) {
+ return $host;
+ }
+
+ if ('[' !== $host[0]) {
+ return $this->formatRegisteredName($host);
+ }
+
+ return $this->formatIp($host);
+ }
+
+ /**
+ * Validate and format a registered name.
+ *
+ * The host is converted to its ascii representation if needed
+ *
+ * @throws IdnSupportMissing if the submitted host required missing or misconfigured IDN support
+ * @throws SyntaxError if the submitted host is not a valid registered name
+ */
+ private function formatRegisteredName(string $host): string
+ {
+ $formatted_host = rawurldecode($host);
+ if (1 === preg_match(self::REGEXP_HOST_REGNAME, $formatted_host)) {
+ return $formatted_host;
+ }
+
+ if (1 === preg_match(self::REGEXP_HOST_GEN_DELIMS, $formatted_host)) {
+ throw new SyntaxError(sprintf('The host `%s` is invalid : a registered name can not contain URI delimiters or spaces', $host));
+ }
+
+ $info = Idna::toAscii($host, Idna::IDNA2008_ASCII);
+ if (0 !== $info->errors()) {
+ throw IdnaConversionFailed::dueToIDNAError($host, $info);
+ }
+
+ return $info->result();
+ }
+
+ /**
+ * Validate and Format the IPv6/IPvfuture host.
+ *
+ * @throws SyntaxError if the submitted host is not a valid IP host
+ */
+ private function formatIp(string $host): string
+ {
+ $ip = substr($host, 1, -1);
+ if (false !== filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+ return $host;
+ }
+
+ if (1 === preg_match(self::REGEXP_HOST_IPFUTURE, $ip, $matches) && !in_array($matches['version'], ['4', '6'], true)) {
+ return $host;
+ }
+
+ $pos = strpos($ip, '%');
+ if (false === $pos) {
+ throw new SyntaxError(sprintf('The host `%s` is invalid : the IP host is malformed', $host));
+ }
+
+ if (1 === preg_match(self::REGEXP_HOST_GEN_DELIMS, rawurldecode(substr($ip, $pos)))) {
+ throw new SyntaxError(sprintf('The host `%s` is invalid : the IP host is malformed', $host));
+ }
+
+ $ip = substr($ip, 0, $pos);
+ if (false === filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+ throw new SyntaxError(sprintf('The host `%s` is invalid : the IP host is malformed', $host));
+ }
+
+ //Only the address block fe80::/10 can have a Zone ID attach to
+ //let's detect the link local significant 10 bits
+ if (0 === strpos((string) inet_pton($ip), self::HOST_ADDRESS_BLOCK)) {
+ return $host;
+ }
+
+ throw new SyntaxError(sprintf('The host `%s` is invalid : the IP host is malformed', $host));
+ }
+
+ /**
+ * Format the Port component.
+ *
+ * @param object|null|int|string $port
+ *
+ * @throws SyntaxError
+ */
+ private function formatPort($port = null): ?int
+ {
+ if (null === $port || '' === $port) {
+ return null;
+ }
+
+ if (!is_int($port) && !(is_string($port) && 1 === preg_match('/^\d*$/', $port))) {
+ throw new SyntaxError('The port is expected to be an integer or a string representing an integer; '.gettype($port).' given.');
+ }
+
+ $port = (int) $port;
+ if (0 > $port) {
+ throw new SyntaxError(sprintf('The port `%s` is invalid', $port));
+ }
+
+ $defaultPort = self::SCHEME_DEFAULT_PORT[$this->scheme] ?? null;
+ if ($defaultPort === $port) {
+ return null;
+ }
+
+ return $port;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public static function __set_state(array $components): self
+ {
+ $components['user'] = null;
+ $components['pass'] = null;
+ if (null !== $components['user_info']) {
+ [$components['user'], $components['pass']] = explode(':', $components['user_info'], 2) + [1 => null];
+ }
+
+ return new self(
+ $components['scheme'],
+ $components['user'],
+ $components['pass'],
+ $components['host'],
+ $components['port'],
+ $components['path'],
+ $components['query'],
+ $components['fragment']
+ );
+ }
+
+ /**
+ * Create a new instance from a URI and a Base URI.
+ *
+ * The returned URI must be absolute.
+ *
+ * @param mixed $uri the input URI to create
+ * @param null|mixed $base_uri the base URI used for reference
+ */
+ public static function createFromBaseUri($uri, $base_uri = null): UriInterface
+ {
+ if (!$uri instanceof UriInterface) {
+ $uri = self::createFromString($uri);
+ }
+
+ if (null === $base_uri) {
+ if (null === $uri->getScheme()) {
+ throw new SyntaxError(sprintf('the URI `%s` must be absolute', (string) $uri));
+ }
+
+ if (null === $uri->getAuthority()) {
+ return $uri;
+ }
+
+ /** @var UriInterface $uri */
+ $uri = UriResolver::resolve($uri, $uri->withFragment(null)->withQuery(null)->withPath(''));
+
+ return $uri;
+ }
+
+ if (!$base_uri instanceof UriInterface) {
+ $base_uri = self::createFromString($base_uri);
+ }
+
+ if (null === $base_uri->getScheme()) {
+ throw new SyntaxError(sprintf('the base URI `%s` must be absolute', (string) $base_uri));
+ }
+
+ /** @var UriInterface $uri */
+ $uri = UriResolver::resolve($uri, $base_uri);
+
+ return $uri;
+ }
+
+ /**
+ * Create a new instance from a string.
+ *
+ * @param string|mixed $uri
+ */
+ public static function createFromString($uri = ''): self
+ {
+ $components = UriString::parse($uri);
+
+ return new self(
+ $components['scheme'],
+ $components['user'],
+ $components['pass'],
+ $components['host'],
+ $components['port'],
+ $components['path'],
+ $components['query'],
+ $components['fragment']
+ );
+ }
+
+ /**
+ * Create a new instance from a hash representation of the URI similar
+ * to PHP parse_url function result.
+ */
+ public static function createFromComponents(array $components = []): self
+ {
+ $components += [
+ 'scheme' => null, 'user' => null, 'pass' => null, 'host' => null,
+ 'port' => null, 'path' => '', 'query' => null, 'fragment' => null,
+ ];
+
+ return new self(
+ $components['scheme'],
+ $components['user'],
+ $components['pass'],
+ $components['host'],
+ $components['port'],
+ $components['path'],
+ $components['query'],
+ $components['fragment']
+ );
+ }
+
+ /**
+ * Create a new instance from a data file path.
+ *
+ * @param resource|null $context
+ *
+ * @throws FileinfoSupportMissing If ext/fileinfo is not installed
+ * @throws SyntaxError If the file does not exist or is not readable
+ */
+ public static function createFromDataPath(string $path, $context = null): self
+ {
+ static $finfo_support = null;
+ $finfo_support = $finfo_support ?? class_exists(finfo::class);
+
+ // @codeCoverageIgnoreStart
+ if (!$finfo_support) {
+ throw new FileinfoSupportMissing(sprintf('Please install ext/fileinfo to use the %s() method.', __METHOD__));
+ }
+ // @codeCoverageIgnoreEnd
+
+ $file_args = [$path, false];
+ $mime_args = [$path, FILEINFO_MIME];
+ if (null !== $context) {
+ $file_args[] = $context;
+ $mime_args[] = $context;
+ }
+
+ $raw = @file_get_contents(...$file_args);
+ if (false === $raw) {
+ throw new SyntaxError(sprintf('The file `%s` does not exist or is not readable', $path));
+ }
+
+ $mimetype = (string) (new finfo(FILEINFO_MIME))->file(...$mime_args);
+
+ return Uri::createFromComponents([
+ 'scheme' => 'data',
+ 'path' => str_replace(' ', '', $mimetype.';base64,'.base64_encode($raw)),
+ ]);
+ }
+
+ /**
+ * Create a new instance from a Unix path string.
+ */
+ public static function createFromUnixPath(string $uri = ''): self
+ {
+ $uri = implode('/', array_map('rawurlencode', explode('/', $uri)));
+ if ('/' !== ($uri[0] ?? '')) {
+ return Uri::createFromComponents(['path' => $uri]);
+ }
+
+ return Uri::createFromComponents(['path' => $uri, 'scheme' => 'file', 'host' => '']);
+ }
+
+ /**
+ * Create a new instance from a local Windows path string.
+ */
+ public static function createFromWindowsPath(string $uri = ''): self
+ {
+ $root = '';
+ if (1 === preg_match(self::REGEXP_WINDOW_PATH, $uri, $matches)) {
+ $root = substr($matches['root'], 0, -1).':';
+ $uri = substr($uri, strlen($root));
+ }
+ $uri = str_replace('\\', '/', $uri);
+ $uri = implode('/', array_map('rawurlencode', explode('/', $uri)));
+
+ //Local Windows absolute path
+ if ('' !== $root) {
+ return Uri::createFromComponents(['path' => '/'.$root.$uri, 'scheme' => 'file', 'host' => '']);
+ }
+
+ //UNC Windows Path
+ if ('//' !== substr($uri, 0, 2)) {
+ return Uri::createFromComponents(['path' => $uri]);
+ }
+
+ $parts = explode('/', substr($uri, 2), 2) + [1 => null];
+
+ return Uri::createFromComponents(['host' => $parts[0], 'path' => '/'.$parts[1], 'scheme' => 'file']);
+ }
+
+ /**
+ * Create a new instance from a URI object.
+ *
+ * @param Psr7UriInterface|UriInterface $uri the input URI to create
+ */
+ public static function createFromUri($uri): self
+ {
+ if ($uri instanceof UriInterface) {
+ $user_info = $uri->getUserInfo();
+ $user = null;
+ $pass = null;
+ if (null !== $user_info) {
+ [$user, $pass] = explode(':', $user_info, 2) + [1 => null];
+ }
+
+ return new self(
+ $uri->getScheme(),
+ $user,
+ $pass,
+ $uri->getHost(),
+ $uri->getPort(),
+ $uri->getPath(),
+ $uri->getQuery(),
+ $uri->getFragment()
+ );
+ }
+
+ if (!$uri instanceof Psr7UriInterface) {
+ throw new TypeError(sprintf('The object must implement the `%s` or the `%s`', Psr7UriInterface::class, UriInterface::class));
+ }
+
+ $scheme = $uri->getScheme();
+ if ('' === $scheme) {
+ $scheme = null;
+ }
+
+ $fragment = $uri->getFragment();
+ if ('' === $fragment) {
+ $fragment = null;
+ }
+
+ $query = $uri->getQuery();
+ if ('' === $query) {
+ $query = null;
+ }
+
+ $host = $uri->getHost();
+ if ('' === $host) {
+ $host = null;
+ }
+
+ $user_info = $uri->getUserInfo();
+ $user = null;
+ $pass = null;
+ if ('' !== $user_info) {
+ [$user, $pass] = explode(':', $user_info, 2) + [1 => null];
+ }
+
+ return new self(
+ $scheme,
+ $user,
+ $pass,
+ $host,
+ $uri->getPort(),
+ $uri->getPath(),
+ $query,
+ $fragment
+ );
+ }
+
+ /**
+ * Create a new instance from the environment.
+ */
+ public static function createFromServer(array $server): self
+ {
+ [$user, $pass] = self::fetchUserInfo($server);
+ [$host, $port] = self::fetchHostname($server);
+ [$path, $query] = self::fetchRequestUri($server);
+
+ return Uri::createFromComponents([
+ 'scheme' => self::fetchScheme($server),
+ 'user' => $user,
+ 'pass' => $pass,
+ 'host' => $host,
+ 'port' => $port,
+ 'path' => $path,
+ 'query' => $query,
+ ]);
+ }
+
+ /**
+ * Returns the environment scheme.
+ */
+ private static function fetchScheme(array $server): string
+ {
+ $server += ['HTTPS' => ''];
+ $res = filter_var($server['HTTPS'], FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE);
+
+ return false !== $res ? 'https' : 'http';
+ }
+
+ /**
+ * Returns the environment user info.
+ *
+ * @return array{0:?string, 1:?string}
+ */
+ private static function fetchUserInfo(array $server): array
+ {
+ $server += ['PHP_AUTH_USER' => null, 'PHP_AUTH_PW' => null, 'HTTP_AUTHORIZATION' => ''];
+ $user = $server['PHP_AUTH_USER'];
+ $pass = $server['PHP_AUTH_PW'];
+ if (0 === strpos(strtolower($server['HTTP_AUTHORIZATION']), 'basic')) {
+ $userinfo = base64_decode(substr($server['HTTP_AUTHORIZATION'], 6), true);
+ if (false === $userinfo) {
+ throw new SyntaxError('The user info could not be detected');
+ }
+ [$user, $pass] = explode(':', $userinfo, 2) + [1 => null];
+ }
+
+ if (null !== $user) {
+ $user = rawurlencode($user);
+ }
+
+ if (null !== $pass) {
+ $pass = rawurlencode($pass);
+ }
+
+ return [$user, $pass];
+ }
+
+ /**
+ * Returns the environment host.
+ *
+ * @throws SyntaxError If the host can not be detected
+ *
+ * @return array{0:string|null, 1:int|null}
+ */
+ private static function fetchHostname(array $server): array
+ {
+ $server += ['SERVER_PORT' => null];
+ if (null !== $server['SERVER_PORT']) {
+ $server['SERVER_PORT'] = (int) $server['SERVER_PORT'];
+ }
+
+ if (isset($server['HTTP_HOST']) && 1 === preg_match(self::REGEXP_HOST_PORT, $server['HTTP_HOST'], $matches)) {
+ if (isset($matches['port'])) {
+ $matches['port'] = (int) $matches['port'];
+ }
+
+ return [
+ $matches['host'],
+ $matches['port'] ?? $server['SERVER_PORT'],
+ ];
+ }
+
+ if (!isset($server['SERVER_ADDR'])) {
+ throw new SyntaxError('The host could not be detected');
+ }
+
+ if (false === filter_var($server['SERVER_ADDR'], FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
+ $server['SERVER_ADDR'] = '['.$server['SERVER_ADDR'].']';
+ }
+
+ return [$server['SERVER_ADDR'], $server['SERVER_PORT']];
+ }
+
+ /**
+ * Returns the environment path.
+ *
+ * @return array{0:?string, 1:?string}
+ */
+ private static function fetchRequestUri(array $server): array
+ {
+ $server += ['IIS_WasUrlRewritten' => null, 'UNENCODED_URL' => '', 'PHP_SELF' => '', 'QUERY_STRING' => null];
+ if ('1' === $server['IIS_WasUrlRewritten'] && '' !== $server['UNENCODED_URL']) {
+ /** @var array{0:?string, 1:?string} $retval */
+ $retval = explode('?', $server['UNENCODED_URL'], 2) + [1 => null];
+
+ return $retval;
+ }
+
+ if (isset($server['REQUEST_URI'])) {
+ [$path, ] = explode('?', $server['REQUEST_URI'], 2);
+ $query = ('' !== $server['QUERY_STRING']) ? $server['QUERY_STRING'] : null;
+
+ return [$path, $query];
+ }
+
+ return [$server['PHP_SELF'], $server['QUERY_STRING']];
+ }
+
+ /**
+ * Generate the URI authority part.
+ */
+ private function setAuthority(): ?string
+ {
+ $authority = null;
+ if (null !== $this->user_info) {
+ $authority = $this->user_info.'@';
+ }
+
+ if (null !== $this->host) {
+ $authority .= $this->host;
+ }
+
+ if (null !== $this->port) {
+ $authority .= ':'.$this->port;
+ }
+
+ return $authority;
+ }
+
+ /**
+ * Format the Path component.
+ */
+ private function formatPath(string $path): string
+ {
+ $path = $this->formatDataPath($path);
+
+ static $pattern = '/(?:[^'.self::REGEXP_CHARS_UNRESERVED.self::REGEXP_CHARS_SUBDELIM.'%:@\/}{]++|%(?![A-Fa-f0-9]{2}))/';
+
+ $path = (string) preg_replace_callback($pattern, [Uri::class, 'urlEncodeMatch'], $path);
+
+ return $this->formatFilePath($path);
+ }
+
+ /**
+ * Filter the Path component.
+ *
+ * @link https://tools.ietf.org/html/rfc2397
+ *
+ * @throws SyntaxError If the path is not compliant with RFC2397
+ */
+ private function formatDataPath(string $path): string
+ {
+ if ('data' !== $this->scheme) {
+ return $path;
+ }
+
+ if ('' == $path) {
+ return 'text/plain;charset=us-ascii,';
+ }
+
+ if (strlen($path) !== strspn($path, self::ASCII) || false === strpos($path, ',')) {
+ throw new SyntaxError(sprintf('The path `%s` is invalid according to RFC2937', $path));
+ }
+
+ $parts = explode(',', $path, 2) + [1 => null];
+ $mediatype = explode(';', (string) $parts[0], 2) + [1 => null];
+ $data = (string) $parts[1];
+ $mimetype = $mediatype[0];
+ if (null === $mimetype || '' === $mimetype) {
+ $mimetype = 'text/plain';
+ }
+
+ $parameters = $mediatype[1];
+ if (null === $parameters || '' === $parameters) {
+ $parameters = 'charset=us-ascii';
+ }
+
+ $this->assertValidPath($mimetype, $parameters, $data);
+
+ return $mimetype.';'.$parameters.','.$data;
+ }
+
+ /**
+ * Assert the path is a compliant with RFC2397.
+ *
+ * @link https://tools.ietf.org/html/rfc2397
+ *
+ * @throws SyntaxError If the mediatype or the data are not compliant with the RFC2397
+ */
+ private function assertValidPath(string $mimetype, string $parameters, string $data): void
+ {
+ if (1 !== preg_match(self::REGEXP_MIMETYPE, $mimetype)) {
+ throw new SyntaxError(sprintf('The path mimetype `%s` is invalid', $mimetype));
+ }
+
+ $is_binary = 1 === preg_match(self::REGEXP_BINARY, $parameters, $matches);
+ if ($is_binary) {
+ $parameters = substr($parameters, 0, - strlen($matches[0]));
+ }
+
+ $res = array_filter(array_filter(explode(';', $parameters), [$this, 'validateParameter']));
+ if ([] !== $res) {
+ throw new SyntaxError(sprintf('The path paremeters `%s` is invalid', $parameters));
+ }
+
+ if (!$is_binary) {
+ return;
+ }
+
+ $res = base64_decode($data, true);
+ if (false === $res || $data !== base64_encode($res)) {
+ throw new SyntaxError(sprintf('The path data `%s` is invalid', $data));
+ }
+ }
+
+ /**
+ * Validate mediatype parameter.
+ */
+ private function validateParameter(string $parameter): bool
+ {
+ $properties = explode('=', $parameter);
+
+ return 2 != count($properties) || 'base64' === strtolower($properties[0]);
+ }
+
+ /**
+ * Format path component for file scheme.
+ */
+ private function formatFilePath(string $path): string
+ {
+ if ('file' !== $this->scheme) {
+ return $path;
+ }
+
+ $replace = static function (array $matches): string {
+ return $matches['delim'].$matches['volume'].':'.$matches['rest'];
+ };
+
+ return (string) preg_replace_callback(self::REGEXP_FILE_PATH, $replace, $path);
+ }
+
+ /**
+ * Format the Query or the Fragment component.
+ *
+ * Returns a array containing:
+ * <ul>
+ * <li> the formatted component (a string or null)</li>
+ * <li> a boolean flag telling wether the delimiter is to be added to the component
+ * when building the URI string representation</li>
+ * </ul>
+ *
+ * @param ?string $component
+ */
+ private function formatQueryAndFragment(?string $component): ?string
+ {
+ if (null === $component || '' === $component) {
+ return $component;
+ }
+
+ static $pattern = '/(?:[^'.self::REGEXP_CHARS_UNRESERVED.self::REGEXP_CHARS_SUBDELIM.'%:@\/\?]++|%(?![A-Fa-f0-9]{2}))/';
+ return preg_replace_callback($pattern, [Uri::class, 'urlEncodeMatch'], $component);
+ }
+
+ /**
+ * assert the URI internal state is valid.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3
+ * @link https://tools.ietf.org/html/rfc3986#section-3.3
+ *
+ * @throws SyntaxError if the URI is in an invalid state according to RFC3986
+ * @throws SyntaxError if the URI is in an invalid state according to scheme specific rules
+ */
+ private function assertValidState(): void
+ {
+ if (null !== $this->authority && ('' !== $this->path && '/' !== $this->path[0])) {
+ throw new SyntaxError('If an authority is present the path must be empty or start with a `/`.');
+ }
+
+ if (null === $this->authority && 0 === strpos($this->path, '//')) {
+ throw new SyntaxError(sprintf('If there is no authority the path `%s` can not start with a `//`.', $this->path));
+ }
+
+ $pos = strpos($this->path, ':');
+ if (null === $this->authority
+ && null === $this->scheme
+ && false !== $pos
+ && false === strpos(substr($this->path, 0, $pos), '/')
+ ) {
+ throw new SyntaxError('In absence of a scheme and an authority the first path segment cannot contain a colon (":") character.');
+ }
+
+ $validationMethod = self::SCHEME_VALIDATION_METHOD[$this->scheme] ?? null;
+ if (null === $validationMethod || true === $this->$validationMethod()) {
+ $this->uri = null;
+
+ return;
+ }
+
+ throw new SyntaxError(sprintf('The uri `%s` is invalid for the `%s` scheme.', (string) $this, $this->scheme));
+ }
+
+ /**
+ * URI validation for URI schemes which allows only scheme and path components.
+ */
+ private function isUriWithSchemeAndPathOnly(): bool
+ {
+ return null === $this->authority
+ && null === $this->query
+ && null === $this->fragment;
+ }
+
+ /**
+ * URI validation for URI schemes which allows only scheme, host and path components.
+ */
+ private function isUriWithSchemeHostAndPathOnly(): bool
+ {
+ return null === $this->user_info
+ && null === $this->port
+ && null === $this->query
+ && null === $this->fragment
+ && !('' != $this->scheme && null === $this->host);
+ }
+
+ /**
+ * URI validation for URI schemes which disallow the empty '' host.
+ */
+ private function isNonEmptyHostUri(): bool
+ {
+ return '' !== $this->host
+ && !(null !== $this->scheme && null === $this->host);
+ }
+
+ /**
+ * URI validation for URIs schemes which disallow the empty '' host
+ * and forbids the fragment component.
+ */
+ private function isNonEmptyHostUriWithoutFragment(): bool
+ {
+ return $this->isNonEmptyHostUri() && null === $this->fragment;
+ }
+
+ /**
+ * URI validation for URIs schemes which disallow the empty '' host
+ * and forbids fragment and query components.
+ */
+ private function isNonEmptyHostUriWithoutFragmentAndQuery(): bool
+ {
+ return $this->isNonEmptyHostUri() && null === $this->fragment && null === $this->query;
+ }
+
+ /**
+ * Generate the URI string representation from its components.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-5.3
+ *
+ * @param ?string $scheme
+ * @param ?string $authority
+ * @param ?string $query
+ * @param ?string $fragment
+ */
+ private function getUriString(
+ ?string $scheme,
+ ?string $authority,
+ string $path,
+ ?string $query,
+ ?string $fragment
+ ): string {
+ if (null !== $scheme) {
+ $scheme = $scheme.':';
+ }
+
+ if (null !== $authority) {
+ $authority = '//'.$authority;
+ }
+
+ if (null !== $query) {
+ $query = '?'.$query;
+ }
+
+ if (null !== $fragment) {
+ $fragment = '#'.$fragment;
+ }
+
+ return $scheme.$authority.$path.$query.$fragment;
+ }
+
+ public function toString(): string
+ {
+ $this->uri = $this->uri ?? $this->getUriString(
+ $this->scheme,
+ $this->authority,
+ $this->path,
+ $this->query,
+ $this->fragment
+ );
+
+ return $this->uri;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function __toString(): string
+ {
+ return $this->toString();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function jsonSerialize(): string
+ {
+ return $this->toString();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @return array{scheme:?string, user_info:?string, host:?string, port:?int, path:string, query:?string, fragment:?string}
+ */
+ public function __debugInfo(): array
+ {
+ return [
+ 'scheme' => $this->scheme,
+ 'user_info' => isset($this->user_info) ? preg_replace(',:(.*).?$,', ':***', $this->user_info) : null,
+ 'host' => $this->host,
+ 'port' => $this->port,
+ 'path' => $this->path,
+ 'query' => $this->query,
+ 'fragment' => $this->fragment,
+ ];
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getScheme(): ?string
+ {
+ return $this->scheme;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getAuthority(): ?string
+ {
+ return $this->authority;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getUserInfo(): ?string
+ {
+ return $this->user_info;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getHost(): ?string
+ {
+ return $this->host;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getPort(): ?int
+ {
+ return $this->port;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getPath(): string
+ {
+ return $this->path;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getQuery(): ?string
+ {
+ return $this->query;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getFragment(): ?string
+ {
+ return $this->fragment;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withScheme($scheme): UriInterface
+ {
+ $scheme = $this->formatScheme($this->filterString($scheme));
+ if ($scheme === $this->scheme) {
+ return $this;
+ }
+
+ $clone = clone $this;
+ $clone->scheme = $scheme;
+ $clone->port = $clone->formatPort($clone->port);
+ $clone->authority = $clone->setAuthority();
+ $clone->assertValidState();
+
+ return $clone;
+ }
+
+ /**
+ * Filter a string.
+ *
+ * @param mixed $str the value to evaluate as a string
+ *
+ * @throws SyntaxError if the submitted data can not be converted to string
+ */
+ private function filterString($str): ?string
+ {
+ if (null === $str) {
+ return $str;
+ }
+
+ if (is_object($str) && method_exists($str, '__toString')) {
+ $str = (string) $str;
+ }
+
+ if (!is_scalar($str)) {
+ throw new SyntaxError(sprintf('The component must be a string, a scalar or a stringable object; `%s` given.', gettype($str)));
+ }
+
+ $str = (string) $str;
+ if (1 !== preg_match(self::REGEXP_INVALID_CHARS, $str)) {
+ return $str;
+ }
+
+ throw new SyntaxError(sprintf('The component `%s` contains invalid characters.', $str));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withUserInfo($user, $password = null): UriInterface
+ {
+ $user_info = null;
+ $user = $this->filterString($user);
+ if (null !== $password) {
+ $password = $this->filterString($password);
+ }
+
+ if ('' !== $user) {
+ $user_info = $this->formatUserInfo($user, $password);
+ }
+
+ if ($user_info === $this->user_info) {
+ return $this;
+ }
+
+ $clone = clone $this;
+ $clone->user_info = $user_info;
+ $clone->authority = $clone->setAuthority();
+ $clone->assertValidState();
+
+ return $clone;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withHost($host): UriInterface
+ {
+ $host = $this->formatHost($this->filterString($host));
+ if ($host === $this->host) {
+ return $this;
+ }
+
+ $clone = clone $this;
+ $clone->host = $host;
+ $clone->authority = $clone->setAuthority();
+ $clone->assertValidState();
+
+ return $clone;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withPort($port): UriInterface
+ {
+ $port = $this->formatPort($port);
+ if ($port === $this->port) {
+ return $this;
+ }
+
+ $clone = clone $this;
+ $clone->port = $port;
+ $clone->authority = $clone->setAuthority();
+ $clone->assertValidState();
+
+ return $clone;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * @param string|object $path
+ */
+ public function withPath($path): UriInterface
+ {
+ $path = $this->filterString($path);
+ if (null === $path) {
+ throw new TypeError('A path must be a string NULL given.');
+ }
+
+ $path = $this->formatPath($path);
+ if ($path === $this->path) {
+ return $this;
+ }
+
+ $clone = clone $this;
+ $clone->path = $path;
+ $clone->assertValidState();
+
+ return $clone;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withQuery($query): UriInterface
+ {
+ $query = $this->formatQueryAndFragment($this->filterString($query));
+ if ($query === $this->query) {
+ return $this;
+ }
+
+ $clone = clone $this;
+ $clone->query = $query;
+ $clone->assertValidState();
+
+ return $clone;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function withFragment($fragment): UriInterface
+ {
+ $fragment = $this->formatQueryAndFragment($this->filterString($fragment));
+ if ($fragment === $this->fragment) {
+ return $this;
+ }
+
+ $clone = clone $this;
+ $clone->fragment = $fragment;
+ $clone->assertValidState();
+
+ return $clone;
+ }
+}
diff --git a/vendor/league/uri/src/UriInfo.php b/vendor/league/uri/src/UriInfo.php
new file mode 100644
index 0000000..ec8473c
--- /dev/null
+++ b/vendor/league/uri/src/UriInfo.php
@@ -0,0 +1,215 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri;
+
+use League\Uri\Contracts\UriInterface;
+use Psr\Http\Message\UriInterface as Psr7UriInterface;
+use TypeError;
+use function explode;
+use function implode;
+use function preg_replace_callback;
+use function rawurldecode;
+use function sprintf;
+
+final class UriInfo
+{
+ private const REGEXP_ENCODED_CHARS = ',%(2[D|E]|3[0-9]|4[1-9|A-F]|5[0-9|AF]|6[1-9|A-F]|7[0-9|E]),i';
+
+ private const WHATWG_SPECIAL_SCHEMES = ['ftp' => 21, 'http' => 80, 'https' => 443, 'ws' => 80, 'wss' => 443];
+
+ /**
+ * @codeCoverageIgnore
+ */
+ private function __construct()
+ {
+ }
+
+ /**
+ * @param Psr7UriInterface|UriInterface $uri
+ */
+ private static function emptyComponentValue($uri): ?string
+ {
+ return $uri instanceof Psr7UriInterface ? '' : null;
+ }
+
+ /**
+ * Filter the URI object.
+ *
+ * To be valid an URI MUST implement at least one of the following interface:
+ * - League\Uri\UriInterface
+ * - Psr\Http\Message\UriInterface
+ *
+ * @param mixed $uri the URI to validate
+ *
+ * @throws TypeError if the URI object does not implements the supported interfaces.
+ *
+ * @return Psr7UriInterface|UriInterface
+ */
+ private static function filterUri($uri)
+ {
+ if ($uri instanceof Psr7UriInterface || $uri instanceof UriInterface) {
+ return $uri;
+ }
+
+ throw new TypeError(sprintf('The uri must be a valid URI object received `%s`', is_object($uri) ? get_class($uri) : gettype($uri)));
+ }
+
+ /**
+ * Normalize an URI for comparison.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ *
+ * @return Psr7UriInterface|UriInterface
+ */
+ private static function normalize($uri)
+ {
+ $uri = self::filterUri($uri);
+ $null = self::emptyComponentValue($uri);
+
+ $path = $uri->getPath();
+ if ('/' === ($path[0] ?? '') || '' !== $uri->getScheme().$uri->getAuthority()) {
+ $path = UriResolver::resolve($uri, $uri->withPath('')->withQuery($null))->getPath();
+ }
+
+ $query = $uri->getQuery();
+ $fragment = $uri->getFragment();
+ $fragmentOrig = $fragment;
+ $pairs = null === $query ? [] : explode('&', $query);
+ sort($pairs, SORT_REGULAR);
+
+ $replace = static fn (array $matches): string => rawurldecode($matches[0]);
+
+ $retval = preg_replace_callback(self::REGEXP_ENCODED_CHARS, $replace, [$path, implode('&', $pairs), $fragment]);
+ if (null !== $retval) {
+ [$path, $query, $fragment] = $retval + ['', $null, $null];
+ }
+
+ if ($null !== $uri->getAuthority() && '' === $path) {
+ $path = '/';
+ }
+
+ return $uri
+ ->withHost(Uri::createFromComponents(['host' => $uri->getHost()])->getHost())
+ ->withPath($path)
+ ->withQuery([] === $pairs ? $null : $query)
+ ->withFragment($null === $fragmentOrig ? $fragmentOrig : $fragment);
+ }
+
+ /**
+ * Tell whether the URI represents an absolute URI.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ */
+ public static function isAbsolute($uri): bool
+ {
+ return self::emptyComponentValue($uri) !== self::filterUri($uri)->getScheme();
+ }
+
+ /**
+ * Tell whether the URI represents a network path.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ */
+ public static function isNetworkPath($uri): bool
+ {
+ $uri = self::filterUri($uri);
+ $null = self::emptyComponentValue($uri);
+
+ return $null === $uri->getScheme() && $null !== $uri->getAuthority();
+ }
+
+ /**
+ * Tell whether the URI represents an absolute path.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ */
+ public static function isAbsolutePath($uri): bool
+ {
+ $uri = self::filterUri($uri);
+ $null = self::emptyComponentValue($uri);
+
+ return $null === $uri->getScheme()
+ && $null === $uri->getAuthority()
+ && '/' === ($uri->getPath()[0] ?? '');
+ }
+
+ /**
+ * Tell whether the URI represents a relative path.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ */
+ public static function isRelativePath($uri): bool
+ {
+ $uri = self::filterUri($uri);
+ $null = self::emptyComponentValue($uri);
+
+ return $null === $uri->getScheme()
+ && $null === $uri->getAuthority()
+ && '/' !== ($uri->getPath()[0] ?? '');
+ }
+
+ /**
+ * Tell whether both URI refers to the same document.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ * @param Psr7UriInterface|UriInterface $base_uri
+ */
+ public static function isSameDocument($uri, $base_uri): bool
+ {
+ $uri = self::normalize($uri);
+ $base_uri = self::normalize($base_uri);
+
+ return (string) $uri->withFragment($uri instanceof Psr7UriInterface ? '' : null)
+ === (string) $base_uri->withFragment($base_uri instanceof Psr7UriInterface ? '' : null);
+ }
+
+ /**
+ * Returns the URI origin property as defined by WHATWG URL living standard.
+ *
+ * {@see https://url.spec.whatwg.org/#origin}
+ *
+ * For URI without a special scheme the method returns null
+ * For URI with the file scheme the method will return null (as this is left to the implementation decision)
+ * For URI with a special scheme the method returns the scheme followed by its authority (without the userinfo part)
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ */
+ public static function getOrigin($uri): ?string
+ {
+ $scheme = self::filterUri($uri)->getScheme();
+ if ('blob' === $scheme) {
+ $uri = Uri::createFromString($uri->getPath());
+ $scheme = $uri->getScheme();
+ }
+
+ if (null === $scheme || !array_key_exists($scheme, self::WHATWG_SPECIAL_SCHEMES)) {
+ return null;
+ }
+
+ $null = self::emptyComponentValue($uri);
+
+ return (string) $uri->withFragment($null)->withQuery($null)->withPath('')->withUserInfo($null);
+ }
+
+ /**
+ * @param Psr7UriInterface|UriInterface $uri
+ * @param Psr7UriInterface|UriInterface $base_uri
+ */
+ public static function isCrossOrigin($uri, $base_uri): bool
+ {
+ return null === ($uriString = self::getOrigin(Uri::createFromUri($uri)))
+ || null === ($baseUriString = self::getOrigin(Uri::createFromUri($base_uri)))
+ || $uriString !== $baseUriString;
+ }
+}
diff --git a/vendor/league/uri/src/UriResolver.php b/vendor/league/uri/src/UriResolver.php
new file mode 100644
index 0000000..1090383
--- /dev/null
+++ b/vendor/league/uri/src/UriResolver.php
@@ -0,0 +1,376 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri;
+
+use League\Uri\Contracts\UriInterface;
+use Psr\Http\Message\UriInterface as Psr7UriInterface;
+use TypeError;
+use function array_pop;
+use function array_reduce;
+use function count;
+use function end;
+use function explode;
+use function gettype;
+use function implode;
+use function in_array;
+use function sprintf;
+use function str_repeat;
+use function strpos;
+use function substr;
+
+final class UriResolver
+{
+ /**
+ * @var array<string,int>
+ */
+ const DOT_SEGMENTS = ['.' => 1, '..' => 1];
+
+ /**
+ * @codeCoverageIgnore
+ */
+ private function __construct()
+ {
+ }
+
+ /**
+ * Resolve an URI against a base URI using RFC3986 rules.
+ *
+ * If the first argument is a UriInterface the method returns a UriInterface object
+ * If the first argument is a Psr7UriInterface the method returns a Psr7UriInterface object
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ * @param Psr7UriInterface|UriInterface $base_uri
+ *
+ * @return Psr7UriInterface|UriInterface
+ */
+ public static function resolve($uri, $base_uri)
+ {
+ self::filterUri($uri);
+ self::filterUri($base_uri);
+ $null = $uri instanceof Psr7UriInterface ? '' : null;
+
+ if ($null !== $uri->getScheme()) {
+ return $uri
+ ->withPath(self::removeDotSegments($uri->getPath()));
+ }
+
+ if ($null !== $uri->getAuthority()) {
+ return $uri
+ ->withScheme($base_uri->getScheme())
+ ->withPath(self::removeDotSegments($uri->getPath()));
+ }
+
+ $user = $null;
+ $pass = null;
+ $userInfo = $base_uri->getUserInfo();
+ if (null !== $userInfo) {
+ [$user, $pass] = explode(':', $userInfo, 2) + [1 => null];
+ }
+
+ [$uri_path, $uri_query] = self::resolvePathAndQuery($uri, $base_uri);
+
+ return $uri
+ ->withPath(self::removeDotSegments($uri_path))
+ ->withQuery($uri_query)
+ ->withHost($base_uri->getHost())
+ ->withPort($base_uri->getPort())
+ ->withUserInfo((string) $user, $pass)
+ ->withScheme($base_uri->getScheme())
+ ;
+ }
+
+ /**
+ * Filter the URI object.
+ *
+ * @param mixed $uri an URI object
+ *
+ * @throws TypeError if the URI object does not implements the supported interfaces.
+ */
+ private static function filterUri($uri): void
+ {
+ if (!$uri instanceof UriInterface && !$uri instanceof Psr7UriInterface) {
+ throw new TypeError(sprintf('The uri must be a valid URI object received `%s`', gettype($uri)));
+ }
+ }
+
+ /**
+ * Remove dot segments from the URI path.
+ */
+ private static function removeDotSegments(string $path): string
+ {
+ if (false === strpos($path, '.')) {
+ return $path;
+ }
+
+ $old_segments = explode('/', $path);
+ $new_path = implode('/', array_reduce($old_segments, [UriResolver::class, 'reducer'], []));
+ if (isset(self::DOT_SEGMENTS[end($old_segments)])) {
+ $new_path .= '/';
+ }
+
+ // @codeCoverageIgnoreStart
+ // added because some PSR-7 implementations do not respect RFC3986
+ if (0 === strpos($path, '/') && 0 !== strpos($new_path, '/')) {
+ return '/'.$new_path;
+ }
+ // @codeCoverageIgnoreEnd
+
+ return $new_path;
+ }
+
+ /**
+ * Remove dot segments.
+ *
+ * @return array<int, string>
+ */
+ private static function reducer(array $carry, string $segment): array
+ {
+ if ('..' === $segment) {
+ array_pop($carry);
+
+ return $carry;
+ }
+
+ if (!isset(self::DOT_SEGMENTS[$segment])) {
+ $carry[] = $segment;
+ }
+
+ return $carry;
+ }
+
+ /**
+ * Resolve an URI path and query component.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ * @param Psr7UriInterface|UriInterface $base_uri
+ *
+ * @return array{0:string, 1:string|null}
+ */
+ private static function resolvePathAndQuery($uri, $base_uri): array
+ {
+ $target_path = $uri->getPath();
+ $target_query = $uri->getQuery();
+ $null = $uri instanceof Psr7UriInterface ? '' : null;
+ $baseNull = $base_uri instanceof Psr7UriInterface ? '' : null;
+
+ if (0 === strpos($target_path, '/')) {
+ return [$target_path, $target_query];
+ }
+
+ if ('' === $target_path) {
+ if ($null === $target_query) {
+ $target_query = $base_uri->getQuery();
+ }
+
+ $target_path = $base_uri->getPath();
+ //@codeCoverageIgnoreStart
+ //because some PSR-7 Uri implementations allow this RFC3986 forbidden construction
+ if ($baseNull !== $base_uri->getAuthority() && 0 !== strpos($target_path, '/')) {
+ $target_path = '/'.$target_path;
+ }
+ //@codeCoverageIgnoreEnd
+
+ return [$target_path, $target_query];
+ }
+
+ $base_path = $base_uri->getPath();
+ if ($baseNull !== $base_uri->getAuthority() && '' === $base_path) {
+ $target_path = '/'.$target_path;
+ }
+
+ if ('' !== $base_path) {
+ $segments = explode('/', $base_path);
+ array_pop($segments);
+ if ([] !== $segments) {
+ $target_path = implode('/', $segments).'/'.$target_path;
+ }
+ }
+
+ return [$target_path, $target_query];
+ }
+
+ /**
+ * Relativize an URI according to a base URI.
+ *
+ * This method MUST retain the state of the submitted URI instance, and return
+ * an URI instance of the same type that contains the applied modifications.
+ *
+ * This method MUST be transparent when dealing with error and exceptions.
+ * It MUST not alter of silence them apart from validating its own parameters.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ * @param Psr7UriInterface|UriInterface $base_uri
+ *
+ * @return Psr7UriInterface|UriInterface
+ */
+ public static function relativize($uri, $base_uri)
+ {
+ self::filterUri($uri);
+ self::filterUri($base_uri);
+ $uri = self::formatHost($uri);
+ $base_uri = self::formatHost($base_uri);
+ if (!self::isRelativizable($uri, $base_uri)) {
+ return $uri;
+ }
+
+ $null = $uri instanceof Psr7UriInterface ? '' : null;
+ $uri = $uri->withScheme($null)->withPort(null)->withUserInfo($null)->withHost($null);
+ $target_path = $uri->getPath();
+ if ($target_path !== $base_uri->getPath()) {
+ return $uri->withPath(self::relativizePath($target_path, $base_uri->getPath()));
+ }
+
+ if (self::componentEquals('getQuery', $uri, $base_uri)) {
+ return $uri->withPath('')->withQuery($null);
+ }
+
+ if ($null === $uri->getQuery()) {
+ return $uri->withPath(self::formatPathWithEmptyBaseQuery($target_path));
+ }
+
+ return $uri->withPath('');
+ }
+
+ /**
+ * Tells whether the component value from both URI object equals.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ * @param Psr7UriInterface|UriInterface $base_uri
+ */
+ private static function componentEquals(string $method, $uri, $base_uri): bool
+ {
+ return self::getComponent($method, $uri) === self::getComponent($method, $base_uri);
+ }
+
+ /**
+ * Returns the component value from the submitted URI object.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ */
+ private static function getComponent(string $method, $uri): ?string
+ {
+ $component = $uri->$method();
+ if ($uri instanceof Psr7UriInterface && '' === $component) {
+ return null;
+ }
+
+ return $component;
+ }
+
+ /**
+ * Filter the URI object.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ *
+ * @throws TypeError if the URI object does not implements the supported interfaces.
+ *
+ * @return Psr7UriInterface|UriInterface
+ */
+ private static function formatHost($uri)
+ {
+ if (!$uri instanceof Psr7UriInterface) {
+ return $uri;
+ }
+
+ $host = $uri->getHost();
+ if ('' === $host) {
+ return $uri;
+ }
+
+ return $uri->withHost((string) Uri::createFromComponents(['host' => $host])->getHost());
+ }
+
+ /**
+ * Tell whether the submitted URI object can be relativize.
+ *
+ * @param Psr7UriInterface|UriInterface $uri
+ * @param Psr7UriInterface|UriInterface $base_uri
+ */
+ private static function isRelativizable($uri, $base_uri): bool
+ {
+ return !UriInfo::isRelativePath($uri)
+ && self::componentEquals('getScheme', $uri, $base_uri)
+ && self::componentEquals('getAuthority', $uri, $base_uri);
+ }
+
+ /**
+ * Relative the URI for a authority-less target URI.
+ */
+ private static function relativizePath(string $path, string $basepath): string
+ {
+ $base_segments = self::getSegments($basepath);
+ $target_segments = self::getSegments($path);
+ $target_basename = array_pop($target_segments);
+ array_pop($base_segments);
+ foreach ($base_segments as $offset => $segment) {
+ if (!isset($target_segments[$offset]) || $segment !== $target_segments[$offset]) {
+ break;
+ }
+ unset($base_segments[$offset], $target_segments[$offset]);
+ }
+ $target_segments[] = $target_basename;
+
+ return self::formatPath(
+ str_repeat('../', count($base_segments)).implode('/', $target_segments),
+ $basepath
+ );
+ }
+
+ /**
+ * returns the path segments.
+ *
+ * @return string[]
+ */
+ private static function getSegments(string $path): array
+ {
+ if ('' !== $path && '/' === $path[0]) {
+ $path = substr($path, 1);
+ }
+
+ return explode('/', $path);
+ }
+
+ /**
+ * Formatting the path to keep a valid URI.
+ */
+ private static function formatPath(string $path, string $basepath): string
+ {
+ if ('' === $path) {
+ return in_array($basepath, ['', '/'], true) ? $basepath : './';
+ }
+
+ if (false === ($colon_pos = strpos($path, ':'))) {
+ return $path;
+ }
+
+ $slash_pos = strpos($path, '/');
+ if (false === $slash_pos || $colon_pos < $slash_pos) {
+ return "./$path";
+ }
+
+ return $path;
+ }
+
+ /**
+ * Formatting the path to keep a resolvable URI.
+ */
+ private static function formatPathWithEmptyBaseQuery(string $path): string
+ {
+ $target_segments = self::getSegments($path);
+ /** @var string $basename */
+ $basename = end($target_segments);
+
+ return '' === $basename ? './' : $basename;
+ }
+}
diff --git a/vendor/league/uri/src/UriString.php b/vendor/league/uri/src/UriString.php
new file mode 100644
index 0000000..674e1a4
--- /dev/null
+++ b/vendor/league/uri/src/UriString.php
@@ -0,0 +1,467 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri;
+
+use League\Uri\Exceptions\IdnaConversionFailed;
+use League\Uri\Exceptions\IdnSupportMissing;
+use League\Uri\Exceptions\SyntaxError;
+use League\Uri\Idna\Idna;
+use TypeError;
+use function array_merge;
+use function explode;
+use function filter_var;
+use function gettype;
+use function inet_pton;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+use function preg_match;
+use function rawurldecode;
+use function sprintf;
+use function strpos;
+use function substr;
+use const FILTER_FLAG_IPV6;
+use const FILTER_VALIDATE_IP;
+
+/**
+ * A class to parse a URI string according to RFC3986.
+ *
+ * @link https://tools.ietf.org/html/rfc3986
+ * @package League\Uri
+ * @author Ignace Nyamagana Butera <[email protected]>
+ * @since 6.0.0
+ */
+final class UriString
+{
+ /**
+ * Default URI component values.
+ */
+ private const URI_COMPONENTS = [
+ 'scheme' => null, 'user' => null, 'pass' => null, 'host' => null,
+ 'port' => null, 'path' => '', 'query' => null, 'fragment' => null,
+ ];
+
+ /**
+ * Simple URI which do not need any parsing.
+ */
+ private const URI_SCHORTCUTS = [
+ '' => [],
+ '#' => ['fragment' => ''],
+ '?' => ['query' => ''],
+ '?#' => ['query' => '', 'fragment' => ''],
+ '/' => ['path' => '/'],
+ '//' => ['host' => ''],
+ ];
+
+ /**
+ * Range of invalid characters in URI string.
+ */
+ private const REGEXP_INVALID_URI_CHARS = '/[\x00-\x1f\x7f]/';
+
+ /**
+ * RFC3986 regular expression URI splitter.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#appendix-B
+ */
+ private const REGEXP_URI_PARTS = ',^
+ (?<scheme>(?<scontent>[^:/?\#]+):)? # URI scheme component
+ (?<authority>//(?<acontent>[^/?\#]*))? # URI authority part
+ (?<path>[^?\#]*) # URI path component
+ (?<query>\?(?<qcontent>[^\#]*))? # URI query component
+ (?<fragment>\#(?<fcontent>.*))? # URI fragment component
+ ,x';
+
+ /**
+ * URI scheme regular expresssion.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.1
+ */
+ private const REGEXP_URI_SCHEME = '/^([a-z][a-z\d\+\.\-]*)?$/i';
+
+ /**
+ * IPvFuture regular expression.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ */
+ private const REGEXP_IP_FUTURE = '/^
+ v(?<version>[A-F0-9])+\.
+ (?:
+ (?<unreserved>[a-z0-9_~\-\.])|
+ (?<sub_delims>[!$&\'()*+,;=:]) # also include the : character
+ )+
+ $/ix';
+
+ /**
+ * General registered name regular expression.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ */
+ private const REGEXP_REGISTERED_NAME = '/(?(DEFINE)
+ (?<unreserved>[a-z0-9_~\-]) # . is missing as it is used to separate labels
+ (?<sub_delims>[!$&\'()*+,;=])
+ (?<encoded>%[A-F0-9]{2})
+ (?<reg_name>(?:(?&unreserved)|(?&sub_delims)|(?&encoded))*)
+ )
+ ^(?:(?&reg_name)\.)*(?&reg_name)\.?$/ix';
+
+ /**
+ * Invalid characters in host regular expression.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ */
+ private const REGEXP_INVALID_HOST_CHARS = '/
+ [:\/?#\[\]@ ] # gen-delims characters as well as the space character
+ /ix';
+
+ /**
+ * Invalid path for URI without scheme and authority regular expression.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.3
+ */
+ private const REGEXP_INVALID_PATH = ',^(([^/]*):)(.*)?/,';
+
+ /**
+ * Host and Port splitter regular expression.
+ */
+ private const REGEXP_HOST_PORT = ',^(?<host>\[.*\]|[^:]*)(:(?<port>.*))?$,';
+
+ /**
+ * IDN Host detector regular expression.
+ */
+ private const REGEXP_IDN_PATTERN = '/[^\x20-\x7f]/';
+
+ /**
+ * Only the address block fe80::/10 can have a Zone ID attach to
+ * let's detect the link local significant 10 bits.
+ */
+ private const ZONE_ID_ADDRESS_BLOCK = "\xfe\x80";
+
+ /**
+ * Generate an URI string representation from its parsed representation
+ * returned by League\UriString::parse() or PHP's parse_url.
+ *
+ * If you supply your own array, you are responsible for providing
+ * valid components without their URI delimiters.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-5.3
+ * @link https://tools.ietf.org/html/rfc3986#section-7.5
+ *
+ * @param array{
+ * scheme:?string,
+ * user:?string,
+ * pass:?string,
+ * host:?string,
+ * port:?int,
+ * path:?string,
+ * query:?string,
+ * fragment:?string
+ * } $components
+ */
+ public static function build(array $components): string
+ {
+ $result = $components['path'] ?? '';
+ if (isset($components['query'])) {
+ $result .= '?'.$components['query'];
+ }
+
+ if (isset($components['fragment'])) {
+ $result .= '#'.$components['fragment'];
+ }
+
+ $scheme = null;
+ if (isset($components['scheme'])) {
+ $scheme = $components['scheme'].':';
+ }
+
+ if (!isset($components['host'])) {
+ return $scheme.$result;
+ }
+
+ $scheme .= '//';
+ $authority = $components['host'];
+ if (isset($components['port'])) {
+ $authority .= ':'.$components['port'];
+ }
+
+ if (!isset($components['user'])) {
+ return $scheme.$authority.$result;
+ }
+
+ $authority = '@'.$authority;
+ if (!isset($components['pass'])) {
+ return $scheme.$components['user'].$authority.$result;
+ }
+
+ return $scheme.$components['user'].':'.$components['pass'].$authority.$result;
+ }
+
+ /**
+ * Parse an URI string into its components.
+ *
+ * This method parses a URI and returns an associative array containing any
+ * of the various components of the URI that are present.
+ *
+ * <code>
+ * $components = (new Parser())->parse('http://[email protected]:42?query#');
+ * var_export($components);
+ * //will display
+ * array(
+ * 'scheme' => 'http', // the URI scheme component
+ * 'user' => 'foo', // the URI user component
+ * 'pass' => null, // the URI pass component
+ * 'host' => 'test.example.com', // the URI host component
+ * 'port' => 42, // the URI port component
+ * 'path' => '', // the URI path component
+ * 'query' => 'query', // the URI query component
+ * 'fragment' => '', // the URI fragment component
+ * );
+ * </code>
+ *
+ * The returned array is similar to PHP's parse_url return value with the following
+ * differences:
+ *
+ * <ul>
+ * <li>All components are always present in the returned array</li>
+ * <li>Empty and undefined component are treated differently. And empty component is
+ * set to the empty string while an undefined component is set to the `null` value.</li>
+ * <li>The path component is never undefined</li>
+ * <li>The method parses the URI following the RFC3986 rules but you are still
+ * required to validate the returned components against its related scheme specific rules.</li>
+ * </ul>
+ *
+ * @link https://tools.ietf.org/html/rfc3986
+ *
+ * @param mixed $uri any scalar or stringable object
+ *
+ * @throws SyntaxError if the URI contains invalid characters
+ * @throws SyntaxError if the URI contains an invalid scheme
+ * @throws SyntaxError if the URI contains an invalid path
+ *
+ * @return array{
+ * scheme:?string,
+ * user:?string,
+ * pass:?string,
+ * host:?string,
+ * port:?int,
+ * path:string,
+ * query:?string,
+ * fragment:?string
+ * }
+ */
+ public static function parse($uri): array
+ {
+ if (is_object($uri) && method_exists($uri, '__toString')) {
+ $uri = (string) $uri;
+ }
+
+ if (!is_scalar($uri)) {
+ throw new TypeError(sprintf('The uri must be a scalar or a stringable object `%s` given', gettype($uri)));
+ }
+
+ $uri = (string) $uri;
+
+ if (isset(self::URI_SCHORTCUTS[$uri])) {
+ /** @var array{scheme:?string, user:?string, pass:?string, host:?string, port:?int, path:string, query:?string, fragment:?string} $components */
+ $components = array_merge(self::URI_COMPONENTS, self::URI_SCHORTCUTS[$uri]);
+
+ return $components;
+ }
+
+ if (1 === preg_match(self::REGEXP_INVALID_URI_CHARS, $uri)) {
+ throw new SyntaxError(sprintf('The uri `%s` contains invalid characters', $uri));
+ }
+
+ //if the first character is a known URI delimiter parsing can be simplified
+ $first_char = $uri[0];
+
+ //The URI is made of the fragment only
+ if ('#' === $first_char) {
+ [, $fragment] = explode('#', $uri, 2);
+ $components = self::URI_COMPONENTS;
+ $components['fragment'] = $fragment;
+
+ return $components;
+ }
+
+ //The URI is made of the query and fragment
+ if ('?' === $first_char) {
+ [, $partial] = explode('?', $uri, 2);
+ [$query, $fragment] = explode('#', $partial, 2) + [1 => null];
+ $components = self::URI_COMPONENTS;
+ $components['query'] = $query;
+ $components['fragment'] = $fragment;
+
+ return $components;
+ }
+
+ //use RFC3986 URI regexp to split the URI
+ preg_match(self::REGEXP_URI_PARTS, $uri, $parts);
+ $parts += ['query' => '', 'fragment' => ''];
+
+ if (':' === $parts['scheme'] || 1 !== preg_match(self::REGEXP_URI_SCHEME, $parts['scontent'])) {
+ throw new SyntaxError(sprintf('The uri `%s` contains an invalid scheme', $uri));
+ }
+
+ if ('' === $parts['scheme'].$parts['authority'] && 1 === preg_match(self::REGEXP_INVALID_PATH, $parts['path'])) {
+ throw new SyntaxError(sprintf('The uri `%s` contains an invalid path.', $uri));
+ }
+
+ /** @var array{scheme:?string, user:?string, pass:?string, host:?string, port:?int, path:string, query:?string, fragment:?string} $components */
+ $components = array_merge(
+ self::URI_COMPONENTS,
+ '' === $parts['authority'] ? [] : self::parseAuthority($parts['acontent']),
+ [
+ 'path' => $parts['path'],
+ 'scheme' => '' === $parts['scheme'] ? null : $parts['scontent'],
+ 'query' => '' === $parts['query'] ? null : $parts['qcontent'],
+ 'fragment' => '' === $parts['fragment'] ? null : $parts['fcontent'],
+ ]
+ );
+
+ return $components;
+ }
+
+ /**
+ * Parses the URI authority part.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2
+ *
+ * @throws SyntaxError If the port component is invalid
+ *
+ * @return array{user:?string, pass:?string, host:?string, port:?int}
+ */
+ private static function parseAuthority(string $authority): array
+ {
+ $components = ['user' => null, 'pass' => null, 'host' => '', 'port' => null];
+ if ('' === $authority) {
+ return $components;
+ }
+
+ $parts = explode('@', $authority, 2);
+ if (isset($parts[1])) {
+ [$components['user'], $components['pass']] = explode(':', $parts[0], 2) + [1 => null];
+ }
+
+ preg_match(self::REGEXP_HOST_PORT, $parts[1] ?? $parts[0], $matches);
+ $matches += ['port' => ''];
+
+ $components['port'] = self::filterPort($matches['port']);
+ $components['host'] = self::filterHost($matches['host']);
+
+ return $components;
+ }
+
+ /**
+ * Filter and format the port component.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ *
+ * @throws SyntaxError if the registered name is invalid
+ */
+ private static function filterPort(string $port): ?int
+ {
+ if ('' === $port) {
+ return null;
+ }
+
+ if (1 === preg_match('/^\d*$/', $port)) {
+ return (int) $port;
+ }
+
+ throw new SyntaxError(sprintf('The port `%s` is invalid', $port));
+ }
+
+ /**
+ * Returns whether a hostname is valid.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ *
+ * @throws SyntaxError if the registered name is invalid
+ */
+ private static function filterHost(string $host): string
+ {
+ if ('' === $host) {
+ return $host;
+ }
+
+ if ('[' !== $host[0] || ']' !== substr($host, -1)) {
+ return self::filterRegisteredName($host);
+ }
+
+ if (!self::isIpHost(substr($host, 1, -1))) {
+ throw new SyntaxError(sprintf('Host `%s` is invalid : the IP host is malformed', $host));
+ }
+
+ return $host;
+ }
+
+ /**
+ * Returns whether the host is an IPv4 or a registered named.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ *
+ * @throws SyntaxError if the registered name is invalid
+ * @throws IdnSupportMissing if IDN support or ICU requirement are not available or met.
+ */
+ private static function filterRegisteredName(string $host): string
+ {
+ $formatted_host = rawurldecode($host);
+ if (1 === preg_match(self::REGEXP_REGISTERED_NAME, $formatted_host)) {
+ return $host;
+ }
+
+ //to test IDN host non-ascii characters must be present in the host
+ if (1 !== preg_match(self::REGEXP_IDN_PATTERN, $formatted_host)) {
+ throw new SyntaxError(sprintf('Host `%s` is invalid : the host is not a valid registered name', $host));
+ }
+
+ $info = Idna::toAscii($host, Idna::IDNA2008_ASCII);
+ if (0 !== $info->errors()) {
+ throw IdnaConversionFailed::dueToIDNAError($host, $info);
+ }
+
+ return $host;
+ }
+
+ /**
+ * Validates a IPv6/IPvfuture host.
+ *
+ * @link https://tools.ietf.org/html/rfc3986#section-3.2.2
+ * @link https://tools.ietf.org/html/rfc6874#section-2
+ * @link https://tools.ietf.org/html/rfc6874#section-4
+ */
+ private static function isIpHost(string $ip_host): bool
+ {
+ if (false !== filter_var($ip_host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)) {
+ return true;
+ }
+
+ if (1 === preg_match(self::REGEXP_IP_FUTURE, $ip_host, $matches)) {
+ return !in_array($matches['version'], ['4', '6'], true);
+ }
+
+ $pos = strpos($ip_host, '%');
+ if (false === $pos || 1 === preg_match(
+ self::REGEXP_INVALID_HOST_CHARS,
+ rawurldecode(substr($ip_host, $pos))
+ )) {
+ return false;
+ }
+
+ $ip_host = substr($ip_host, 0, $pos);
+
+ return false !== filter_var($ip_host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)
+ && 0 === strpos((string) inet_pton($ip_host), self::ZONE_ID_ADDRESS_BLOCK);
+ }
+}
diff --git a/vendor/league/uri/src/UriTemplate.php b/vendor/league/uri/src/UriTemplate.php
new file mode 100644
index 0000000..ba7a5a3
--- /dev/null
+++ b/vendor/league/uri/src/UriTemplate.php
@@ -0,0 +1,134 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri;
+
+use League\Uri\Contracts\UriException;
+use League\Uri\Contracts\UriInterface;
+use League\Uri\Exceptions\SyntaxError;
+use League\Uri\Exceptions\TemplateCanNotBeExpanded;
+use League\Uri\UriTemplate\Template;
+use League\Uri\UriTemplate\VariableBag;
+use TypeError;
+
+/**
+ * Defines the URI Template syntax and the process for expanding a URI Template into a URI reference.
+ *
+ * @link https://tools.ietf.org/html/rfc6570
+ * @package League\Uri
+ * @author Ignace Nyamagana Butera <[email protected]>
+ * @since 6.1.0
+ *
+ * Based on GuzzleHttp\UriTemplate class in Guzzle v6.5.
+ * @link https://github.com/guzzle/guzzle/blob/6.5/src/UriTemplate.php
+ */
+final class UriTemplate
+{
+ private Template $template;
+ private VariableBag $defaultVariables;
+
+ /**
+ * @param object|string $template a string or an object with the __toString method
+ *
+ * @throws TypeError if the template is not a string or an object with the __toString method
+ * @throws SyntaxError if the template syntax is invalid
+ * @throws TemplateCanNotBeExpanded if the template variables are invalid
+ */
+ public function __construct($template, array $defaultVariables = [])
+ {
+ $this->template = Template::createFromString($template);
+ $this->defaultVariables = $this->filterVariables($defaultVariables);
+ }
+
+ public static function __set_state(array $properties): self
+ {
+ return new self($properties['template']->toString(), $properties['defaultVariables']->all());
+ }
+
+ /**
+ * Filters out variables for the given template.
+ *
+ * @param array<string,string|array<string>> $variables
+ */
+ private function filterVariables(array $variables): VariableBag
+ {
+ $output = new VariableBag();
+ foreach ($this->template->variableNames() as $name) {
+ if (isset($variables[$name])) {
+ $output->assign($name, $variables[$name]);
+ }
+ }
+
+ return $output;
+ }
+
+ /**
+ * The template string.
+ */
+ public function getTemplate(): string
+ {
+ return $this->template->toString();
+ }
+
+ /**
+ * Returns the names of the variables in the template, in order.
+ *
+ * @return string[]
+ */
+ public function getVariableNames(): array
+ {
+ return $this->template->variableNames();
+ }
+
+ /**
+ * Returns the default values used to expand the template.
+ *
+ * The returned list only contains variables whose name is part of the current template.
+ *
+ * @return array<string,string|array>
+ */
+ public function getDefaultVariables(): array
+ {
+ return $this->defaultVariables->all();
+ }
+
+ /**
+ * Returns a new instance with the updated default variables.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the modified default variables.
+ *
+ * If present, variables whose name is not part of the current template
+ * possible variable names are removed.
+ */
+ public function withDefaultVariables(array $defaultDefaultVariables): self
+ {
+ return new self(
+ $this->template->toString(),
+ $this->filterVariables($defaultDefaultVariables)->all()
+ );
+ }
+
+ /**
+ * @throws TemplateCanNotBeExpanded if the variable contains nested array values
+ * @throws UriException if the resulting expansion can not be converted to a UriInterface instance
+ */
+ public function expand(array $variables = []): UriInterface
+ {
+ return Uri::createFromString(
+ $this->template->expand(
+ $this->filterVariables($variables)->replace($this->defaultVariables)
+ )
+ );
+ }
+}
diff --git a/vendor/league/uri/src/UriTemplate/Expression.php b/vendor/league/uri/src/UriTemplate/Expression.php
new file mode 100644
index 0000000..99ecac9
--- /dev/null
+++ b/vendor/league/uri/src/UriTemplate/Expression.php
@@ -0,0 +1,329 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\UriTemplate;
+
+use League\Uri\Exceptions\SyntaxError;
+use League\Uri\Exceptions\TemplateCanNotBeExpanded;
+use function array_filter;
+use function array_keys;
+use function array_map;
+use function array_unique;
+use function explode;
+use function implode;
+use function preg_match;
+use function rawurlencode;
+use function str_replace;
+use function strpos;
+use function substr;
+
+final class Expression
+{
+ /**
+ * Expression regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc6570#section-2.2
+ */
+ private const REGEXP_EXPRESSION = '/^\{
+ (?:
+ (?<operator>[\.\/;\?&\=,\!@\|\+#])?
+ (?<variables>[^\}]*)
+ )
+ \}$/x';
+
+ /**
+ * Reserved Operator characters.
+ *
+ * @link https://tools.ietf.org/html/rfc6570#section-2.2
+ */
+ private const RESERVED_OPERATOR = '=,!@|';
+
+ /**
+ * Processing behavior according to the expression type operator.
+ *
+ * @link https://tools.ietf.org/html/rfc6570#appendix-A
+ */
+ private const OPERATOR_HASH_LOOKUP = [
+ '' => ['prefix' => '', 'joiner' => ',', 'query' => false],
+ '+' => ['prefix' => '', 'joiner' => ',', 'query' => false],
+ '#' => ['prefix' => '#', 'joiner' => ',', 'query' => false],
+ '.' => ['prefix' => '.', 'joiner' => '.', 'query' => false],
+ '/' => ['prefix' => '/', 'joiner' => '/', 'query' => false],
+ ';' => ['prefix' => ';', 'joiner' => ';', 'query' => true],
+ '?' => ['prefix' => '?', 'joiner' => '&', 'query' => true],
+ '&' => ['prefix' => '&', 'joiner' => '&', 'query' => true],
+ ];
+
+ private string $operator;
+ /** @var array<VarSpecifier> */
+ private array $varSpecifiers;
+ private string $joiner;
+ /** @var array<string> */
+ private array $variableNames;
+ private string $expressionString;
+
+ private function __construct(string $operator, VarSpecifier ...$varSpecifiers)
+ {
+ $this->operator = $operator;
+ $this->varSpecifiers = $varSpecifiers;
+ $this->joiner = self::OPERATOR_HASH_LOOKUP[$operator]['joiner'];
+ $this->variableNames = $this->setVariableNames();
+ $this->expressionString = $this->setExpressionString();
+ }
+
+ /**
+ * @return array<string>
+ */
+ private function setVariableNames(): array
+ {
+ return array_unique(array_map(
+ static fn (VarSpecifier $varSpecifier): string => $varSpecifier->name(),
+ $this->varSpecifiers
+ ));
+ }
+
+ private function setExpressionString(): string
+ {
+ $varSpecifierString = implode(',', array_map(
+ static fn (VarSpecifier $variable): string => $variable->toString(),
+ $this->varSpecifiers
+ ));
+
+ return '{'.$this->operator.$varSpecifierString.'}';
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public static function __set_state(array $properties): self
+ {
+ return new self($properties['operator'], ...$properties['varSpecifiers']);
+ }
+
+ /**
+ * @throws SyntaxError if the expression is invalid
+ * @throws SyntaxError if the operator used in the expression is invalid
+ * @throws SyntaxError if the variable specifiers is invalid
+ */
+ public static function createFromString(string $expression): self
+ {
+ if (1 !== preg_match(self::REGEXP_EXPRESSION, $expression, $parts)) {
+ throw new SyntaxError('The expression "'.$expression.'" is invalid.');
+ }
+
+ /** @var array{operator:string, variables:string} $parts */
+ $parts = $parts + ['operator' => ''];
+ if ('' !== $parts['operator'] && false !== strpos(self::RESERVED_OPERATOR, $parts['operator'])) {
+ throw new SyntaxError('The operator used in the expression "'.$expression.'" is reserved.');
+ }
+
+ return new Expression($parts['operator'], ...array_map(
+ static fn (string $varSpec): VarSpecifier => VarSpecifier::createFromString($varSpec),
+ explode(',', $parts['variables'])
+ ));
+ }
+
+ /**
+ * Returns the expression string representation.
+ *
+ */
+ public function toString(): string
+ {
+ return $this->expressionString;
+ }
+
+ /**
+ * @return array<string>
+ */
+ public function variableNames(): array
+ {
+ return $this->variableNames;
+ }
+
+ public function expand(VariableBag $variables): string
+ {
+ $parts = [];
+ foreach ($this->varSpecifiers as $varSpecifier) {
+ $parts[] = $this->replace($varSpecifier, $variables);
+ }
+
+ $expanded = implode($this->joiner, array_filter($parts, static fn ($value): bool => '' !== $value));
+ if ('' === $expanded) {
+ return $expanded;
+ }
+
+ $prefix = self::OPERATOR_HASH_LOOKUP[$this->operator]['prefix'];
+ if ('' === $prefix) {
+ return $expanded;
+ }
+
+ return $prefix.$expanded;
+ }
+
+ /**
+ * Replaces an expression with the given variables.
+ *
+ * @throws TemplateCanNotBeExpanded if the variables is an array and a ":" modifier needs to be applied
+ * @throws TemplateCanNotBeExpanded if the variables contains nested array values
+ */
+ private function replace(VarSpecifier $varSpec, VariableBag $variables): string
+ {
+ $value = $variables->fetch($varSpec->name());
+ if (null === $value) {
+ return '';
+ }
+
+ $useQuery = self::OPERATOR_HASH_LOOKUP[$this->operator]['query'];
+ [$expanded, $actualQuery] = $this->inject($value, $varSpec, $useQuery);
+ if (!$actualQuery) {
+ return $expanded;
+ }
+
+ if ('&' !== $this->joiner && '' === $expanded) {
+ return $varSpec->name();
+ }
+
+ return $varSpec->name().'='.$expanded;
+ }
+
+ /**
+ * @param string|array<string> $value
+ *
+ * @return array{0:string, 1:bool}
+ */
+ private function inject($value, VarSpecifier $varSpec, bool $useQuery): array
+ {
+ if (is_string($value)) {
+ return $this->replaceString($value, $varSpec, $useQuery);
+ }
+
+ return $this->replaceList($value, $varSpec, $useQuery);
+ }
+
+ /**
+ * Expands an expression using a string value.
+ *
+ * @return array{0:string, 1:bool}
+ */
+ private function replaceString(string $value, VarSpecifier $varSpec, bool $useQuery): array
+ {
+ if (':' === $varSpec->modifier()) {
+ $value = substr($value, 0, $varSpec->position());
+ }
+
+ $expanded = rawurlencode($value);
+ if ('+' === $this->operator || '#' === $this->operator) {
+ return [$this->decodeReserved($expanded), $useQuery];
+ }
+
+ return [$expanded, $useQuery];
+ }
+
+ /**
+ * Expands an expression using a list of values.
+ *
+ * @param array<string> $value
+ *
+ * @throws TemplateCanNotBeExpanded if the variables is an array and a ":" modifier needs to be applied
+ *
+ * @return array{0:string, 1:bool}
+ */
+ private function replaceList(array $value, VarSpecifier $varSpec, bool $useQuery): array
+ {
+ if ([] === $value) {
+ return ['', false];
+ }
+
+ if (':' === $varSpec->modifier()) {
+ throw TemplateCanNotBeExpanded::dueToUnableToProcessValueListWithPrefix($varSpec->name());
+ }
+
+ $pairs = [];
+ $isAssoc = $this->isAssoc($value);
+ foreach ($value as $key => $var) {
+ if ($isAssoc) {
+ $key = rawurlencode((string) $key);
+ }
+
+ $var = rawurlencode($var);
+ if ('+' === $this->operator || '#' === $this->operator) {
+ $var = $this->decodeReserved($var);
+ }
+
+ if ('*' === $varSpec->modifier()) {
+ if ($isAssoc) {
+ $var = $key.'='.$var;
+ } elseif ($key > 0 && $useQuery) {
+ $var = $varSpec->name().'='.$var;
+ }
+ }
+
+ $pairs[$key] = $var;
+ }
+
+ if ('*' === $varSpec->modifier()) {
+ if ($isAssoc) {
+ // Don't prepend the value name when using the explode
+ // modifier with an associative array.
+ $useQuery = false;
+ }
+
+ return [implode($this->joiner, $pairs), $useQuery];
+ }
+
+ if ($isAssoc) {
+ // When an associative array is encountered and the
+ // explode modifier is not set, then the result must be
+ // a comma separated list of keys followed by their
+ // respective values.
+ foreach ($pairs as $offset => &$data) {
+ $data = $offset.','.$data;
+ }
+
+ unset($data);
+ }
+
+ return [implode(',', $pairs), $useQuery];
+ }
+
+ /**
+ * Determines if an array is associative.
+ *
+ * This makes the assumption that input arrays are sequences or hashes.
+ * This assumption is a trade-off for accuracy in favor of speed, but it
+ * should work in almost every case where input is supplied for a URI
+ * template.
+ */
+ private function isAssoc(array $array): bool
+ {
+ return [] !== $array && 0 !== array_keys($array)[0];
+ }
+
+ /**
+ * Removes percent encoding on reserved characters (used with + and # modifiers).
+ */
+ private function decodeReserved(string $str): string
+ {
+ static $delimiters = [
+ ':', '/', '?', '#', '[', ']', '@', '!', '$',
+ '&', '\'', '(', ')', '*', '+', ',', ';', '=',
+ ];
+
+ static $delimitersEncoded = [
+ '%3A', '%2F', '%3F', '%23', '%5B', '%5D', '%40', '%21', '%24',
+ '%26', '%27', '%28', '%29', '%2A', '%2B', '%2C', '%3B', '%3D',
+ ];
+
+ return str_replace($delimitersEncoded, $delimiters, $str);
+ }
+}
diff --git a/vendor/league/uri/src/UriTemplate/Template.php b/vendor/league/uri/src/UriTemplate/Template.php
new file mode 100644
index 0000000..ecd130f
--- /dev/null
+++ b/vendor/league/uri/src/UriTemplate/Template.php
@@ -0,0 +1,126 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\UriTemplate;
+
+use League\Uri\Exceptions\SyntaxError;
+use League\Uri\Exceptions\TemplateCanNotBeExpanded;
+use TypeError;
+use function array_merge;
+use function array_unique;
+use function gettype;
+use function is_object;
+use function is_string;
+use function method_exists;
+use function preg_match_all;
+use function preg_replace;
+use function sprintf;
+use function strpos;
+use const PREG_SET_ORDER;
+
+final class Template
+{
+ /**
+ * Expression regular expression pattern.
+ */
+ private const REGEXP_EXPRESSION_DETECTOR = '/\{[^\}]*\}/x';
+
+ private string $template;
+ /** @var array<string, Expression> */
+ private array $expressions = [];
+ /** @var array<string> */
+ private array $variableNames;
+
+ private function __construct(string $template, Expression ...$expressions)
+ {
+ $this->template = $template;
+ $variableNames = [];
+ foreach ($expressions as $expression) {
+ $this->expressions[$expression->toString()] = $expression;
+ $variableNames[] = $expression->variableNames();
+ }
+ $this->variableNames = array_unique(array_merge([], ...$variableNames));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public static function __set_state(array $properties): self
+ {
+ return new self($properties['template'], ...array_values($properties['expressions']));
+ }
+
+ /**
+ * @param object|string $template a string or an object with the __toString method
+ *
+ * @throws TypeError if the template is not a string or an object with the __toString method
+ * @throws SyntaxError if the template contains invalid expressions
+ * @throws SyntaxError if the template contains invalid variable specification
+ */
+ public static function createFromString($template): self
+ {
+ if (is_object($template) && method_exists($template, '__toString')) {
+ $template = (string) $template;
+ }
+
+ if (!is_string($template)) {
+ throw new TypeError(sprintf('The template must be a string or a stringable object %s given.', gettype($template)));
+ }
+
+ /** @var string $remainder */
+ $remainder = preg_replace(self::REGEXP_EXPRESSION_DETECTOR, '', $template);
+ if (false !== strpos($remainder, '{') || false !== strpos($remainder, '}')) {
+ throw new SyntaxError('The template "'.$template.'" contains invalid expressions.');
+ }
+
+ $names = [];
+ preg_match_all(self::REGEXP_EXPRESSION_DETECTOR, $template, $findings, PREG_SET_ORDER);
+ $arguments = [];
+ foreach ($findings as $finding) {
+ if (!isset($names[$finding[0]])) {
+ $arguments[] = Expression::createFromString($finding[0]);
+ $names[$finding[0]] = 1;
+ }
+ }
+
+ return new self($template, ...$arguments);
+ }
+
+ public function toString(): string
+ {
+ return $this->template;
+ }
+
+ /**
+ * @return array<string>
+ */
+ public function variableNames(): array
+ {
+ return $this->variableNames;
+ }
+
+ /**
+ * @throws TemplateCanNotBeExpanded if the variables is an array and a ":" modifier needs to be applied
+ * @throws TemplateCanNotBeExpanded if the variables contains nested array values
+ */
+ public function expand(VariableBag $variables): string
+ {
+ $uriString = $this->template;
+ /** @var Expression $expression */
+ foreach ($this->expressions as $pattern => $expression) {
+ $uriString = str_replace($pattern, $expression->expand($variables), $uriString);
+ }
+
+ return $uriString;
+ }
+}
diff --git a/vendor/league/uri/src/UriTemplate/VarSpecifier.php b/vendor/league/uri/src/UriTemplate/VarSpecifier.php
new file mode 100644
index 0000000..ac49efb
--- /dev/null
+++ b/vendor/league/uri/src/UriTemplate/VarSpecifier.php
@@ -0,0 +1,96 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\UriTemplate;
+
+use League\Uri\Exceptions\SyntaxError;
+use function preg_match;
+
+final class VarSpecifier
+{
+ /**
+ * Variables specification regular expression pattern.
+ *
+ * @link https://tools.ietf.org/html/rfc6570#section-2.3
+ */
+ private const REGEXP_VARSPEC = '/^
+ (?<name>(?:[A-z0-9_\.]|%[0-9a-fA-F]{2})+)
+ (?<modifier>\:(?<position>\d+)|\*)?
+ $/x';
+
+ private string $name;
+ private string $modifier;
+ private int $position;
+
+ private function __construct(string $name, string $modifier, int $position)
+ {
+ $this->name = $name;
+ $this->modifier = $modifier;
+ $this->position = $position;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public static function __set_state(array $properties): self
+ {
+ return new self($properties['name'], $properties['modifier'], $properties['position']);
+ }
+
+ public static function createFromString(string $specification): self
+ {
+ if (1 !== preg_match(self::REGEXP_VARSPEC, $specification, $parsed)) {
+ throw new SyntaxError('The variable specification "'.$specification.'" is invalid.');
+ }
+
+ $parsed += ['modifier' => '', 'position' => ''];
+ if ('' !== $parsed['position']) {
+ $parsed['position'] = (int) $parsed['position'];
+ $parsed['modifier'] = ':';
+ }
+
+ if ('' === $parsed['position']) {
+ $parsed['position'] = 0;
+ }
+
+ if (10000 <= $parsed['position']) {
+ throw new SyntaxError('The variable specification "'.$specification.'" is invalid the position modifier must be lower than 10000.');
+ }
+
+ return new self($parsed['name'], $parsed['modifier'], $parsed['position']);
+ }
+
+ public function toString(): string
+ {
+ if (0 < $this->position) {
+ return $this->name.$this->modifier.$this->position;
+ }
+
+ return $this->name.$this->modifier;
+ }
+
+ public function name(): string
+ {
+ return $this->name;
+ }
+
+ public function modifier(): string
+ {
+ return $this->modifier;
+ }
+
+ public function position(): int
+ {
+ return $this->position;
+ }
+}
diff --git a/vendor/league/uri/src/UriTemplate/VariableBag.php b/vendor/league/uri/src/UriTemplate/VariableBag.php
new file mode 100644
index 0000000..cf60de9
--- /dev/null
+++ b/vendor/league/uri/src/UriTemplate/VariableBag.php
@@ -0,0 +1,114 @@
+<?php
+
+/**
+ * League.Uri (https://uri.thephpleague.com)
+ *
+ * (c) Ignace Nyamagana Butera <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace League\Uri\UriTemplate;
+
+use League\Uri\Exceptions\TemplateCanNotBeExpanded;
+use TypeError;
+use function gettype;
+use function is_array;
+use function is_bool;
+use function is_object;
+use function is_scalar;
+use function method_exists;
+use function sprintf;
+
+final class VariableBag
+{
+ /**
+ * @var array<string,string|array<string>>
+ */
+ private array $variables = [];
+
+ /**
+ * @param iterable<string,string|bool|int|float|array<string|bool|int|float>> $variables
+ */
+ public function __construct(iterable $variables = [])
+ {
+ foreach ($variables as $name => $value) {
+ $this->assign($name, $value);
+ }
+ }
+
+ public static function __set_state(array $properties): self
+ {
+ return new self($properties['variables']);
+ }
+
+ /**
+ * @return array<string,string|array<string>>
+ */
+ public function all(): array
+ {
+ return $this->variables;
+ }
+
+ /**
+ * Fetches the variable value if none found returns null.
+ *
+ * @return null|string|array<string>
+ */
+ public function fetch(string $name)
+ {
+ return $this->variables[$name] ?? null;
+ }
+
+ /**
+ * @param string|bool|int|float|array<string|bool|int|float> $value
+ */
+ public function assign(string $name, $value): void
+ {
+ $this->variables[$name] = $this->normalizeValue($value, $name, true);
+ }
+
+ /**
+ * @param mixed $value the value to be expanded
+ *
+ * @throws TemplateCanNotBeExpanded if the value contains nested list
+ *
+ * @return string|array<string>
+ */
+ private function normalizeValue($value, string $name, bool $isNestedListAllowed)
+ {
+ if (is_bool($value)) {
+ return true === $value ? '1' : '0';
+ }
+
+ if (null === $value || is_scalar($value) || (is_object($value) && method_exists($value, '__toString'))) {
+ return (string) $value;
+ }
+
+ if (!is_array($value)) {
+ throw new TypeError(sprintf('The variable '.$name.' must be NULL, a scalar or a stringable object `%s` given', gettype($value)));
+ }
+
+ if (!$isNestedListAllowed) {
+ throw TemplateCanNotBeExpanded::dueToNestedListOfValue($name);
+ }
+
+ foreach ($value as &$var) {
+ $var = self::normalizeValue($var, $name, false);
+ }
+ unset($var);
+
+ return $value;
+ }
+
+ /**
+ * Replaces elements from passed variables into the current instance.
+ */
+ public function replace(VariableBag $variables): self
+ {
+ return new self($this->variables + $variables->variables);
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-27 21:06:26 +0000