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

namespace Illuminate\View\Compilers;

use Illuminate\Container\Container;
use Illuminate\Contracts\Support\Htmlable;
use Illuminate\Contracts\View\Factory as ViewFactory;
use Illuminate\Contracts\View\View;
use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\ReflectsClosures;
use Illuminate\View\Component;
use InvalidArgumentException;

class BladeCompiler extends Compiler implements CompilerInterface
{
    use Concerns\CompilesAuthorizations,
        Concerns\CompilesClasses,
        Concerns\CompilesComments,
        Concerns\CompilesComponents,
        Concerns\CompilesConditionals,
        Concerns\CompilesEchos,
        Concerns\CompilesErrors,
        Concerns\CompilesHelpers,
        Concerns\CompilesIncludes,
        Concerns\CompilesInjections,
        Concerns\CompilesJson,
        Concerns\CompilesJs,
        Concerns\CompilesLayouts,
        Concerns\CompilesLoops,
        Concerns\CompilesRawPhp,
        Concerns\CompilesStacks,
        Concerns\CompilesTranslations,
        ReflectsClosures;

    /**
     * All of the registered extensions.
     *
     * @var array
     */
    protected $extensions = [];

    /**
     * All custom &quot;directive&quot; handlers.
     *
     * @var array
     */
    protected $customDirectives = [];

    /**
     * All custom &quot;condition&quot; handlers.
     *
     * @var array
     */
    protected $conditions = [];

    /**
     * All of the registered precompilers.
     *
     * @var array
     */
    protected $precompilers = [];

    /**
     * The file currently being compiled.
     *
     * @var string
     */
    protected $path;

    /**
     * All of the available compiler functions.
     *
     * @var string[]
     */
    protected $compilers = [
        // 'Comments',
        'Extensions',
        'Statements',
        'Echos',
    ];

    /**
     * Array of opening and closing tags for raw echos.
     *
     * @var string[]
     */
    protected $rawTags = ['{!!', '!!}'];

    /**
     * Array of opening and closing tags for regular echos.
     *
     * @var string[]
     */
    protected $contentTags = ['{{', '}}'];

    /**
     * Array of opening and closing tags for escaped echos.
     *
     * @var string[]
     */
    protected $escapedTags = ['{{{', '}}}'];

    /**
     * The &quot;regular&quot; / legacy echo string format.
     *
     * @var string
     */
    protected $echoFormat = 'e(%s)';

    /**
     * Array of footer lines to be added to the template.
     *
     * @var array
     */
    protected $footer = [];

    /**
     * Array to temporarily store the raw blocks found in the template.
     *
     * @var array
     */
    protected $rawBlocks = [];

    /**
     * The array of class component aliases and their class names.
     *
     * @var array
     */
    protected $classComponentAliases = [];

    /**
     * The array of class component namespaces to autoload from.
     *
     * @var array
     */
    protected $classComponentNamespaces = [];

    /**
     * Indicates if component tags should be compiled.
     *
     * @var bool
     */
    protected $compilesComponentTags = true;

    /**
     * Compile the view at the given path.
     *
     * @param  string|null  $path
     * @return void
     */
    public function compile($path = null)
    {
        if ($path) {
            $this-&gt;setPath($path);
        }

        if (! is_null($this-&gt;cachePath)) {
            $contents = $this-&gt;compileString($this-&gt;files-&gt;get($this-&gt;getPath()));

            if (! empty($this-&gt;getPath())) {
                $contents = $this-&gt;appendFilePath($contents);
            }

            $this-&gt;ensureCompiledDirectoryExists(
                $compiledPath = $this-&gt;getCompiledPath($this-&gt;getPath())
            );

            $this-&gt;files-&gt;put($compiledPath, $contents);
        }
    }

    /**
     * Append the file path to the compiled string.
     *
     * @param  string  $contents
     * @return string
     */
    protected function appendFilePath($contents)
    {
        $tokens = $this-&gt;getOpenAndClosingPhpTokens($contents);

        if ($tokens-&gt;isNotEmpty() &amp;&amp; $tokens-&gt;last() !== T_CLOSE_TAG) {
            $contents .= ' ?&gt;';
        }

        return $contents.&quot;&lt;?php /**PATH {$this-&gt;getPath()} ENDPATH**/ ?&gt;&quot;;
    }

    /**
     * Get the open and closing PHP tag tokens from the given string.
     *
     * @param  string  $contents
     * @return \Illuminate\Support\Collection
     */
    protected function getOpenAndClosingPhpTokens($contents)
    {
        return collect(token_get_all($contents))
            -&gt;pluck(0)
            -&gt;filter(function ($token) {
                return in_array($token, [T_OPEN_TAG, T_OPEN_TAG_WITH_ECHO, T_CLOSE_TAG]);
            });
    }

    /**
     * Get the path currently being compiled.
     *
     * @return string
     */
    public function getPath()
    {
        return $this-&gt;path;
    }

    /**
     * Set the path currently being compiled.
     *
     * @param  string  $path
     * @return void
     */
    public function setPath($path)
    {
        $this-&gt;path = $path;
    }

    /**
     * Compile the given Blade template contents.
     *
     * @param  string  $value
     * @return string
     */
    public function compileString($value)
    {
        [$this-&gt;footer, $result] = [[], ''];

        // First we will compile the Blade component tags. This is a precompile style
        // step which compiles the component Blade tags into @component directives
        // that may be used by Blade. Then we should call any other precompilers.
        $value = $this-&gt;compileComponentTags(
            $this-&gt;compileComments($this-&gt;storeUncompiledBlocks($value))
        );

        foreach ($this-&gt;precompilers as $precompiler) {
            $value = call_user_func($precompiler, $value);
        }

        // Here we will loop through all of the tokens returned by the Zend lexer and
        // parse each one into the corresponding valid PHP. We will then have this
        // template as the correctly rendered PHP that can be rendered natively.
        foreach (token_get_all($value) as $token) {
            $result .= is_array($token) ? $this-&gt;parseToken($token) : $token;
        }

        if (! empty($this-&gt;rawBlocks)) {
            $result = $this-&gt;restoreRawContent($result);
        }

        // If there are any footer lines that need to get added to a template we will
        // add them here at the end of the template. This gets used mainly for the
        // template inheritance via the extends keyword that should be appended.
        if (count($this-&gt;footer) &gt; 0) {
            $result = $this-&gt;addFooters($result);
        }

        if (! empty($this-&gt;echoHandlers)) {
            $result = $this-&gt;addBladeCompilerVariable($result);
        }

        return str_replace(
            ['##BEGIN-COMPONENT-CLASS##', '##END-COMPONENT-CLASS##'],
            '',
            $result);
    }

    /**
     * Evaluate and render a Blade string to HTML.
     *
     * @param  string  $string
     * @param  array  $data
     * @param  bool  $deleteCachedView
     * @return string
     */
    public static function render($string, $data = [], $deleteCachedView = false)
    {
        $component = new class($string) extends Component
        {
            protected $template;

            public function __construct($template)
            {
                $this-&gt;template = $template;
            }

            public function render()
            {
                return $this-&gt;template;
            }
        };

        $view = Container::getInstance()
                    -&gt;make(ViewFactory::class)
                    -&gt;make($component-&gt;resolveView(), $data);

        return tap($view-&gt;render(), function () use ($view, $deleteCachedView) {
            if ($deleteCachedView) {
                unlink($view-&gt;getPath());
            }
        });
    }

    /**
     * Render a component instance to HTML.
     *
     * @param  \Illuminate\View\Component  $component
     * @return string
     */
    public static function renderComponent(Component $component)
    {
        $data = $component-&gt;data();

        $view = value($component-&gt;resolveView(), $data);

        if ($view instanceof View) {
            return $view-&gt;with($data)-&gt;render();
        } elseif ($view instanceof Htmlable) {
            return $view-&gt;toHtml();
        } else {
            return Container::getInstance()
                -&gt;make(ViewFactory::class)
                -&gt;make($view, $data)
                -&gt;render();
        }
    }

    /**
     * Store the blocks that do not receive compilation.
     *
     * @param  string  $value
     * @return string
     */
    protected function storeUncompiledBlocks($value)
    {
        if (strpos($value, '@verbatim') !== false) {
            $value = $this-&gt;storeVerbatimBlocks($value);
        }

        if (strpos($value, '@php') !== false) {
            $value = $this-&gt;storePhpBlocks($value);
        }

        return $value;
    }

    /**
     * Store the verbatim blocks and replace them with a temporary placeholder.
     *
     * @param  string  $value
     * @return string
     */
    protected function storeVerbatimBlocks($value)
    {
        return preg_replace_callback('/(?&lt;!@)@verbatim(.*?)@endverbatim/s', function ($matches) {
            return $this-&gt;storeRawBlock($matches[1]);
        }, $value);
    }

    /**
     * Store the PHP blocks and replace them with a temporary placeholder.
     *
     * @param  string  $value
     * @return string
     */
    protected function storePhpBlocks($value)
    {
        return preg_replace_callback('/(?&lt;!@)@php(.*?)@endphp/s', function ($matches) {
            return $this-&gt;storeRawBlock(&quot;&lt;?php{$matches[1]}?&gt;&quot;);
        }, $value);
    }

    /**
     * Store a raw block and return a unique raw placeholder.
     *
     * @param  string  $value
     * @return string
     */
    protected function storeRawBlock($value)
    {
        return $this-&gt;getRawPlaceholder(
            array_push($this-&gt;rawBlocks, $value) - 1
        );
    }

    /**
     * Compile the component tags.
     *
     * @param  string  $value
     * @return string
     */
    protected function compileComponentTags($value)
    {
        if (! $this-&gt;compilesComponentTags) {
            return $value;
        }

        return (new ComponentTagCompiler(
            $this-&gt;classComponentAliases, $this-&gt;classComponentNamespaces, $this
        ))-&gt;compile($value);
    }

    /**
     * Replace the raw placeholders with the original code stored in the raw blocks.
     *
     * @param  string  $result
     * @return string
     */
    protected function restoreRawContent($result)
    {
        $result = preg_replace_callback('/'.$this-&gt;getRawPlaceholder('(\d+)').'/', function ($matches) {
            return $this-&gt;rawBlocks[$matches[1]];
        }, $result);

        $this-&gt;rawBlocks = [];

        return $result;
    }

    /**
     * Get a placeholder to temporarily mark the position of raw blocks.
     *
     * @param  int|string  $replace
     * @return string
     */
    protected function getRawPlaceholder($replace)
    {
        return str_replace('#', $replace, '@__raw_block_#__@');
    }

    /**
     * Add the stored footers onto the given content.
     *
     * @param  string  $result
     * @return string
     */
    protected function addFooters($result)
    {
        return ltrim($result, &quot;\n&quot;)
                .&quot;\n&quot;.implode(&quot;\n&quot;, array_reverse($this-&gt;footer));
    }

    /**
     * Parse the tokens from the template.
     *
     * @param  array  $token
     * @return string
     */
    protected function parseToken($token)
    {
        [$id, $content] = $token;

        if ($id == T_INLINE_HTML) {
            foreach ($this-&gt;compilers as $type) {
                $content = $this-&gt;{&quot;compile{$type}&quot;}($content);
            }
        }

        return $content;
    }

    /**
     * Execute the user defined extensions.
     *
     * @param  string  $value
     * @return string
     */
    protected function compileExtensions($value)
    {
        foreach ($this-&gt;extensions as $compiler) {
            $value = $compiler($value, $this);
        }

        return $value;
    }

    /**
     * Compile Blade statements that start with &quot;@&quot;.
     *
     * @param  string  $value
     * @return string
     */
    protected function compileStatements($value)
    {
        return preg_replace_callback(
            '/\B@(@?\w+(?:::\w+)?)([ \t]*)(\( ( (?&gt;[^()]+) | (?3) )* \))?/x', function ($match) {
                return $this-&gt;compileStatement($match);
            }, $value
        );
    }

    /**
     * Compile a single Blade @ statement.
     *
     * @param  array  $match
     * @return string
     */
    protected function compileStatement($match)
    {
        if (Str::contains($match[1], '@')) {
            $match[0] = isset($match[3]) ? $match[1].$match[3] : $match[1];
        } elseif (isset($this-&gt;customDirectives[$match[1]])) {
            $match[0] = $this-&gt;callCustomDirective($match[1], Arr::get($match, 3));
        } elseif (method_exists($this, $method = 'compile'.ucfirst($match[1]))) {
            $match[0] = $this-&gt;$method(Arr::get($match, 3));
        }

        return isset($match[3]) ? $match[0] : $match[0].$match[2];
    }

    /**
     * Call the given directive with the given value.
     *
     * @param  string  $name
     * @param  string|null  $value
     * @return string
     */
    protected function callCustomDirective($name, $value)
    {
        $value = $value ?? '';

        if (Str::startsWith($value, '(') &amp;&amp; Str::endsWith($value, ')')) {
            $value = Str::substr($value, 1, -1);
        }

        return call_user_func($this-&gt;customDirectives[$name], trim($value));
    }

    /**
     * Strip the parentheses from the given expression.
     *
     * @param  string  $expression
     * @return string
     */
    public function stripParentheses($expression)
    {
        if (Str::startsWith($expression, '(')) {
            $expression = substr($expression, 1, -1);
        }

        return $expression;
    }

    /**
     * Register a custom Blade compiler.
     *
     * @param  callable  $compiler
     * @return void
     */
    public function extend(callable $compiler)
    {
        $this-&gt;extensions[] = $compiler;
    }

    /**
     * Get the extensions used by the compiler.
     *
     * @return array
     */
    public function getExtensions()
    {
        return $this-&gt;extensions;
    }

    /**
     * Register an &quot;if&quot; statement directive.
     *
     * @param  string  $name
     * @param  callable  $callback
     * @return void
     */
    public function if($name, callable $callback)
    {
        $this-&gt;conditions[$name] = $callback;

        $this-&gt;directive($name, function ($expression) use ($name) {
            return $expression !== ''
                    ? &quot;&lt;?php if (\Illuminate\Support\Facades\Blade::check('{$name}', {$expression})): ?&gt;&quot;
                    : &quot;&lt;?php if (\Illuminate\Support\Facades\Blade::check('{$name}')): ?&gt;&quot;;
        });

        $this-&gt;directive('unless'.$name, function ($expression) use ($name) {
            return $expression !== ''
                ? &quot;&lt;?php if (! \Illuminate\Support\Facades\Blade::check('{$name}', {$expression})): ?&gt;&quot;
                : &quot;&lt;?php if (! \Illuminate\Support\Facades\Blade::check('{$name}')): ?&gt;&quot;;
        });

        $this-&gt;directive('else'.$name, function ($expression) use ($name) {
            return $expression !== ''
                ? &quot;&lt;?php elseif (\Illuminate\Support\Facades\Blade::check('{$name}', {$expression})): ?&gt;&quot;
                : &quot;&lt;?php elseif (\Illuminate\Support\Facades\Blade::check('{$name}')): ?&gt;&quot;;
        });

        $this-&gt;directive('end'.$name, function () {
            return '&lt;?php endif; ?&gt;';
        });
    }

    /**
     * Check the result of a condition.
     *
     * @param  string  $name
     * @param  array  $parameters
     * @return bool
     */
    public function check($name, ...$parameters)
    {
        return call_user_func($this-&gt;conditions[$name], ...$parameters);
    }

    /**
     * Register a class-based component alias directive.
     *
     * @param  string  $class
     * @param  string|null  $alias
     * @param  string  $prefix
     * @return void
     */
    public function component($class, $alias = null, $prefix = '')
    {
        if (! is_null($alias) &amp;&amp; Str::contains($alias, '\\')) {
            [$class, $alias] = [$alias, $class];
        }

        if (is_null($alias)) {
            $alias = Str::contains($class, '\\View\\Components\\')
                            ? collect(explode('\\', Str::after($class, '\\View\\Components\\')))-&gt;map(function ($segment) {
                                return Str::kebab($segment);
                            })-&gt;implode(':')
                            : Str::kebab(class_basename($class));
        }

        if (! empty($prefix)) {
            $alias = $prefix.'-'.$alias;
        }

        $this-&gt;classComponentAliases[$alias] = $class;
    }

    /**
     * Register an array of class-based components.
     *
     * @param  array  $components
     * @param  string  $prefix
     * @return void
     */
    public function components(array $components, $prefix = '')
    {
        foreach ($components as $key =&gt; $value) {
            if (is_numeric($key)) {
                $this-&gt;component($value, null, $prefix);
            } else {
                $this-&gt;component($key, $value, $prefix);
            }
        }
    }

    /**
     * Get the registered class component aliases.
     *
     * @return array
     */
    public function getClassComponentAliases()
    {
        return $this-&gt;classComponentAliases;
    }

    /**
     * Register a class-based component namespace.
     *
     * @param  string  $namespace
     * @param  string  $prefix
     * @return void
     */
    public function componentNamespace($namespace, $prefix)
    {
        $this-&gt;classComponentNamespaces[$prefix] = $namespace;
    }

    /**
     * Get the registered class component namespaces.
     *
     * @return array
     */
    public function getClassComponentNamespaces()
    {
        return $this-&gt;classComponentNamespaces;
    }

    /**
     * Register a component alias directive.
     *
     * @param  string  $path
     * @param  string|null  $alias
     * @return void
     */
    public function aliasComponent($path, $alias = null)
    {
        $alias = $alias ?: Arr::last(explode('.', $path));

        $this-&gt;directive($alias, function ($expression) use ($path) {
            return $expression
                        ? &quot;&lt;?php \$__env-&gt;startComponent('{$path}', {$expression}); ?&gt;&quot;
                        : &quot;&lt;?php \$__env-&gt;startComponent('{$path}'); ?&gt;&quot;;
        });

        $this-&gt;directive('end'.$alias, function ($expression) {
            return '&lt;?php echo $__env-&gt;renderComponent(); ?&gt;';
        });
    }

    /**
     * Register an include alias directive.
     *
     * @param  string  $path
     * @param  string|null  $alias
     * @return void
     */
    public function include($path, $alias = null)
    {
        $this-&gt;aliasInclude($path, $alias);
    }

    /**
     * Register an include alias directive.
     *
     * @param  string  $path
     * @param  string|null  $alias
     * @return void
     */
    public function aliasInclude($path, $alias = null)
    {
        $alias = $alias ?: Arr::last(explode('.', $path));

        $this-&gt;directive($alias, function ($expression) use ($path) {
            $expression = $this-&gt;stripParentheses($expression) ?: '[]';

            return &quot;&lt;?php echo \$__env-&gt;make('{$path}', {$expression}, \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path']))-&gt;render(); ?&gt;&quot;;
        });
    }

    /**
     * Register a handler for custom directives.
     *
     * @param  string  $name
     * @param  callable  $handler
     * @return void
     *
     * @throws \InvalidArgumentException
     */
    public function directive($name, callable $handler)
    {
        if (! preg_match('/^\w+(?:::\w+)?$/x', $name)) {
            throw new InvalidArgumentException(&quot;The directive name [{$name}] is not valid. Directive names must only contain alphanumeric characters and underscores.&quot;);
        }

        $this-&gt;customDirectives[$name] = $handler;
    }

    /**
     * Get the list of custom directives.
     *
     * @return array
     */
    public function getCustomDirectives()
    {
        return $this-&gt;customDirectives;
    }

    /**
     * Register a new precompiler.
     *
     * @param  callable  $precompiler
     * @return void
     */
    public function precompiler(callable $precompiler)
    {
        $this-&gt;precompilers[] = $precompiler;
    }

    /**
     * Set the echo format to be used by the compiler.
     *
     * @param  string  $format
     * @return void
     */
    public function setEchoFormat($format)
    {
        $this-&gt;echoFormat = $format;
    }

    /**
     * Set the &quot;echo&quot; format to double encode entities.
     *
     * @return void
     */
    public function withDoubleEncoding()
    {
        $this-&gt;setEchoFormat('e(%s, true)');
    }

    /**
     * Set the &quot;echo&quot; format to not double encode entities.
     *
     * @return void
     */
    public function withoutDoubleEncoding()
    {
        $this-&gt;setEchoFormat('e(%s, false)');
    }

    /**
     * Indicate that component tags should not be compiled.
     *
     * @return void
     */
    public function withoutComponentTags()
    {
        $this-&gt;compilesComponentTags = false;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>