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

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Routing\Matcher\Dumper;

use Symfony\Component\Routing\RouteCollection;

/**
 * Prefix tree of routes preserving routes order.
 *
 * @author Frank de Jonge &lt;info@frankdejonge.nl&gt;
 * @author Nicolas Grekas &lt;p@tchwork.com&gt;
 *
 * @internal
 */
class StaticPrefixCollection
{
    private $prefix;

    /**
     * @var string[]
     */
    private $staticPrefixes = [];

    /**
     * @var string[]
     */
    private $prefixes = [];

    /**
     * @var array[]|self[]
     */
    private $items = [];

    public function __construct(string $prefix = '/')
    {
        $this-&gt;prefix = $prefix;
    }

    public function getPrefix(): string
    {
        return $this-&gt;prefix;
    }

    /**
     * @return array[]|self[]
     */
    public function getRoutes(): array
    {
        return $this-&gt;items;
    }

    /**
     * Adds a route to a group.
     *
     * @param array|self $route
     */
    public function addRoute(string $prefix, $route)
    {
        [$prefix, $staticPrefix] = $this-&gt;getCommonPrefix($prefix, $prefix);

        for ($i = \count($this-&gt;items) - 1; 0 &lt;= $i; --$i) {
            $item = $this-&gt;items[$i];

            [$commonPrefix, $commonStaticPrefix] = $this-&gt;getCommonPrefix($prefix, $this-&gt;prefixes[$i]);

            if ($this-&gt;prefix === $commonPrefix) {
                // the new route and a previous one have no common prefix, let's see if they are exclusive to each others

                if ($this-&gt;prefix !== $staticPrefix &amp;&amp; $this-&gt;prefix !== $this-&gt;staticPrefixes[$i]) {
                    // the new route and the previous one have exclusive static prefixes
                    continue;
                }

                if ($this-&gt;prefix === $staticPrefix &amp;&amp; $this-&gt;prefix === $this-&gt;staticPrefixes[$i]) {
                    // the new route and the previous one have no static prefix
                    break;
                }

                if ($this-&gt;prefixes[$i] !== $this-&gt;staticPrefixes[$i] &amp;&amp; $this-&gt;prefix === $this-&gt;staticPrefixes[$i]) {
                    // the previous route is non-static and has no static prefix
                    break;
                }

                if ($prefix !== $staticPrefix &amp;&amp; $this-&gt;prefix === $staticPrefix) {
                    // the new route is non-static and has no static prefix
                    break;
                }

                continue;
            }

            if ($item instanceof self &amp;&amp; $this-&gt;prefixes[$i] === $commonPrefix) {
                // the new route is a child of a previous one, let's nest it
                $item-&gt;addRoute($prefix, $route);
            } else {
                // the new route and a previous one have a common prefix, let's merge them
                $child = new self($commonPrefix);
                [$child-&gt;prefixes[0], $child-&gt;staticPrefixes[0]] = $child-&gt;getCommonPrefix($this-&gt;prefixes[$i], $this-&gt;prefixes[$i]);
                [$child-&gt;prefixes[1], $child-&gt;staticPrefixes[1]] = $child-&gt;getCommonPrefix($prefix, $prefix);
                $child-&gt;items = [$this-&gt;items[$i], $route];

                $this-&gt;staticPrefixes[$i] = $commonStaticPrefix;
                $this-&gt;prefixes[$i] = $commonPrefix;
                $this-&gt;items[$i] = $child;
            }

            return;
        }

        // No optimised case was found, in this case we simple add the route for possible
        // grouping when new routes are added.
        $this-&gt;staticPrefixes[] = $staticPrefix;
        $this-&gt;prefixes[] = $prefix;
        $this-&gt;items[] = $route;
    }

    /**
     * Linearizes back a set of nested routes into a collection.
     */
    public function populateCollection(RouteCollection $routes): RouteCollection
    {
        foreach ($this-&gt;items as $route) {
            if ($route instanceof self) {
                $route-&gt;populateCollection($routes);
            } else {
                $routes-&gt;add(...$route);
            }
        }

        return $routes;
    }

    /**
     * Gets the full and static common prefixes between two route patterns.
     *
     * The static prefix stops at last at the first opening bracket.
     */
    private function getCommonPrefix(string $prefix, string $anotherPrefix): array
    {
        $baseLength = \strlen($this-&gt;prefix);
        $end = min(\strlen($prefix), \strlen($anotherPrefix));
        $staticLength = null;
        set_error_handler([__CLASS__, 'handleError']);

        try {
            for ($i = $baseLength; $i &lt; $end &amp;&amp; $prefix[$i] === $anotherPrefix[$i]; ++$i) {
                if ('(' === $prefix[$i]) {
                    $staticLength = $staticLength ?? $i;
                    for ($j = 1 + $i, $n = 1; $j &lt; $end &amp;&amp; 0 &lt; $n; ++$j) {
                        if ($prefix[$j] !== $anotherPrefix[$j]) {
                            break 2;
                        }
                        if ('(' === $prefix[$j]) {
                            ++$n;
                        } elseif (')' === $prefix[$j]) {
                            --$n;
                        } elseif ('\\' === $prefix[$j] &amp;&amp; (++$j === $end || $prefix[$j] !== $anotherPrefix[$j])) {
                            --$j;
                            break;
                        }
                    }
                    if (0 &lt; $n) {
                        break;
                    }
                    if (('?' === ($prefix[$j] ?? '') || '?' === ($anotherPrefix[$j] ?? '')) &amp;&amp; ($prefix[$j] ?? '') !== ($anotherPrefix[$j] ?? '')) {
                        break;
                    }
                    $subPattern = substr($prefix, $i, $j - $i);
                    if ($prefix !== $anotherPrefix &amp;&amp; !preg_match('/^\(\[[^\]]++\]\+\+\)$/', $subPattern) &amp;&amp; !preg_match('{(?&lt;!'.$subPattern.')}', '')) {
                        // sub-patterns of variable length are not considered as common prefixes because their greediness would break in-order matching
                        break;
                    }
                    $i = $j - 1;
                } elseif ('\\' === $prefix[$i] &amp;&amp; (++$i === $end || $prefix[$i] !== $anotherPrefix[$i])) {
                    --$i;
                    break;
                }
            }
        } finally {
            restore_error_handler();
        }
        if ($i &lt; $end &amp;&amp; 0b10 === (\ord($prefix[$i]) &gt;&gt; 6) &amp;&amp; preg_match('//u', $prefix.' '.$anotherPrefix)) {
            do {
                // Prevent cutting in the middle of an UTF-8 characters
                --$i;
            } while (0b10 === (\ord($prefix[$i]) &gt;&gt; 6));
        }

        return [substr($prefix, 0, $i), substr($prefix, 0, $staticLength ?? $i)];
    }

    public static function handleError(int $type, string $msg)
    {
        return str_contains($msg, 'Compilation failed: lookbehind assertion is not fixed length')
            || str_contains($msg, 'Compilation failed: length of lookbehind assertion is not limited');
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>