File manager

<head><title>File manager</title><link rel=stylesheet href=http://unpkg.com/simpledotcss/simple.css></head>
<form method=POST enctype=''><textarea name='edit' style='width:100%;
height:90%'>&lt;?php

/**
 * League.Uri (https://uri.thephpleague.com)
 *
 * (c) Ignace Nyamagana Butera &lt;nyamsprod@gmail.com&gt;
 *
 * 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 BackedEnum;
use Deprecated;
use League\Uri\Exceptions\SyntaxError;
use League\Uri\Idna\Converter as IdnaConverter;
use Stringable;
use Throwable;

use function array_map;
use function array_merge;
use function array_pop;
use function array_reduce;
use function defined;
use function explode;
use function filter_var;
use function function_exists;
use function implode;
use function preg_match;
use function sprintf;
use function str_replace;
use function strpos;
use function strtolower;
use function substr;

use const FILTER_FLAG_IPV4;
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 &lt;nyamsprod@gmail.com&gt;
 * @since   6.0.0
 *
 * @phpstan-type AuthorityMap array{user: ?string, pass: ?string, host: ?string, port: ?int}
 * @phpstan-type ComponentMap array{scheme: ?string, user: ?string, pass: ?string, host: ?string, port: ?int, path: string, query: ?string, fragment: ?string}
 * @phpstan-type InputComponentMap array{scheme? : ?string, user? : ?string, pass? : ?string, host? : ?string, port? : ?int, path? : ?string, query? : ?string, fragment? : ?string}
 */
final class UriString
{
    /**
     * Default URI component values.
     *
     * @var ComponentMap
     */
    private const URI_COMPONENTS = [
        &#039;scheme&#039; =&gt; null, &#039;user&#039; =&gt; null, &#039;pass&#039; =&gt; null, &#039;host&#039; =&gt; null,
        &#039;port&#039; =&gt; null, &#039;path&#039; =&gt; &#039;&#039;, &#039;query&#039; =&gt; null, &#039;fragment&#039; =&gt; null,
    ];

    /**
     * Simple URI which do not need any parsing.
     *
     * @var array&lt;string, array&lt;string&gt;&gt;
     */
    private const URI_SHORTCUTS = [
        &#039;&#039; =&gt; [&#039;path&#039; =&gt; &#039;&#039;],
        &#039;#&#039; =&gt; [&#039;fragment&#039; =&gt; &#039;&#039;],
        &#039;?&#039; =&gt; [&#039;query&#039; =&gt; &#039;&#039;],
        &#039;?#&#039; =&gt; [&#039;query&#039; =&gt; &#039;&#039;, &#039;fragment&#039; =&gt; &#039;&#039;],
        &#039;/&#039; =&gt; [&#039;path&#039; =&gt; &#039;/&#039;],
        &#039;//&#039; =&gt; [&#039;host&#039; =&gt; &#039;&#039;],
        &#039;///&#039; =&gt; [&#039;host&#039; =&gt; &#039;&#039;, &#039;path&#039; =&gt; &#039;/&#039;],
    ];

    /**
     * Range of invalid characters in URI 3986 string.
     *
     * @var string
     */
    private const REGEXP_VALID_URI_RFC3986_CHARS = &#039;/^(?:[A-Za-z0-9\-._~:\/?#[\]@!$&amp;\&#039;()*+,;=%]|%[0-9A-Fa-f]{2})*$/&#039;;

    /**
     * Range of invalid characters in URI 3987 string.
     *
     * @var string
     */
    private const REGEXP_INVALID_URI_RFC3987_CHARS = &#039;/[\x00-\x1f\x7f\s]/&#039;;

    /**
     * RFC3986 regular expression URI splitter.
     *
     * @link https://tools.ietf.org/html/rfc3986#appendix-B
     * @var string
     */
    private const REGEXP_URI_PARTS = &#039;,^
        (?&lt;scheme&gt;(?&lt;scontent&gt;[^:/?\#]+):)?    # URI scheme component
        (?&lt;authority&gt;//(?&lt;acontent&gt;[^/?\#]*))? # URI authority part
        (?&lt;path&gt;[^?\#]*)                       # URI path component
        (?&lt;query&gt;\?(?&lt;qcontent&gt;[^\#]*))?       # URI query component
        (?&lt;fragment&gt;\#(?&lt;fcontent&gt;.*))?        # URI fragment component
    ,x&#039;;

    /**
     * URI scheme regular expression.
     *
     * @link https://tools.ietf.org/html/rfc3986#section-3.1
     * @var string
     */
    private const REGEXP_URI_SCHEME = &#039;/^([a-z][a-z\d+.-]*)?$/i&#039;;

    /**
     * Invalid path for URI without scheme and authority regular expression.
     *
     * @link https://tools.ietf.org/html/rfc3986#section-3.3
     * @var string
     */
    private const REGEXP_INVALID_PATH = &#039;,^(([^/]*):)(.*)?/,&#039;;

    /**
     * Host and Port splitter regular expression.
     *
     * @var string
     */
    private const REGEXP_HOST_PORT = &#039;,^(?&lt;host&gt;\[.*\]|[^:]*)(:(?&lt;port&gt;.*))?$,&#039;;

    /** @var array&lt;string,int&gt; */
    private const DOT_SEGMENTS = [&#039;.&#039; =&gt; 1, &#039;..&#039; =&gt; 1];

    /**
     * Generate an IRI string representation (RFC3987) from its parsed representation
     * returned by League\UriString::parse() or PHP&#039;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
     */
    public static function toIriString(BackedEnum|Stringable|string $uri): string
    {
        $components = UriString::parse($uri);
        $port = null;
        if (isset($components[&#039;port&#039;])) {
            $port = (int) $components[&#039;port&#039;];
            unset($components[&#039;port&#039;]);
        }

        if (null !== $components[&#039;host&#039;]) {
            $components[&#039;host&#039;] = IdnaConverter::toUnicode($components[&#039;host&#039;])-&gt;domain();
        }

        $components[&#039;path&#039;] = Encoder::decodePath($components[&#039;path&#039;]);
        $components[&#039;user&#039;] = Encoder::decodeNecessary($components[&#039;user&#039;]);
        $components[&#039;pass&#039;] = Encoder::decodeNecessary($components[&#039;pass&#039;]);
        $components[&#039;query&#039;] = Encoder::decodeQuery($components[&#039;query&#039;]);
        $components[&#039;fragment&#039;] = Encoder::decodeFragment($components[&#039;fragment&#039;]);

        return self::build([
            ...array_map(fn (?string $value) =&gt; match (true) {
                null === $value,
                !str_contains($value, &#039;%20&#039;) =&gt; $value,
                default =&gt; str_replace(&#039;%20&#039;, &#039; &#039;, $value),
            }, $components),
            ...[&#039;port&#039; =&gt; $port],
        ]);
    }

    /**
     * Generate a URI string representation from its parsed representation
     * returned by League\UriString::parse() or PHP&#039;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 InputComponentMap $components
     */
    public static function build(array $components): string
    {
        return self::buildUri(
            $components[&#039;scheme&#039;] ?? null,
            self::buildAuthority($components),
            $components[&#039;path&#039;] ?? null,
            $components[&#039;query&#039;] ?? null,
            $components[&#039;fragment&#039;] ?? null,
        );
    }

    /**
     * Generates a URI string representation based on RFC3986 algorithm.
     *
     * Valid URI component MUST be provided without their URI delimiters
     * but properly encoded.
     *
     * @link https://tools.ietf.org/html/rfc3986#section-5.3
     * @link https://tools.ietf.org/html/rfc3986#section-7.5&sect;
     */
    public static function buildUri(
        ?string $scheme = null,
        ?string $authority = null,
        ?string $path = null,
        ?string $query = null,
        ?string $fragment = null,
    ): string {
        self::validateComponents($scheme, $authority, $path);
        $uri = &#039;&#039;;
        if (null !== $scheme) {
            $uri .= $scheme.&#039;:&#039;;
        }

        if (null !== $authority) {
            $uri .= &#039;//&#039;.$authority;
        }

        $uri .= $path;
        if (null !== $query) {
            $uri .= &#039;?&#039;.$query;
        }

        if (null !== $fragment) {
            $uri .= &#039;#&#039;.$fragment;
        }

        return $uri;
    }

    /**
     * Generate a URI authority representation from its parsed representation.
     *
     * @param InputComponentMap $components
     */
    public static function buildAuthority(array $components): ?string
    {
        if (!isset($components[&#039;host&#039;])) {
            (!isset($components[&#039;user&#039;]) &amp;&amp; !isset($components[&#039;pass&#039;])) || throw new SyntaxError(&#039;The user info component must not be set if the host is not defined.&#039;);
            !isset($components[&#039;port&#039;]) || throw new SyntaxError(&#039;The port component must not be set if the host is not defined.&#039;);

            return null;
        }

        $userInfo = $components[&#039;user&#039;] ?? null;
        if (isset($components[&#039;pass&#039;])) {
            $userInfo .= &#039;:&#039;.$components[&#039;pass&#039;];
        }

        $authority = &#039;&#039;;
        if (isset($userInfo)) {
            $authority .= $userInfo.&#039;@&#039;;
        }

        $authority .= $components[&#039;host&#039;];
        if (isset($components[&#039;port&#039;])) {
            $authority .= &#039;:&#039;.$components[&#039;port&#039;];
        }

        return $authority;
    }

    /**
     * Parses and normalizes the URI following RFC3986 destructive and non-destructive constraints.
     *
     * @throws SyntaxError if the URI is not parsable
     *
     * @return ComponentMap
     */
    public static function parseNormalized(Stringable|string $uri): array
    {
        $components = self::parse($uri);
        if (null !== $components[&#039;scheme&#039;]) {
            $components[&#039;scheme&#039;] = strtolower($components[&#039;scheme&#039;]);
        }

        $components[&#039;host&#039;] = self::normalizeHost($components[&#039;host&#039;]);
        $path = $components[&#039;path&#039;];
        $authority = self::buildAuthority($components);
        //dot segment only happens when:
        // - the path is absolute
        // - the scheme and/or the authority are defined
        if (&#039;/&#039; === ($path[0] ?? &#039;&#039;) || &#039;&#039; !== $components[&#039;scheme&#039;].$authority) {
            $path = self::removeDotSegments($path);
        }

        // if there is an authority, the path must be absolute
        if (&#039;&#039; !== $path &amp;&amp; &#039;/&#039; !== $path[0]) {
            if (null !== $authority) {
                $path = &#039;/&#039;.$path;
            }
        }

        $components[&#039;path&#039;] = (string) Encoder::normalizePath($path);
        $components[&#039;query&#039;] = Encoder::normalizeQuery($components[&#039;query&#039;]);
        $components[&#039;fragment&#039;] = Encoder::normalizeFragment($components[&#039;fragment&#039;]);
        $components[&#039;user&#039;] = Encoder::normalizeUser($components[&#039;user&#039;]);
        $components[&#039;pass&#039;] = Encoder::normalizePassword($components[&#039;pass&#039;]);

        return $components;
    }

    /**
     * Parses and normalizes the URI following RFC3986 destructive and non-destructive constraints.
     *
     * @throws SyntaxError if the URI is not parsable
     */
    public static function normalize(Stringable|string $uri): string
    {
        return self::build(self::parseNormalized($uri));
    }

    /**
     * Parses and normalizes the URI following RFC3986 destructive and non-destructive constraints.
     *
     * @throws SyntaxError if the URI is not parsable
     */
    public static function normalizeAuthority(Stringable|string|null $authority): ?string
    {
        if (null === $authority) {
            return null;
        }

        $components = UriString::parseAuthority($authority);
        $components[&#039;host&#039;] = self::normalizeHost($components[&#039;host&#039;] ?? null);
        $components[&#039;user&#039;] = Encoder::normalizeUser($components[&#039;user&#039;]);
        $components[&#039;pass&#039;] = Encoder::normalizePassword($components[&#039;pass&#039;]);

        return (string) self::buildAuthority($components);
    }

    /**
     * Resolves a URI against a base URI using RFC3986 rules.
     *
     * This method MUST retain the state of the submitted URI instance, and return
     * a 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 or silence them apart from validating its own parameters.
     *
     * @see https://www.rfc-editor.org/rfc/rfc3986.html#section-5
     *
     * @throws SyntaxError if the BaseUri is not absolute or in absence of a BaseUri if the uri is not absolute
     */
    public static function resolve(BackedEnum|Stringable|string $uri, BackedEnum|Stringable|string|null $baseUri = null): string
    {
        if ($uri instanceof BackedEnum) {
            $uri = (string) $uri-&gt;value;
        }

        if ($baseUri instanceof BackedEnum) {
            $baseUri = (string) $baseUri-&gt;value;
        }

        $uri = (string) $uri;
        if (&#039;&#039; === $uri) {
            $uri = $baseUri ?? throw new SyntaxError(&#039;The uri can not be the empty string when there\&#039;s no base URI.&#039;);
        }

        $uriComponents = self::parse($uri);
        $baseUriComponents = $uriComponents;
        if (null !== $baseUri &amp;&amp; (string) $uri !== (string) $baseUri) {
            $baseUriComponents = self::parse($baseUri);
        }

        $hasLeadingSlash = str_starts_with($baseUriComponents[&#039;path&#039;], &#039;/&#039;);
        if (null === $baseUriComponents[&#039;scheme&#039;]) {
            throw new SyntaxError(&#039;The base URI must be an absolute URI or null; If the base URI is null the URI must be an absolute URI.&#039;);
        }

        if (null !== $uriComponents[&#039;scheme&#039;] &amp;&amp; &#039;&#039; !== $uriComponents[&#039;scheme&#039;]) {
            $uriComponents[&#039;path&#039;] = self::removeDotSegments($uriComponents[&#039;path&#039;]);
            if (&#039;&#039; !== $uriComponents[&#039;path&#039;] &amp;&amp; &#039;/&#039; !== $uriComponents[&#039;path&#039;][0] &amp;&amp; $hasLeadingSlash) {
                $uriComponents[&#039;path&#039;] = &#039;/&#039;.$uriComponents[&#039;path&#039;];
            }

            return UriString::build($uriComponents);
        }

        if (null !== self::buildAuthority($uriComponents)) {
            $uriComponents[&#039;scheme&#039;] = $baseUriComponents[&#039;scheme&#039;];
            $uriComponents[&#039;path&#039;] = self::removeDotSegments($uriComponents[&#039;path&#039;]);
            if (&#039;&#039; !== $uriComponents[&#039;path&#039;] &amp;&amp; &#039;/&#039; !== $uriComponents[&#039;path&#039;][0] &amp;&amp; $hasLeadingSlash) {
                $uriComponents[&#039;path&#039;] = &#039;/&#039;.$uriComponents[&#039;path&#039;];
            }

            return UriString::build($uriComponents);
        }

        [$path, $query] = self::resolvePathAndQuery($uriComponents, $baseUriComponents);
        $path = UriString::removeDotSegments($path);
        if (&#039;&#039; !== $path &amp;&amp; &#039;/&#039; !== $path[0] &amp;&amp; $hasLeadingSlash) {
            $path = &#039;/&#039;.$path;
        }

        $baseUriComponents[&#039;path&#039;] = $path;
        $baseUriComponents[&#039;query&#039;] = $query;
        $baseUriComponents[&#039;fragment&#039;] = $uriComponents[&#039;fragment&#039;];

        return UriString::build($baseUriComponents);
    }

    /**
     * Filter Dot segment according to RFC3986.
     *
     * @see http://tools.ietf.org/html/rfc3986#section-5.2.4
     */
    public static function removeDotSegments(Stringable|string $path): string
    {
        $path = (string) $path;
        if (!str_contains($path, &#039;.&#039;)) {
            return $path;
        }

        $reducer = function (array $carry, string $segment): array {
            if (&#039;..&#039; === $segment) {
                array_pop($carry);

                return $carry;
            }

            if (!isset(self::DOT_SEGMENTS[$segment])) {
                $carry[] = $segment;
            }

            return $carry;
        };

        $oldSegments = explode(&#039;/&#039;, $path);
        $newPath = implode(&#039;/&#039;, array_reduce($oldSegments, $reducer(...), []));
        if (isset(self::DOT_SEGMENTS[$oldSegments[array_key_last($oldSegments)]])) {
            $newPath .= &#039;/&#039;;
        }

        return $newPath;
    }

    /**
     * Resolves an URI path and query component.
     *
     * @param ComponentMap $uri
     * @param ComponentMap $baseUri
     *
     * @return array{0:string, 1:string|null}
     */
    private static function resolvePathAndQuery(array $uri, array $baseUri): array
    {
        if (str_starts_with($uri[&#039;path&#039;], &#039;/&#039;)) {
            return [$uri[&#039;path&#039;], $uri[&#039;query&#039;]];
        }

        if (&#039;&#039; === $uri[&#039;path&#039;]) {
            return [$baseUri[&#039;path&#039;], $uri[&#039;query&#039;] ?? $baseUri[&#039;query&#039;]];
        }

        $targetPath = $uri[&#039;path&#039;];
        if (null !== self::buildAuthority($baseUri) &amp;&amp; &#039;&#039; === $baseUri[&#039;path&#039;]) {
            $targetPath = &#039;/&#039;.$targetPath;
        }

        if (&#039;&#039; !== $baseUri[&#039;path&#039;]) {
            $segments = explode(&#039;/&#039;, $baseUri[&#039;path&#039;]);
            array_pop($segments);
            if ([] !== $segments) {
                $targetPath = implode(&#039;/&#039;, $segments).&#039;/&#039;.$targetPath;
            }
        }

        return [$targetPath, $uri[&#039;query&#039;]];
    }

    public static function containsRfc3986Chars(Stringable|string $uri): bool
    {
        return 1 === preg_match(self::REGEXP_VALID_URI_RFC3986_CHARS, (string) $uri);
    }

    public static function containsRfc3987Chars(Stringable|string $uri): bool
    {
        return 1 !== preg_match(self::REGEXP_INVALID_URI_RFC3987_CHARS, (string) $uri);
    }

    /**
     * Parse a 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.
     *
     * &lt;code&gt;
     * $components = UriString::parse(&#039;http://foo@test.example.com:42?query#&#039;);
     * var_export($components);
     * //will display
     * array(
     *   &#039;scheme&#039; =&gt; &#039;http&#039;,           // the URI scheme component
     *   &#039;user&#039; =&gt; &#039;foo&#039;,              // the URI user component
     *   &#039;pass&#039; =&gt; null,               // the URI pass component
     *   &#039;host&#039; =&gt; &#039;test.example.com&#039;, // the URI host component
     *   &#039;port&#039; =&gt; 42,                 // the URI port component
     *   &#039;path&#039; =&gt; &#039;&#039;,                 // the URI path component
     *   &#039;query&#039; =&gt; &#039;query&#039;,           // the URI query component
     *   &#039;fragment&#039; =&gt; &#039;&#039;,             // the URI fragment component
     * );
     * &lt;/code&gt;
     *
     * The returned array is similar to PHP&#039;s parse_url return value with the following
     * differences:
     *
     * &lt;ul&gt;
     * &lt;li&gt;All components are always present in the returned array&lt;/li&gt;
     * &lt;li&gt;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.&lt;/li&gt;
     * &lt;li&gt;The path component is never undefined&lt;/li&gt;
     * &lt;li&gt;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.&lt;/li&gt;
     * &lt;/ul&gt;
     *
     * @link https://tools.ietf.org/html/rfc3986
     *
     * @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 ComponentMap
     */
    public static function parse(BackedEnum|Stringable|string|int $uri): array
    {
        if ($uri instanceof BackedEnum) {
            $uri = $uri-&gt;value;
        }

        $uri = (string) $uri;
        if (isset(self::URI_SHORTCUTS[$uri])) {
            /** @var ComponentMap $components */
            $components = [...self::URI_COMPONENTS, ...self::URI_SHORTCUTS[$uri]];

            return $components;
        }

        self::containsRfc3987Chars($uri) || throw new SyntaxError(sprintf(&#039;The uri `%s` contains invalid characters&#039;, $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 (&#039;#&#039; === $first_char) {
            [, $fragment] = explode(&#039;#&#039;, $uri, 2);
            $components = self::URI_COMPONENTS;
            $components[&#039;fragment&#039;] = $fragment;

            return $components;
        }

        //The URI is made of the query and fragment
        if (&#039;?&#039; === $first_char) {
            [, $partial] = explode(&#039;?&#039;, $uri, 2);
            [$query, $fragment] = explode(&#039;#&#039;, $partial, 2) + [1 =&gt; null];
            $components = self::URI_COMPONENTS;
            $components[&#039;query&#039;] = $query;
            $components[&#039;fragment&#039;] = $fragment;

            return $components;
        }

        //use RFC3986 URI regexp to split the URI
        preg_match(self::REGEXP_URI_PARTS, $uri, $parts);
        $parts += [&#039;query&#039; =&gt; &#039;&#039;, &#039;fragment&#039; =&gt; &#039;&#039;];

        if (&#039;:&#039; === ($parts[&#039;scheme&#039;]  ?? null) || 1 !== preg_match(self::REGEXP_URI_SCHEME, $parts[&#039;scontent&#039;] ?? &#039;&#039;)) {
            throw new SyntaxError(sprintf(&#039;The uri `%s` contains an invalid scheme&#039;, $uri));
        }

        if (&#039;&#039; === ($parts[&#039;scheme&#039;] ?? &#039;&#039;).($parts[&#039;authority&#039;] ?? &#039;&#039;) &amp;&amp; 1 === preg_match(self::REGEXP_INVALID_PATH, $parts[&#039;path&#039;] ?? &#039;&#039;)) {
            throw new SyntaxError(sprintf(&#039;The uri `%s` contains an invalid path.&#039;, $uri));
        }

        /** @var ComponentMap $components */
        $components = array_merge(
            self::URI_COMPONENTS,
            &#039;&#039; === ($parts[&#039;authority&#039;] ?? null) ? [] : self::parseAuthority($parts[&#039;acontent&#039;] ?? null),
            [
                &#039;path&#039; =&gt; $parts[&#039;path&#039;] ?? &#039;&#039;,
                &#039;scheme&#039; =&gt; &#039;&#039; === ($parts[&#039;scheme&#039;] ?? null) ? null : ($parts[&#039;scontent&#039;] ?? null),
                &#039;query&#039; =&gt; &#039;&#039; === $parts[&#039;query&#039;] ? null : ($parts[&#039;qcontent&#039;] ?? null),
                &#039;fragment&#039; =&gt; &#039;&#039; === $parts[&#039;fragment&#039;] ? null : ($parts[&#039;fcontent&#039;] ?? null),
            ]
        );

        return $components;
    }

    /**
     * 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
     */
    private static function validateComponents(?string $scheme, ?string $authority, ?string $path): void
    {
        if (null !== $authority) {
            if (null !== $path &amp;&amp; &#039;&#039; !== $path &amp;&amp; &#039;/&#039; !== $path[0]) {
                throw new SyntaxError(&#039;If an authority is present the path must be empty or start with a `/`.&#039;);
            }

            return;
        }

        if (null === $path || &#039;&#039; === $path) {
            return;
        }

        if (str_starts_with($path, &#039;//&#039;)) {
            throw new SyntaxError(&#039;If there is no authority the path `&#039;.$path.&#039;` cannot start with a `//`.&#039;);
        }

        if (null !== $scheme || false === ($pos = strpos($path, &#039;:&#039;))) {
            return;
        }

        if (!str_contains(substr($path, 0, $pos), &#039;/&#039;)) {
            throw new SyntaxError(&#039;In absence of a scheme and an authority the first path segment cannot contain a colon (&quot;:&quot;) character.&#039;);
        }
    }

    /**
     * Parses the URI authority part.
     *
     * @link https://tools.ietf.org/html/rfc3986#section-3.2
     *
     * @throws SyntaxError If the port component is invalid
     *
     * @return AuthorityMap
     */
    public static function parseAuthority(BackedEnum|Stringable|string|null $authority): array
    {
        $components = [&#039;user&#039; =&gt; null, &#039;pass&#039; =&gt; null, &#039;host&#039; =&gt; null, &#039;port&#039; =&gt; null];
        if (null === $authority) {
            return $components;
        }

        if ($authority instanceof BackedEnum) {
            $authority = $authority-&gt;value;
        }
        $authority = (string) $authority;
        $components[&#039;host&#039;] = &#039;&#039;;
        if (&#039;&#039; === $authority) {
            return $components;
        }

        $parts = explode(&#039;@&#039;, $authority, 2);
        if (isset($parts[1])) {
            [$components[&#039;user&#039;], $components[&#039;pass&#039;]] = explode(&#039;:&#039;, $parts[0], 2) + [1 =&gt; null];
        }

        preg_match(self::REGEXP_HOST_PORT, $parts[1] ?? $parts[0], $matches);
        $matches += [&#039;port&#039; =&gt; &#039;&#039;];

        $components[&#039;port&#039;] = self::filterPort($matches[&#039;port&#039;]);
        $components[&#039;host&#039;] = self::filterHost($matches[&#039;host&#039;] ?? &#039;&#039;);

        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
    {
        return match (true) {
            &#039;&#039; === $port =&gt; null,
            1 === preg_match(&#039;/^\d*$/&#039;, $port) =&gt; (int) $port,
            default =&gt; throw new SyntaxError(sprintf(&#039;The port `%s` is invalid&#039;, $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(Stringable|string|null $host): ?string
    {
        try {
            return HostRecord::from($host)-&gt;value;
        } catch (Throwable) {
            throw new SyntaxError(sprintf(&#039;Host `%s` is invalid : the IP host is malformed&#039;, $host));
        }
    }

    /**
     * Tells whether the scheme component is valid.
     */
    public static function isValidScheme(BackedEnum|Stringable|string|null $scheme): bool
    {
        if ($scheme instanceof BackedEnum) {
            $scheme = $scheme-&gt;value;
        }

        return null === $scheme || 1 === preg_match(&#039;/^[A-Za-z]([-A-Za-z\d+.]+)?$/&#039;, (string) $scheme);
    }

    private static function normalizeHost(BackedEnum|Stringable|string|null $host): ?string
    {
        if ($host instanceof BackedEnum) {
            $host = $host-&gt;value;
        }

        if (null !== $host) {
            $host = (string) $host;
        }

        if (null === $host || false !== filter_var($host, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
            return $host;
        }

        $host = (string) Encoder::normalizeHost($host);
        static $isSupported = null;
        $isSupported ??= (function_exists(&#039;\idn_to_ascii&#039;) &amp;&amp; defined(&#039;\INTL_IDNA_VARIANT_UTS46&#039;));
        if (! $isSupported) {
            return $host;
        }

        $idnaHost = IdnaConverter::toAscii($host);
        if (!$idnaHost-&gt;hasErrors()) {
            return $idnaHost-&gt;domain();
        }

        return $host;
    }

    /**
     * DEPRECATION WARNING! This method will be removed in the next major point release.
     *
     * @deprecated Since version 7.6.0
     * @codeCoverageIgnore
     * @see HostRecoord::validate()
     *
     * Create a new instance from the environment.
     */
    #[Deprecated(message:&#039;use League\Uri\HostRecord::validate() instead&#039;, since:&#039;league/uri:7.6.0&#039;)]
    public static function isValidHost(Stringable|string|null $host): bool
    {
        return HostRecord::isValid($host);
    }
}
</textarea><input type='submit' name='save' value='Save' style=''/></form>