<form method="POST">
    <h3>Editing: Uri.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

declare(strict_types=1);

namespace GuzzleHttp\Psr7;

use GuzzleHttp\Psr7\Exception\MalformedUriException;
use Psr\Http\Message\UriInterface;

/**
 * PSR-7 URI implementation.
 *
 * @author Michael Dowling
 * @author Tobias Schultze
 * @author Matthew Weier O'Phinney
 */
class Uri implements UriInterface, \JsonSerializable
{
    /**
     * Absolute http and https URIs require a host per RFC 7230 Section 2.7
     * but in generic URIs the host can be empty. So for http(s) URIs
     * we apply this default host when no host is given yet to form a
     * valid URI.
     */
    private const HTTP_DEFAULT_HOST = 'localhost';

    private const DEFAULT_PORTS = [
        'http' =&gt; 80,
        'https' =&gt; 443,
        'ftp' =&gt; 21,
        'gopher' =&gt; 70,
        'nntp' =&gt; 119,
        'news' =&gt; 119,
        'telnet' =&gt; 23,
        'tn3270' =&gt; 23,
        'imap' =&gt; 143,
        'pop' =&gt; 110,
        'ldap' =&gt; 389,
    ];

    /**
     * Unreserved characters for use in a regex.
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-2.3
     */
    private const CHAR_UNRESERVED = 'a-zA-Z0-9_\-\.~';

    /**
     * Sub-delims for use in a regex.
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-2.2
     */
    private const CHAR_SUB_DELIMS = '!\$&amp;\'\(\)\*\+,;=';
    private const QUERY_SEPARATORS_REPLACEMENT = ['=' =&gt; '%3D', '&amp;' =&gt; '%26'];

    /** @var string Uri scheme. */
    private $scheme = '';

    /** @var string Uri user info. */
    private $userInfo = '';

    /** @var string Uri host. */
    private $host = '';

    /** @var int|null Uri port. */
    private $port;

    /** @var string Uri path. */
    private $path = '';

    /** @var string Uri query string. */
    private $query = '';

    /** @var string Uri fragment. */
    private $fragment = '';

    /** @var string|null String representation */
    private $composedComponents;

    public function __construct(string $uri = '')
    {
        if ($uri !== '') {
            $parts = self::parse($uri);
            if ($parts === false) {
                throw new MalformedUriException(&quot;Unable to parse URI: $uri&quot;);
            }
            $this-&gt;applyParts($parts);
        }
    }

    /**
     * UTF-8 aware \parse_url() replacement.
     *
     * The internal function produces broken output for non ASCII domain names
     * (IDN) when used with locales other than &quot;C&quot;.
     *
     * On the other hand, cURL understands IDN correctly only when UTF-8 locale
     * is configured (&quot;C.UTF-8&quot;, &quot;en_US.UTF-8&quot;, etc.).
     *
     * @see https://bugs.php.net/bug.php?id=52923
     * @see https://www.php.net/manual/en/function.parse-url.php#114817
     * @see https://curl.haxx.se/libcurl/c/CURLOPT_URL.html#ENCODING
     *
     * @return array|false
     */
    private static function parse(string $url)
    {
        // If IPv6
        $prefix = '';
        if (preg_match('%^(.*://\[[0-9:a-f]+\])(.*?)$%', $url, $matches)) {
            /** @var array{0:string, 1:string, 2:string} $matches */
            $prefix = $matches[1];
            $url = $matches[2];
        }

        /** @var string */
        $encodedUrl = preg_replace_callback(
            '%[^:/@?&amp;=#]+%usD',
            static function ($matches) {
                return urlencode($matches[0]);
            },
            $url
        );

        $result = parse_url($prefix.$encodedUrl);

        if ($result === false) {
            return false;
        }

        return array_map('urldecode', $result);
    }

    public function __toString(): string
    {
        if ($this-&gt;composedComponents === null) {
            $this-&gt;composedComponents = self::composeComponents(
                $this-&gt;scheme,
                $this-&gt;getAuthority(),
                $this-&gt;path,
                $this-&gt;query,
                $this-&gt;fragment
            );
        }

        return $this-&gt;composedComponents;
    }

    /**
     * Composes a URI reference string from its various components.
     *
     * Usually this method does not need to be called manually but instead is used indirectly via
     * `Psr\Http\Message\UriInterface::__toString`.
     *
     * PSR-7 UriInterface treats an empty component the same as a missing component as
     * getQuery(), getFragment() etc. always return a string. This explains the slight
     * difference to RFC 3986 Section 5.3.
     *
     * Another adjustment is that the authority separator is added even when the authority is missing/empty
     * for the &quot;file&quot; scheme. This is because PHP stream functions like `file_get_contents` only work with
     * `file:///myfile` but not with `file:/myfile` although they are equivalent according to RFC 3986. But
     * `file:///` is the more common syntax for the file scheme anyway (Chrome for example redirects to
     * that format).
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.3
     */
    public static function composeComponents(?string $scheme, ?string $authority, string $path, ?string $query, ?string $fragment): string
    {
        $uri = '';

        // weak type checks to also accept null until we can add scalar type hints
        if ($scheme != '') {
            $uri .= $scheme.':';
        }

        if ($authority != '' || $scheme === 'file') {
            $uri .= '//'.$authority;
        }

        if ($authority != '' &amp;&amp; $path != '' &amp;&amp; $path[0] != '/') {
            $path = '/'.$path;
        }

        $uri .= $path;

        if ($query != '') {
            $uri .= '?'.$query;
        }

        if ($fragment != '') {
            $uri .= '#'.$fragment;
        }

        return $uri;
    }

    /**
     * Whether the URI has the default port of the current scheme.
     *
     * `Psr\Http\Message\UriInterface::getPort` may return null or the standard port. This method can be used
     * independently of the implementation.
     */
    public static function isDefaultPort(UriInterface $uri): bool
    {
        return $uri-&gt;getPort() === null
            || (isset(self::DEFAULT_PORTS[$uri-&gt;getScheme()]) &amp;&amp; $uri-&gt;getPort() === self::DEFAULT_PORTS[$uri-&gt;getScheme()]);
    }

    /**
     * Whether the URI is absolute, i.e. it has a scheme.
     *
     * An instance of UriInterface can either be an absolute URI or a relative reference. This method returns true
     * if it is the former. An absolute URI has a scheme. A relative reference is used to express a URI relative
     * to another URI, the base URI. Relative references can be divided into several forms:
     * - network-path references, e.g. '//example.com/path'
     * - absolute-path references, e.g. '/path'
     * - relative-path references, e.g. 'subpath'
     *
     * @see Uri::isNetworkPathReference
     * @see Uri::isAbsolutePathReference
     * @see Uri::isRelativePathReference
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-4
     */
    public static function isAbsolute(UriInterface $uri): bool
    {
        return $uri-&gt;getScheme() !== '';
    }

    /**
     * Whether the URI is a network-path reference.
     *
     * A relative reference that begins with two slash characters is termed an network-path reference.
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-4.2
     */
    public static function isNetworkPathReference(UriInterface $uri): bool
    {
        return $uri-&gt;getScheme() === '' &amp;&amp; $uri-&gt;getAuthority() !== '';
    }

    /**
     * Whether the URI is a absolute-path reference.
     *
     * A relative reference that begins with a single slash character is termed an absolute-path reference.
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-4.2
     */
    public static function isAbsolutePathReference(UriInterface $uri): bool
    {
        return $uri-&gt;getScheme() === ''
            &amp;&amp; $uri-&gt;getAuthority() === ''
            &amp;&amp; isset($uri-&gt;getPath()[0])
            &amp;&amp; $uri-&gt;getPath()[0] === '/';
    }

    /**
     * Whether the URI is a relative-path reference.
     *
     * A relative reference that does not begin with a slash character is termed a relative-path reference.
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-4.2
     */
    public static function isRelativePathReference(UriInterface $uri): bool
    {
        return $uri-&gt;getScheme() === ''
            &amp;&amp; $uri-&gt;getAuthority() === ''
            &amp;&amp; (!isset($uri-&gt;getPath()[0]) || $uri-&gt;getPath()[0] !== '/');
    }

    /**
     * Whether the URI is a same-document reference.
     *
     * A same-document reference refers to a URI that is, aside from its fragment
     * component, identical to the base URI. When no base URI is given, only an empty
     * URI reference (apart from its fragment) is considered a same-document reference.
     *
     * @param UriInterface      $uri  The URI to check
     * @param UriInterface|null $base An optional base URI to compare against
     *
     * @see https://datatracker.ietf.org/doc/html/rfc3986#section-4.4
     */
    public static function isSameDocumentReference(UriInterface $uri, ?UriInterface $base = null): bool
    {
        if ($base !== null) {
            $uri = UriResolver::resolve($base, $uri);

            return ($uri-&gt;getScheme() === $base-&gt;getScheme())
                &amp;&amp; ($uri-&gt;getAuthority() === $base-&gt;getAuthority())
                &amp;&amp; ($uri-&gt;getPath() === $base-&gt;getPath())
                &amp;&amp; ($uri-&gt;getQuery() === $base-&gt;getQuery());
        }

        return $uri-&gt;getScheme() === '' &amp;&amp; $uri-&gt;getAuthority() === '' &amp;&amp; $uri-&gt;getPath() === '' &amp;&amp; $uri-&gt;getQuery() === '';
    }

    /**
     * Creates a new URI with a specific query string value removed.
     *
     * Any existing query string values that exactly match the provided key are
     * removed.
     *
     * @param UriInterface $uri URI to use as a base.
     * @param string       $key Query string key to remove.
     */
    public static function withoutQueryValue(UriInterface $uri, string $key): UriInterface
    {
        $result = self::getFilteredQueryString($uri, [$key]);

        return $uri-&gt;withQuery(implode('&amp;', $result));
    }

    /**
     * Creates a new URI with a specific query string value.
     *
     * Any existing query string values that exactly match the provided key are
     * removed and replaced with the given key value pair.
     *
     * A value of null will set the query string key without a value, e.g. &quot;key&quot;
     * instead of &quot;key=value&quot;.
     *
     * @param UriInterface $uri   URI to use as a base.
     * @param string       $key   Key to set.
     * @param string|null  $value Value to set
     */
    public static function withQueryValue(UriInterface $uri, string $key, ?string $value): UriInterface
    {
        $result = self::getFilteredQueryString($uri, [$key]);

        $result[] = self::generateQueryString($key, $value);

        return $uri-&gt;withQuery(implode('&amp;', $result));
    }

    /**
     * Creates a new URI with multiple specific query string values.
     *
     * It has the same behavior as withQueryValue() but for an associative array of key =&gt; value.
     *
     * @param UriInterface    $uri           URI to use as a base.
     * @param (string|null)[] $keyValueArray Associative array of key and values
     */
    public static function withQueryValues(UriInterface $uri, array $keyValueArray): UriInterface
    {
        $result = self::getFilteredQueryString($uri, array_keys($keyValueArray));

        foreach ($keyValueArray as $key =&gt; $value) {
            $result[] = self::generateQueryString((string) $key, $value !== null ? (string) $value : null);
        }

        return $uri-&gt;withQuery(implode('&amp;', $result));
    }

    /**
     * Creates a URI from a hash of `parse_url` components.
     *
     * @see https://www.php.net/manual/en/function.parse-url.php
     *
     * @throws MalformedUriException If the components do not form a valid URI.
     */
    public static function fromParts(array $parts): UriInterface
    {
        $uri = new self();
        $uri-&gt;applyParts($parts);
        $uri-&gt;validateState();

        return $uri;
    }

    public function getScheme(): string
    {
        return $this-&gt;scheme;
    }

    public function getAuthority(): string
    {
        $authority = $this-&gt;host;
        if ($this-&gt;userInfo !== '') {
            $authority = $this-&gt;userInfo.'@'.$authority;
        }

        if ($this-&gt;port !== null) {
            $authority .= ':'.$this-&gt;port;
        }

        return $authority;
    }

    public function getUserInfo(): string
    {
        return $this-&gt;userInfo;
    }

    public function getHost(): string
    {
        return $this-&gt;host;
    }

    public function getPort(): ?int
    {
        return $this-&gt;port;
    }

    public function getPath(): string
    {
        return $this-&gt;path;
    }

    public function getQuery(): string
    {
        return $this-&gt;query;
    }

    public function getFragment(): string
    {
        return $this-&gt;fragment;
    }

    public function withScheme($scheme): UriInterface
    {
        $scheme = $this-&gt;filterScheme($scheme);

        if ($this-&gt;scheme === $scheme) {
            return $this;
        }

        $new = clone $this;
        $new-&gt;scheme = $scheme;
        $new-&gt;composedComponents = null;
        $new-&gt;removeDefaultPort();
        $new-&gt;validateState();

        return $new;
    }

    public function withUserInfo($user, $password = null): UriInterface
    {
        $info = $this-&gt;filterUserInfoComponent($user);
        if ($password !== null) {
            $info .= ':'.$this-&gt;filterUserInfoComponent($password);
        }

        if ($this-&gt;userInfo === $info) {
            return $this;
        }

        $new = clone $this;
        $new-&gt;userInfo = $info;
        $new-&gt;composedComponents = null;
        $new-&gt;validateState();

        return $new;
    }

    public function withHost($host): UriInterface
    {
        $host = $this-&gt;filterHost($host);

        if ($this-&gt;host === $host) {
            return $this;
        }

        $new = clone $this;
        $new-&gt;host = $host;
        $new-&gt;composedComponents = null;
        $new-&gt;validateState();

        return $new;
    }

    public function withPort($port): UriInterface
    {
        $port = $this-&gt;filterPort($port);

        if ($this-&gt;port === $port) {
            return $this;
        }

        $new = clone $this;
        $new-&gt;port = $port;
        $new-&gt;composedComponents = null;
        $new-&gt;removeDefaultPort();
        $new-&gt;validateState();

        return $new;
    }

    public function withPath($path): UriInterface
    {
        $path = $this-&gt;filterPath($path);

        if ($this-&gt;path === $path) {
            return $this;
        }

        $new = clone $this;
        $new-&gt;path = $path;
        $new-&gt;composedComponents = null;
        $new-&gt;validateState();

        return $new;
    }

    public function withQuery($query): UriInterface
    {
        $query = $this-&gt;filterQueryAndFragment($query);

        if ($this-&gt;query === $query) {
            return $this;
        }

        $new = clone $this;
        $new-&gt;query = $query;
        $new-&gt;composedComponents = null;

        return $new;
    }

    public function withFragment($fragment): UriInterface
    {
        $fragment = $this-&gt;filterQueryAndFragment($fragment);

        if ($this-&gt;fragment === $fragment) {
            return $this;
        }

        $new = clone $this;
        $new-&gt;fragment = $fragment;
        $new-&gt;composedComponents = null;

        return $new;
    }

    public function jsonSerialize(): string
    {
        return $this-&gt;__toString();
    }

    /**
     * Apply parse_url parts to a URI.
     *
     * @param array $parts Array of parse_url parts to apply.
     */
    private function applyParts(array $parts): void
    {
        $this-&gt;scheme = isset($parts['scheme'])
            ? $this-&gt;filterScheme($parts['scheme'])
            : '';
        $this-&gt;userInfo = isset($parts['user'])
            ? $this-&gt;filterUserInfoComponent($parts['user'])
            : '';
        $this-&gt;host = isset($parts['host'])
            ? $this-&gt;filterHost($parts['host'])
            : '';
        $this-&gt;port = isset($parts['port'])
            ? $this-&gt;filterPort($parts['port'])
            : null;
        $this-&gt;path = isset($parts['path'])
            ? $this-&gt;filterPath($parts['path'])
            : '';
        $this-&gt;query = isset($parts['query'])
            ? $this-&gt;filterQueryAndFragment($parts['query'])
            : '';
        $this-&gt;fragment = isset($parts['fragment'])
            ? $this-&gt;filterQueryAndFragment($parts['fragment'])
            : '';
        if (isset($parts['pass'])) {
            $this-&gt;userInfo .= ':'.$this-&gt;filterUserInfoComponent($parts['pass']);
        }

        $this-&gt;removeDefaultPort();
    }

    /**
     * @param mixed $scheme
     *
     * @throws \InvalidArgumentException If the scheme is invalid.
     */
    private function filterScheme($scheme): string
    {
        if (!is_string($scheme)) {
            throw new \InvalidArgumentException('Scheme must be a string');
        }

        return \strtr($scheme, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
    }

    /**
     * @param mixed $component
     *
     * @throws \InvalidArgumentException If the user info is invalid.
     */
    private function filterUserInfoComponent($component): string
    {
        if (!is_string($component)) {
            throw new \InvalidArgumentException('User info must be a string');
        }

        return preg_replace_callback(
            '/(?:[^%'.self::CHAR_UNRESERVED.self::CHAR_SUB_DELIMS.']+|%(?![A-Fa-f0-9]{2}))/',
            [$this, 'rawurlencodeMatchZero'],
            $component
        );
    }

    /**
     * @param mixed $host
     *
     * @throws \InvalidArgumentException If the host is invalid.
     */
    private function filterHost($host): string
    {
        if (!is_string($host)) {
            throw new \InvalidArgumentException('Host must be a string');
        }

        return \strtr($host, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz');
    }

    /**
     * @param mixed $port
     *
     * @throws \InvalidArgumentException If the port is invalid.
     */
    private function filterPort($port): ?int
    {
        if ($port === null) {
            return null;
        }

        $port = (int) $port;
        if (0 &gt; $port || 0xFFFF &lt; $port) {
            throw new \InvalidArgumentException(
                sprintf('Invalid port: %d. Must be between 0 and 65535', $port)
            );
        }

        return $port;
    }

    /**
     * @param (string|int)[] $keys
     *
     * @return string[]
     */
    private static function getFilteredQueryString(UriInterface $uri, array $keys): array
    {
        $current = $uri-&gt;getQuery();

        if ($current === '') {
            return [];
        }

        $decodedKeys = array_map(function ($k): string {
            return rawurldecode((string) $k);
        }, $keys);

        return array_filter(explode('&amp;', $current), function ($part) use ($decodedKeys) {
            return !in_array(rawurldecode(explode('=', $part)[0]), $decodedKeys, true);
        });
    }

    private static function generateQueryString(string $key, ?string $value): string
    {
        // Query string separators (&quot;=&quot;, &quot;&amp;&quot;) within the key or value need to be encoded
        // (while preventing double-encoding) before setting the query string. All other
        // chars that need percent-encoding will be encoded by withQuery().
        $queryString = strtr($key, self::QUERY_SEPARATORS_REPLACEMENT);

        if ($value !== null) {
            $queryString .= '='.strtr($value, self::QUERY_SEPARATORS_REPLACEMENT);
        }

        return $queryString;
    }

    private function removeDefaultPort(): void
    {
        if ($this-&gt;port !== null &amp;&amp; self::isDefaultPort($this)) {
            $this-&gt;port = null;
        }
    }

    /**
     * Filters the path of a URI
     *
     * @param mixed $path
     *
     * @throws \InvalidArgumentException If the path is invalid.
     */
    private function filterPath($path): string
    {
        if (!is_string($path)) {
            throw new \InvalidArgumentException('Path must be a string');
        }

        return preg_replace_callback(
            '/(?:[^'.self::CHAR_UNRESERVED.self::CHAR_SUB_DELIMS.'%:@\/]++|%(?![A-Fa-f0-9]{2}))/',
            [$this, 'rawurlencodeMatchZero'],
            $path
        );
    }

    /**
     * Filters the query string or fragment of a URI.
     *
     * @param mixed $str
     *
     * @throws \InvalidArgumentException If the query or fragment is invalid.
     */
    private function filterQueryAndFragment($str): string
    {
        if (!is_string($str)) {
            throw new \InvalidArgumentException('Query and fragment must be a string');
        }

        return preg_replace_callback(
            '/(?:[^'.self::CHAR_UNRESERVED.self::CHAR_SUB_DELIMS.'%:@\/\?]++|%(?![A-Fa-f0-9]{2}))/',
            [$this, 'rawurlencodeMatchZero'],
            $str
        );
    }

    private function rawurlencodeMatchZero(array $match): string
    {
        return rawurlencode($match[0]);
    }

    private function validateState(): void
    {
        if ($this-&gt;host === '' &amp;&amp; ($this-&gt;scheme === 'http' || $this-&gt;scheme === 'https')) {
            $this-&gt;host = self::HTTP_DEFAULT_HOST;
        }

        if ($this-&gt;getAuthority() === '') {
            if (0 === strpos($this-&gt;path, '//')) {
                throw new MalformedUriException('The path of a URI without an authority must not start with two slashes &quot;//&quot;');
            }
            if ($this-&gt;scheme === '' &amp;&amp; false !== strpos(explode('/', $this-&gt;path, 2)[0], ':')) {
                throw new MalformedUriException('A relative URI must not have a path beginning with a segment containing a colon');
            }
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>