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

namespace Illuminate\View\Compilers\Concerns;

use Illuminate\Contracts\Support\CanBeEscapedWhenCastToString;
use Illuminate\Support\Str;
use Illuminate\View\ComponentAttributeBag;

trait CompilesComponents
{
    /**
     * The component name hash stack.
     *
     * @var array
     */
    protected static $componentHashStack = [];

    /**
     * Compile the component statements into valid PHP.
     *
     * @param  string  $expression
     * @return string
     */
    protected function compileComponent($expression)
    {
        [$component, $alias, $data] = strpos($expression, ',') !== false
                    ? array_map('trim', explode(',', trim($expression, '()'), 3)) + ['', '', '']
                    : [trim($expression, '()'), '', ''];

        $component = trim($component, '\'&quot;');

        $hash = static::newComponentHash($component);

        if (Str::contains($component, ['::class', '\\'])) {
            return static::compileClassComponentOpening($component, $alias, $data, $hash);
        }

        return &quot;&lt;?php \$__env-&gt;startComponent{$expression}; ?&gt;&quot;;
    }

    /**
     * Get a new component hash for a component name.
     *
     * @param  string  $component
     * @return string
     */
    public static function newComponentHash(string $component)
    {
        static::$componentHashStack[] = $hash = sha1($component);

        return $hash;
    }

    /**
     * Compile a class component opening.
     *
     * @param  string  $component
     * @param  string  $alias
     * @param  string  $data
     * @param  string  $hash
     * @return string
     */
    public static function compileClassComponentOpening(string $component, string $alias, string $data, string $hash)
    {
        return implode(&quot;\n&quot;, [
            '&lt;?php if (isset($component)) { $__componentOriginal'.$hash.' = $component; } ?&gt;',
            '&lt;?php $component = $__env-&gt;getContainer()-&gt;make('.Str::finish($component, '::class').', '.($data ?: '[]').'); ?&gt;',
            '&lt;?php $component-&gt;withName('.$alias.'); ?&gt;',
            '&lt;?php if ($component-&gt;shouldRender()): ?&gt;',
            '&lt;?php $__env-&gt;startComponent($component-&gt;resolveView(), $component-&gt;data()); ?&gt;',
        ]);
    }

    /**
     * Compile the end-component statements into valid PHP.
     *
     * @return string
     */
    protected function compileEndComponent()
    {
        return '&lt;?php echo $__env-&gt;renderComponent(); ?&gt;';
    }

    /**
     * Compile the end-component statements into valid PHP.
     *
     * @return string
     */
    public function compileEndComponentClass()
    {
        $hash = array_pop(static::$componentHashStack);

        return $this-&gt;compileEndComponent().&quot;\n&quot;.implode(&quot;\n&quot;, [
            '&lt;?php endif; ?&gt;',
            '&lt;?php if (isset($__componentOriginal'.$hash.')): ?&gt;',
            '&lt;?php $component = $__componentOriginal'.$hash.'; ?&gt;',
            '&lt;?php unset($__componentOriginal'.$hash.'); ?&gt;',
            '&lt;?php endif; ?&gt;',
        ]);
    }

    /**
     * Compile the slot statements into valid PHP.
     *
     * @param  string  $expression
     * @return string
     */
    protected function compileSlot($expression)
    {
        return &quot;&lt;?php \$__env-&gt;slot{$expression}; ?&gt;&quot;;
    }

    /**
     * Compile the end-slot statements into valid PHP.
     *
     * @return string
     */
    protected function compileEndSlot()
    {
        return '&lt;?php $__env-&gt;endSlot(); ?&gt;';
    }

    /**
     * Compile the component-first statements into valid PHP.
     *
     * @param  string  $expression
     * @return string
     */
    protected function compileComponentFirst($expression)
    {
        return &quot;&lt;?php \$__env-&gt;startComponentFirst{$expression}; ?&gt;&quot;;
    }

    /**
     * Compile the end-component-first statements into valid PHP.
     *
     * @return string
     */
    protected function compileEndComponentFirst()
    {
        return $this-&gt;compileEndComponent();
    }

    /**
     * Compile the prop statement into valid PHP.
     *
     * @param  string  $expression
     * @return string
     */
    protected function compileProps($expression)
    {
        return &quot;&lt;?php \$attributes = \$attributes-&gt;exceptProps{$expression}; ?&gt;
&lt;?php foreach (array_filter({$expression}, 'is_string', ARRAY_FILTER_USE_KEY) as \$__key =&gt; \$__value) {
    \$\$__key = \$\$__key ?? \$__value;
} ?&gt;
&lt;?php \$__defined_vars = get_defined_vars(); ?&gt;
&lt;?php foreach (\$attributes as \$__key =&gt; \$__value) {
    if (array_key_exists(\$__key, \$__defined_vars)) unset(\$\$__key);
} ?&gt;
&lt;?php unset(\$__defined_vars); ?&gt;&quot;;
    }

    /**
     * Compile the aware statement into valid PHP.
     *
     * @param  string  $expression
     * @return string
     */
    protected function compileAware($expression)
    {
        return &quot;&lt;?php foreach ({$expression} as \$__key =&gt; \$__value) {
    \$__consumeVariable = is_string(\$__key) ? \$__key : \$__value;
    \$\$__consumeVariable = is_string(\$__key) ? \$__env-&gt;getConsumableComponentData(\$__key, \$__value) : \$__env-&gt;getConsumableComponentData(\$__value);
} ?&gt;&quot;;
    }

    /**
     * Sanitize the given component attribute value.
     *
     * @param  mixed  $value
     * @return mixed
     */
    public static function sanitizeComponentAttribute($value)
    {
        if (is_object($value) &amp;&amp; $value instanceof CanBeEscapedWhenCastToString) {
            return $value-&gt;escapeWhenCastingToString();
        }

        return is_string($value) ||
               (is_object($value) &amp;&amp; ! $value instanceof ComponentAttributeBag &amp;&amp; method_exists($value, '__toString'))
                        ? e($value)
                        : $value;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>