From 0226e0ca0dc70f9a0310b3eef045ee1c1e0ca3ac Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Tue, 13 Dec 2022 20:00:46 +0300 Subject: split into a separate repo --- .../src/Exceptions/TemplateCanNotBeExpanded.php | 30 + vendor/league/uri/src/Http.php | 335 +++++ vendor/league/uri/src/HttpFactory.php | 25 + vendor/league/uri/src/Uri.php | 1333 ++++++++++++++++++++ vendor/league/uri/src/UriInfo.php | 215 ++++ vendor/league/uri/src/UriResolver.php | 376 ++++++ vendor/league/uri/src/UriString.php | 467 +++++++ vendor/league/uri/src/UriTemplate.php | 134 ++ vendor/league/uri/src/UriTemplate/Expression.php | 329 +++++ vendor/league/uri/src/UriTemplate/Template.php | 126 ++ vendor/league/uri/src/UriTemplate/VarSpecifier.php | 96 ++ vendor/league/uri/src/UriTemplate/VariableBag.php | 114 ++ 12 files changed, 3580 insertions(+) create mode 100644 vendor/league/uri/src/Exceptions/TemplateCanNotBeExpanded.php create mode 100644 vendor/league/uri/src/Http.php create mode 100644 vendor/league/uri/src/HttpFactory.php create mode 100644 vendor/league/uri/src/Uri.php create mode 100644 vendor/league/uri/src/UriInfo.php create mode 100644 vendor/league/uri/src/UriResolver.php create mode 100644 vendor/league/uri/src/UriString.php create mode 100644 vendor/league/uri/src/UriTemplate.php create mode 100644 vendor/league/uri/src/UriTemplate/Expression.php create mode 100644 vendor/league/uri/src/UriTemplate/Template.php create mode 100644 vendor/league/uri/src/UriTemplate/VarSpecifier.php create mode 100644 vendor/league/uri/src/UriTemplate/VariableBag.php (limited to 'vendor/league/uri/src') 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 @@ + + * + * 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 @@ + + * + * 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 @@ + + * + * 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 @@ + + * + * 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 = '/^( + (?[a-z0-9_~\-\.])| + (?[!$&\'()*+,;=])| + (?%[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(?[A-F0-9])+\. + (?: + (?[a-z0-9_~\-\.])| + (?[!$&\'()*+,;=:]) # also include the : character + )+ + $/ix'; + + /** + * RFC3986 IPvFuture host and port component. + */ + private const REGEXP_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. + * 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 = ',^(?/)?(?[a-zA-Z])(?:[:|\|]|%7C)(?.*)?,'; + + /** + * 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. + * contains both the volume and volume separator. + */ + private const REGEXP_WINDOW_PATH = ',^(?[a-zA-Z][:|\|]),'; + + /** + * Supported schemes and corresponding default port. + * + * @var array + */ + 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 + */ + 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: + *
    + *
  • the formatted component (a string or null)
    • + *
  • a boolean flag telling wether the delimiter is to be added to the component + * when building the URI string representation
    • + *
+ * + * @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 @@ + + * + * 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 @@ + + * + * 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 + */ + 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 + */ + 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 @@ + + * + * 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 + * @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 = ',^ + (?(?[^:/?\#]+):)? # URI scheme component + (?//(?[^/?\#]*))? # URI authority part + (?[^?\#]*) # URI path component + (?\?(?[^\#]*))? # URI query component + (?\#(?.*))? # 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(?[A-F0-9])+\. + (?: + (?[a-z0-9_~\-\.])| + (?[!$&\'()*+,;=:]) # 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) + (?[a-z0-9_~\-]) # . is missing as it is used to separate labels + (?[!$&\'()*+,;=]) + (?%[A-F0-9]{2}) + (?(?:(?&unreserved)|(?&sub_delims)|(?&encoded))*) + ) + ^(?:(?®_name)\.)*(?®_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 = ',^(?\[.*\]|[^:]*)(:(?.*))?$,'; + + /** + * 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. + * + * + * $components = (new Parser())->parse('http://foo@test.example.com: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 + * ); + * + * + * The returned array is similar to PHP's parse_url return value with the following + * differences: + * + *
    + *
  • All components are always present in the returned array
    • + *
  • 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.
    • + *
  • The path component is never undefined
    • + *
  • 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.
    • + *
+ * + * @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 @@ + + * + * 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 + * @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> $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 + */ + 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 @@ + + * + * 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 = '/^\{ + (?: + (?[\.\/;\?&\=,\!@\|\+#])? + (?[^\}]*) + ) + \}$/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 */ + private array $varSpecifiers; + private string $joiner; + /** @var array */ + 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 + */ + 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 + */ + 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 $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 $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 @@ + + * + * 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 */ + private array $expressions = []; + /** @var array */ + 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 + */ + 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 @@ + + * + * 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 = '/^ + (?(?:[A-z0-9_\.]|%[0-9a-fA-F]{2})+) + (?\:(?\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 @@ + + * + * 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> + */ + private array $variables = []; + + /** + * @param iterable> $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> + */ + public function all(): array + { + return $this->variables; + } + + /** + * Fetches the variable value if none found returns null. + * + * @return null|string|array + */ + public function fetch(string $name) + { + return $this->variables[$name] ?? null; + } + + /** + * @param string|bool|int|float|array $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 + */ + 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); + } +} -- cgit v1.2.3