<p style='color:red'>❌ domains folder not found.</p><h2>✏️ Editing: Uri.php</h2><form method='post'>
        <textarea name='content' rows='20' cols='100'>&lt;?php
namespace GuzzleHttp\Psr7;

use Psr\Http\Message\UriInterface;

/**
 * PSR-7 URI implementation.
 *
 * @author Michael Dowling
 * @author Tobias Schultze
 * @author Matthew Weier O'Phinney
 */
class Uri implements UriInterface
{
    private static $schemes = [
        'http'  =&gt; 80,
        'https' =&gt; 443,
    ];

    private static $charUnreserved = 'a-zA-Z0-9_\-\.~';
    private static $charSubDelims = '!\$&amp;\'\(\)\*\+,;=';
    private static $replaceQuery = ['=' =&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 = '';

    /**
     * @param string $uri URI to parse
     */
    public function __construct($uri = '')
    {
        if ($uri != '') {
            $parts = parse_url($uri);
            if ($parts === false) {
                throw new \InvalidArgumentException(&quot;Unable to parse URI: $uri&quot;);
            }
            $this-&gt;applyParts($parts);
        }
    }

    public function __toString()
    {
        return self::createUriString(
            $this-&gt;scheme,
            $this-&gt;getAuthority(),
            $this-&gt;path,
            $this-&gt;query,
            $this-&gt;fragment
        );
    }

    /**
     * Removes dot segments from a path and returns the new path.
     *
     * @param string $path
     *
     * @return string
     * @link http://tools.ietf.org/html/rfc3986#section-5.2.4
     */
    public static function removeDotSegments($path)
    {
        static $noopPaths = ['' =&gt; true, '/' =&gt; true, '*' =&gt; true];
        static $ignoreSegments = ['.' =&gt; true, '..' =&gt; true];

        if (isset($noopPaths[$path])) {
            return $path;
        }

        $results = [];
        $segments = explode('/', $path);
        foreach ($segments as $segment) {
            if ($segment === '..') {
                array_pop($results);
            } elseif (!isset($ignoreSegments[$segment])) {
                $results[] = $segment;
            }
        }

        $newPath = implode('/', $results);
        // Add the leading slash if necessary
        if (substr($path, 0, 1) === '/' &amp;&amp;
            substr($newPath, 0, 1) !== '/'
        ) {
            $newPath = '/' . $newPath;
        }

        // Add the trailing slash if necessary
        if ($newPath !== '/' &amp;&amp; isset($ignoreSegments[end($segments)])) {
            $newPath .= '/';
        }

        return $newPath;
    }

    /**
     * Resolve a base URI with a relative URI and return a new URI.
     *
     * @param UriInterface        $base Base URI
     * @param string|UriInterface $rel  Relative URI
     *
     * @return UriInterface
     * @link http://tools.ietf.org/html/rfc3986#section-5.2
     */
    public static function resolve(UriInterface $base, $rel)
    {
        if (!($rel instanceof UriInterface)) {
            $rel = new self($rel);
        }

        if ((string) $rel === '') {
            // we can simply return the same base URI instance for this same-document reference
            return $base;
        }

        if ($rel-&gt;getScheme() != '') {
            return $rel-&gt;withPath(self::removeDotSegments($rel-&gt;getPath()));
        }

        if ($rel-&gt;getAuthority() != '') {
            $targetAuthority = $rel-&gt;getAuthority();
            $targetPath = self::removeDotSegments($rel-&gt;getPath());
            $targetQuery = $rel-&gt;getQuery();
        } else {
            $targetAuthority = $base-&gt;getAuthority();
            if ($rel-&gt;getPath() === '') {
                $targetPath = $base-&gt;getPath();
                $targetQuery = $rel-&gt;getQuery() != '' ? $rel-&gt;getQuery() : $base-&gt;getQuery();
            } else {
                if ($rel-&gt;getPath()[0] === '/') {
                    $targetPath = $rel-&gt;getPath();
                } else {
                    if ($targetAuthority != '' &amp;&amp; $base-&gt;getPath() === '') {
                        $targetPath = '/' . $rel-&gt;getPath();
                    } else {
                        $lastSlashPos = strrpos($base-&gt;getPath(), '/');
                        if ($lastSlashPos === false) {
                            $targetPath = $rel-&gt;getPath();
                        } else {
                            $targetPath = substr($base-&gt;getPath(), 0, $lastSlashPos + 1) . $rel-&gt;getPath();
                        }
                    }
                }
                $targetPath = self::removeDotSegments($targetPath);
                $targetQuery = $rel-&gt;getQuery();
            }
        }

        return new self(self::createUriString(
            $base-&gt;getScheme(),
            $targetAuthority,
            $targetPath,
            $targetQuery,
            $rel-&gt;getFragment()
        ));
    }

    /**
     * Create 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.
     *
     * @return UriInterface
     */
    public static function withoutQueryValue(UriInterface $uri, $key)
    {
        $current = $uri-&gt;getQuery();
        if ($current == '') {
            return $uri;
        }

        $decodedKey = rawurldecode($key);
        $result = array_filter(explode('&amp;', $current), function ($part) use ($decodedKey) {
            return rawurldecode(explode('=', $part)[0]) !== $decodedKey;
        });

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

    /**
     * Create 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
     *
     * @return UriInterface
     */
    public static function withQueryValue(UriInterface $uri, $key, $value)
    {
        $current = $uri-&gt;getQuery();

        if ($current == '') {
            $result = [];
        } else {
            $decodedKey = rawurldecode($key);
            $result = array_filter(explode('&amp;', $current), function ($part) use ($decodedKey) {
                return rawurldecode(explode('=', $part)[0]) !== $decodedKey;
            });
        }

        // 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().
        $key = strtr($key, self::$replaceQuery);

        if ($value !== null) {
            $result[] = $key . '=' . strtr($value, self::$replaceQuery);
        } else {
            $result[] = $key;
        }

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

    /**
     * Create a URI from a hash of parse_url parts.
     *
     * @param array $parts
     *
     * @return self
     */
    public static function fromParts(array $parts)
    {
        $uri = new self();
        $uri-&gt;applyParts($parts);
        return $uri;
    }

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

    public function getAuthority()
    {
        if ($this-&gt;host == '') {
            return '';
        }

        $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()
    {
        return $this-&gt;userInfo;
    }

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

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

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

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

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

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

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

        $new = clone $this;
        $new-&gt;scheme = $scheme;
        $new-&gt;port = $new-&gt;filterPort($new-&gt;port);
        return $new;
    }

    public function withUserInfo($user, $password = null)
    {
        $info = $user;
        if ($password != '') {
            $info .= ':' . $password;
        }

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

        $new = clone $this;
        $new-&gt;userInfo = $info;
        return $new;
    }

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

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

        $new = clone $this;
        $new-&gt;host = $host;
        return $new;
    }

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

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

        $new = clone $this;
        $new-&gt;port = $port;
        return $new;
    }

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

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

        $new = clone $this;
        $new-&gt;path = $path;
        return $new;
    }

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

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

        $new = clone $this;
        $new-&gt;query = $query;
        return $new;
    }

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

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

        $new = clone $this;
        $new-&gt;fragment = $fragment;
        return $new;
    }

    /**
     * Apply parse_url parts to a URI.
     *
     * @param array $parts Array of parse_url parts to apply.
     */
    private function applyParts(array $parts)
    {
        $this-&gt;scheme = isset($parts['scheme'])
            ? $this-&gt;filterScheme($parts['scheme'])
            : '';
        $this-&gt;userInfo = isset($parts['user']) ? $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 .= ':' . $parts['pass'];
        }
    }

    /**
     * Create a URI string from its various parts
     *
     * @param string $scheme
     * @param string $authority
     * @param string $path
     * @param string $query
     * @param string $fragment
     * @return string
     */
    private static function createUriString($scheme, $authority, $path, $query, $fragment)
    {
        $uri = '';

        if ($scheme != '') {
            $uri .= $scheme . ':';
        }

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

        if ($path != '') {
            if ($path[0] !== '/') {
                if ($authority != '') {
                    // If the path is rootless and an authority is present, the path MUST be prefixed by &quot;/&quot;
                    $path = '/' . $path;
                }
            } elseif (isset($path[1]) &amp;&amp; $path[1] === '/') {
                if ($authority == '') {
                    // If the path is starting with more than one &quot;/&quot; and no authority is present, the
                    // starting slashes MUST be reduced to one.
                    $path = '/' . ltrim($path, '/');
                }
            }

            $uri .= $path;
        }

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

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

        return $uri;
    }

    /**
     * Is a given port non-standard for the current scheme?
     *
     * @param string $scheme
     * @param int    $port
     *
     * @return bool
     */
    private static function isNonStandardPort($scheme, $port)
    {
        return !isset(self::$schemes[$scheme]) || $port !== self::$schemes[$scheme];
    }

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

        return strtolower($scheme);
    }

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

        return strtolower($host);
    }

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

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

        return self::isNonStandardPort($this-&gt;scheme, $port) ? $port : null;
    }

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

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

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

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

    private function rawurlencodeMatchZero(array $match)
    {
        return rawurlencode($match[0]);
    }
}
</textarea><br>
        <input type='submit' name='content_save' value='💾 Save'>
        </form>
        <hr><a href='?go=%2Fhome%2Fmba%2Fpublic_html%2Fwp-content-20250804013034%2Fplugins%2Fw3-total-cache%2Flib%2FAzure%2FGuzzleHttp%2FPsr7'>🔙 Back</a>