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

namespace Illuminate\View\Compilers;

use Illuminate\Container\Container;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Contracts\View\Factory;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Str;
use Illuminate\View\AnonymousComponent;
use Illuminate\View\DynamicComponent;
use Illuminate\View\ViewFinderInterface;
use InvalidArgumentException;
use ReflectionClass;

/**
 * @author Spatie bvba &lt;info@spatie.be&gt;
 * @author Taylor Otwell &lt;taylor@laravel.com&gt;
 */
class ComponentTagCompiler
{
    /**
     * The Blade compiler instance.
     *
     * @var \Illuminate\View\Compilers\BladeCompiler
     */
    protected $blade;

    /**
     * The component class aliases.
     *
     * @var array
     */
    protected $aliases = [];

    /**
     * The component class namespaces.
     *
     * @var array
     */
    protected $namespaces = [];

    /**
     * The &quot;bind:&quot; attributes that have been compiled for the current component.
     *
     * @var array
     */
    protected $boundAttributes = [];

    /**
     * Create a new component tag compiler.
     *
     * @param  array  $aliases
     * @param  array  $namespaces
     * @param  \Illuminate\View\Compilers\BladeCompiler|null  $blade
     * @return void
     */
    public function __construct(array $aliases = [], array $namespaces = [], ?BladeCompiler $blade = null)
    {
        $this-&gt;aliases = $aliases;
        $this-&gt;namespaces = $namespaces;

        $this-&gt;blade = $blade ?: new BladeCompiler(new Filesystem, sys_get_temp_dir());
    }

    /**
     * Compile the component and slot tags within the given string.
     *
     * @param  string  $value
     * @return string
     */
    public function compile(string $value)
    {
        $value = $this-&gt;compileSlots($value);

        return $this-&gt;compileTags($value);
    }

    /**
     * Compile the tags within the given string.
     *
     * @param  string  $value
     * @return string
     *
     * @throws \InvalidArgumentException
     */
    public function compileTags(string $value)
    {
        $value = $this-&gt;compileSelfClosingTags($value);
        $value = $this-&gt;compileOpeningTags($value);
        $value = $this-&gt;compileClosingTags($value);

        return $value;
    }

    /**
     * Compile the opening tags within the given string.
     *
     * @param  string  $value
     * @return string
     *
     * @throws \InvalidArgumentException
     */
    protected function compileOpeningTags(string $value)
    {
        $pattern = &quot;/
            &lt;
                \s*
                x[-\:]([\w\-\:\.]*)
                (?&lt;attributes&gt;
                    (?:
                        \s+
                        (?:
                            (?:
                                \{\{\s*\\\$attributes(?:[^}]+?)?\s*\}\}
                            )
                            |
                            (?:
                                [\w\-:.@]+
                                (
                                    =
                                    (?:
                                        \\\&quot;[^\\\&quot;]*\\\&quot;
                                        |
                                        \'[^\']*\'
                                        |
                                        [^\'\\\&quot;=&lt;&gt;]+
                                    )
                                )?
                            )
                        )
                    )*
                    \s*
                )
                (?&lt;![\/=\-])
            &gt;
        /x&quot;;

        return preg_replace_callback($pattern, function (array $matches) {
            $this-&gt;boundAttributes = [];

            $attributes = $this-&gt;getAttributesFromAttributeString($matches['attributes']);

            return $this-&gt;componentString($matches[1], $attributes);
        }, $value);
    }

    /**
     * Compile the self-closing tags within the given string.
     *
     * @param  string  $value
     * @return string
     *
     * @throws \InvalidArgumentException
     */
    protected function compileSelfClosingTags(string $value)
    {
        $pattern = &quot;/
            &lt;
                \s*
                x[-\:]([\w\-\:\.]*)
                \s*
                (?&lt;attributes&gt;
                    (?:
                        \s+
                        (?:
                            (?:
                                \{\{\s*\\\$attributes(?:[^}]+?)?\s*\}\}
                            )
                            |
                            (?:
                                [\w\-:.@]+
                                (
                                    =
                                    (?:
                                        \\\&quot;[^\\\&quot;]*\\\&quot;
                                        |
                                        \'[^\']*\'
                                        |
                                        [^\'\\\&quot;=&lt;&gt;]+
                                    )
                                )?
                            )
                        )
                    )*
                    \s*
                )
            \/&gt;
        /x&quot;;

        return preg_replace_callback($pattern, function (array $matches) {
            $this-&gt;boundAttributes = [];

            $attributes = $this-&gt;getAttributesFromAttributeString($matches['attributes']);

            return $this-&gt;componentString($matches[1], $attributes).&quot;\n@endComponentClass##END-COMPONENT-CLASS##&quot;;
        }, $value);
    }

    /**
     * Compile the Blade component string for the given component and attributes.
     *
     * @param  string  $component
     * @param  array  $attributes
     * @return string
     *
     * @throws \InvalidArgumentException
     */
    protected function componentString(string $component, array $attributes)
    {
        $class = $this-&gt;componentClass($component);

        [$data, $attributes] = $this-&gt;partitionDataAndAttributes($class, $attributes);

        $data = $data-&gt;mapWithKeys(function ($value, $key) {
            return [Str::camel($key) =&gt; $value];
        });

        // If the component doesn't exists as a class we'll assume it's a class-less
        // component and pass the component as a view parameter to the data so it
        // can be accessed within the component and we can render out the view.
        if (! class_exists($class)) {
            $parameters = [
                'view' =&gt; &quot;'$class'&quot;,
                'data' =&gt; '['.$this-&gt;attributesToString($data-&gt;all(), $escapeBound = false).']',
            ];

            $class = AnonymousComponent::class;
        } else {
            $parameters = $data-&gt;all();
        }

        return &quot;##BEGIN-COMPONENT-CLASS##@component('{$class}', '{$component}', [&quot;.$this-&gt;attributesToString($parameters, $escapeBound = false).'])
&lt;?php $component-&gt;withAttributes(['.$this-&gt;attributesToString($attributes-&gt;all(), $escapeAttributes = $class !== DynamicComponent::class).']); ?&gt;';
    }

    /**
     * Get the component class for a given component alias.
     *
     * @param  string  $component
     * @return string
     *
     * @throws \InvalidArgumentException
     */
    public function componentClass(string $component)
    {
        $viewFactory = Container::getInstance()-&gt;make(Factory::class);

        if (isset($this-&gt;aliases[$component])) {
            if (class_exists($alias = $this-&gt;aliases[$component])) {
                return $alias;
            }

            if ($viewFactory-&gt;exists($alias)) {
                return $alias;
            }

            throw new InvalidArgumentException(
                &quot;Unable to locate class or view [{$alias}] for component [{$component}].&quot;
            );
        }

        if ($class = $this-&gt;findClassByComponent($component)) {
            return $class;
        }

        if (class_exists($class = $this-&gt;guessClassName($component))) {
            return $class;
        }

        if ($viewFactory-&gt;exists($view = $this-&gt;guessViewName($component))) {
            return $view;
        }

        if ($viewFactory-&gt;exists($view = $this-&gt;guessViewName($component).'.index')) {
            return $view;
        }

        throw new InvalidArgumentException(
            &quot;Unable to locate a class or view for component [{$component}].&quot;
        );
    }

    /**
     * Find the class for the given component using the registered namespaces.
     *
     * @param  string  $component
     * @return string|null
     */
    public function findClassByComponent(string $component)
    {
        $segments = explode('::', $component);

        $prefix = $segments[0];

        if (! isset($this-&gt;namespaces[$prefix]) || ! isset($segments[1])) {
            return;
        }

        if (class_exists($class = $this-&gt;namespaces[$prefix].'\\'.$this-&gt;formatClassName($segments[1]))) {
            return $class;
        }
    }

    /**
     * Guess the class name for the given component.
     *
     * @param  string  $component
     * @return string
     */
    public function guessClassName(string $component)
    {
        $namespace = Container::getInstance()
                    -&gt;make(Application::class)
                    -&gt;getNamespace();

        $class = $this-&gt;formatClassName($component);

        return $namespace.'View\\Components\\'.$class;
    }

    /**
     * Format the class name for the given component.
     *
     * @param  string  $component
     * @return string
     */
    public function formatClassName(string $component)
    {
        $componentPieces = array_map(function ($componentPiece) {
            return ucfirst(Str::camel($componentPiece));
        }, explode('.', $component));

        return implode('\\', $componentPieces);
    }

    /**
     * Guess the view name for the given component.
     *
     * @param  string  $name
     * @return string
     */
    public function guessViewName($name)
    {
        $prefix = 'components.';

        $delimiter = ViewFinderInterface::HINT_PATH_DELIMITER;

        if (Str::contains($name, $delimiter)) {
            return Str::replaceFirst($delimiter, $delimiter.$prefix, $name);
        }

        return $prefix.$name;
    }

    /**
     * Partition the data and extra attributes from the given array of attributes.
     *
     * @param  string  $class
     * @param  array  $attributes
     * @return array
     */
    public function partitionDataAndAttributes($class, array $attributes)
    {
        // If the class doesn't exists, we'll assume it's a class-less component and
        // return all of the attributes as both data and attributes since we have
        // now way to partition them. The user can exclude attributes manually.
        if (! class_exists($class)) {
            return [collect($attributes), collect($attributes)];
        }

        $constructor = (new ReflectionClass($class))-&gt;getConstructor();

        $parameterNames = $constructor
                    ? collect($constructor-&gt;getParameters())-&gt;map-&gt;getName()-&gt;all()
                    : [];

        return collect($attributes)-&gt;partition(function ($value, $key) use ($parameterNames) {
            return in_array(Str::camel($key), $parameterNames);
        })-&gt;all();
    }

    /**
     * Compile the closing tags within the given string.
     *
     * @param  string  $value
     * @return string
     */
    protected function compileClosingTags(string $value)
    {
        return preg_replace(&quot;/&lt;\/\s*x[-\:][\w\-\:\.]*\s*&gt;/&quot;, ' @endComponentClass##END-COMPONENT-CLASS##', $value);
    }

    /**
     * Compile the slot tags within the given string.
     *
     * @param  string  $value
     * @return string
     */
    public function compileSlots(string $value)
    {
        $pattern = &quot;/
            &lt;
                \s*
                x[\-\:]slot
                \s+
                (:?)name=(?&lt;name&gt;(\&quot;[^\&quot;]+\&quot;|\\\'[^\\\']+\\\'|[^\s&gt;]+))
                (?&lt;attributes&gt;
                    (?:
                        \s+
                        (?:
                            (?:
                                \{\{\s*\\\$attributes(?:[^}]+?)?\s*\}\}
                            )
                            |
                            (?:
                                [\w\-:.@]+
                                (
                                    =
                                    (?:
                                        \\\&quot;[^\\\&quot;]*\\\&quot;
                                        |
                                        \'[^\']*\'
                                        |
                                        [^\'\\\&quot;=&lt;&gt;]+
                                    )
                                )?
                            )
                        )
                    )*
                    \s*
                )
                (?&lt;![\/=\-])
            &gt;
        /x&quot;;

        $value = preg_replace_callback($pattern, function ($matches) {
            $name = $this-&gt;stripQuotes($matches['name']);

            if ($matches[1] !== ':') {
                $name = &quot;'{$name}'&quot;;
            }

            $this-&gt;boundAttributes = [];

            $attributes = $this-&gt;getAttributesFromAttributeString($matches['attributes']);

            return &quot; @slot({$name}, null, [&quot;.$this-&gt;attributesToString($attributes).']) ';
        }, $value);

        return preg_replace('/&lt;\/\s*x[\-\:]slot[^&gt;]*&gt;/', ' @endslot', $value);
    }

    /**
     * Get an array of attributes from the given attribute string.
     *
     * @param  string  $attributeString
     * @return array
     */
    protected function getAttributesFromAttributeString(string $attributeString)
    {
        $attributeString = $this-&gt;parseAttributeBag($attributeString);

        $attributeString = $this-&gt;parseBindAttributes($attributeString);

        $pattern = '/
            (?&lt;attribute&gt;[\w\-:.@]+)
            (
                =
                (?&lt;value&gt;
                    (
                        \&quot;[^\&quot;]+\&quot;
                        |
                        \\\'[^\\\']+\\\'
                        |
                        [^\s&gt;]+
                    )
                )
            )?
        /x';

        if (! preg_match_all($pattern, $attributeString, $matches, PREG_SET_ORDER)) {
            return [];
        }

        return collect($matches)-&gt;mapWithKeys(function ($match) {
            $attribute = $match['attribute'];
            $value = $match['value'] ?? null;

            if (is_null($value)) {
                $value = 'true';

                $attribute = Str::start($attribute, 'bind:');
            }

            $value = $this-&gt;stripQuotes($value);

            if (Str::startsWith($attribute, 'bind:')) {
                $attribute = Str::after($attribute, 'bind:');

                $this-&gt;boundAttributes[$attribute] = true;
            } else {
                $value = &quot;'&quot;.$this-&gt;compileAttributeEchos($value).&quot;'&quot;;
            }

            if (Str::startsWith($attribute, '::')) {
                $attribute = substr($attribute, 1);
            }

            return [$attribute =&gt; $value];
        })-&gt;toArray();
    }

    /**
     * Parse the attribute bag in a given attribute string into its fully-qualified syntax.
     *
     * @param  string  $attributeString
     * @return string
     */
    protected function parseAttributeBag(string $attributeString)
    {
        $pattern = &quot;/
            (?:^|\s+)                                        # start of the string or whitespace between attributes
            \{\{\s*(\\\$attributes(?:[^}]+?(?&lt;!\s))?)\s*\}\} # exact match of attributes variable being echoed
        /x&quot;;

        return preg_replace($pattern, ' :attributes=&quot;$1&quot;', $attributeString);
    }

    /**
     * Parse the &quot;bind&quot; attributes in a given attribute string into their fully-qualified syntax.
     *
     * @param  string  $attributeString
     * @return string
     */
    protected function parseBindAttributes(string $attributeString)
    {
        $pattern = &quot;/
            (?:^|\s+)     # start of the string or whitespace between attributes
            :(?!:)        # attribute needs to start with a single colon
            ([\w\-:.@]+)  # match the actual attribute name
            =             # only match attributes that have a value
        /xm&quot;;

        return preg_replace($pattern, ' bind:$1=', $attributeString);
    }

    /**
     * Compile any Blade echo statements that are present in the attribute string.
     *
     * These echo statements need to be converted to string concatenation statements.
     *
     * @param  string  $attributeString
     * @return string
     */
    protected function compileAttributeEchos(string $attributeString)
    {
        $value = $this-&gt;blade-&gt;compileEchos($attributeString);

        $value = $this-&gt;escapeSingleQuotesOutsideOfPhpBlocks($value);

        $value = str_replace('&lt;?php echo ', '\'.', $value);
        $value = str_replace('; ?&gt;', '.\'', $value);

        return $value;
    }

    /**
     * Escape the single quotes in the given string that are outside of PHP blocks.
     *
     * @param  string  $value
     * @return string
     */
    protected function escapeSingleQuotesOutsideOfPhpBlocks(string $value)
    {
        return collect(token_get_all($value))-&gt;map(function ($token) {
            if (! is_array($token)) {
                return $token;
            }

            return $token[0] === T_INLINE_HTML
                        ? str_replace(&quot;'&quot;, &quot;\\'&quot;, $token[1])
                        : $token[1];
        })-&gt;implode('');
    }

    /**
     * Convert an array of attributes to a string.
     *
     * @param  array  $attributes
     * @param  bool  $escapeBound
     * @return string
     */
    protected function attributesToString(array $attributes, $escapeBound = true)
    {
        return collect($attributes)
                -&gt;map(function (string $value, string $attribute) use ($escapeBound) {
                    return $escapeBound &amp;&amp; isset($this-&gt;boundAttributes[$attribute]) &amp;&amp; $value !== 'true' &amp;&amp; ! is_numeric($value)
                                ? &quot;'{$attribute}' =&gt; \Illuminate\View\Compilers\BladeCompiler::sanitizeComponentAttribute({$value})&quot;
                                : &quot;'{$attribute}' =&gt; {$value}&quot;;
                })
                -&gt;implode(',');
    }

    /**
     * Strip any quotes from the given string.
     *
     * @param  string  $value
     * @return string
     */
    public function stripQuotes(string $value)
    {
        return Str::startsWith($value, ['&quot;', '\''])
                    ? substr($value, 1, -1)
                    : $value;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>