Vendor lock

vendor/illuminate/view/Compilers/BladeCompiler.php

@@ -0,0 +1,557 @@
+<?php
+
+namespace Illuminate\View\Compilers;
+
+use Illuminate\Support\Arr;
+use Illuminate\Support\Str;
+use InvalidArgumentException;
+
+class BladeCompiler extends Compiler implements CompilerInterface
+{
+    use Concerns\CompilesAuthorizations,
+        Concerns\CompilesComments,
+        Concerns\CompilesComponents,
+        Concerns\CompilesConditionals,
+        Concerns\CompilesEchos,
+        Concerns\CompilesErrors,
+        Concerns\CompilesHelpers,
+        Concerns\CompilesIncludes,
+        Concerns\CompilesInjections,
+        Concerns\CompilesJson,
+        Concerns\CompilesLayouts,
+        Concerns\CompilesLoops,
+        Concerns\CompilesRawPhp,
+        Concerns\CompilesStacks,
+        Concerns\CompilesTranslations;
+
+    /**
+     * All of the registered extensions.
+     *
+     * @var array
+     */
+    protected $extensions = [];
+
+    /**
+     * All custom "directive" handlers.
+     *
+     * @var array
+     */
+    protected $customDirectives = [];
+
+    /**
+     * All custom "condition" handlers.
+     *
+     * @var array
+     */
+    protected $conditions = [];
+
+    /**
+     * The file currently being compiled.
+     *
+     * @var string
+     */
+    protected $path;
+
+    /**
+     * All of the available compiler functions.
+     *
+     * @var array
+     */
+    protected $compilers = [
+        'Comments',
+        'Extensions',
+        'Statements',
+        'Echos',
+    ];
+
+    /**
+     * Array of opening and closing tags for raw echos.
+     *
+     * @var array
+     */
+    protected $rawTags = ['{!!', '!!}'];
+
+    /**
+     * Array of opening and closing tags for regular echos.
+     *
+     * @var array
+     */
+    protected $contentTags = ['{{', '}}'];
+
+    /**
+     * Array of opening and closing tags for escaped echos.
+     *
+     * @var array
+     */
+    protected $escapedTags = ['{{{', '}}}'];
+
+    /**
+     * The "regular" / legacy echo string format.
+     *
+     * @var string
+     */
+    protected $echoFormat = 'e(%s)';
+
+    /**
+     * Array of footer lines to be added to template.
+     *
+     * @var array
+     */
+    protected $footer = [];
+
+    /**
+     * Array to temporary store the raw blocks found in the template.
+     *
+     * @var array
+     */
+    protected $rawBlocks = [];
+
+    /**
+     * Compile the view at the given path.
+     *
+     * @param  string|null  $path
+     * @return void
+     */
+    public function compile($path = null)
+    {
+        if ($path) {
+            $this->setPath($path);
+        }
+
+        if (! is_null($this->cachePath)) {
+            $contents = $this->compileString(
+                $this->files->get($this->getPath())
+            );
+
+            if (! empty($this->getPath())) {
+                $tokens = $this->getOpenAndClosingPhpTokens($contents);
+
+                // If the tokens we retrieved from the compiled contents have at least
+                // one opening tag and if that last token isn't the closing tag, we
+                // need to close the statement before adding the path at the end.
+                if ($tokens->isNotEmpty() && $tokens->last() !== T_CLOSE_TAG) {
+                    $contents .= ' ?>';
+                }
+
+                $contents .= "<?php /**PATH {$this->getPath()} ENDPATH**/ ?>";
+            }
+
+            $this->files->put(
+                $this->getCompiledPath($this->getPath()), $contents
+            );
+        }
+    }
+
+    /**
+     * 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))
+            ->pluck($tokenNumber = 0)
+            ->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->path;
+    }
+
+    /**
+     * Set the path currently being compiled.
+     *
+     * @param  string  $path
+     * @return void
+     */
+    public function setPath($path)
+    {
+        $this->path = $path;
+    }
+
+    /**
+     * Compile the given Blade template contents.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    public function compileString($value)
+    {
+        if (strpos($value, '@verbatim') !== false) {
+            $value = $this->storeVerbatimBlocks($value);
+        }
+
+        $this->footer = [];
+
+        if (strpos($value, '@php') !== false) {
+            $value = $this->storePhpBlocks($value);
+        }
+
+        $result = '';
+
+        // 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->parseToken($token) : $token;
+        }
+
+        if (! empty($this->rawBlocks)) {
+            $result = $this->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->footer) > 0) {
+            $result = $this->addFooters($result);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Store the verbatim blocks and replace them with a temporary placeholder.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function storeVerbatimBlocks($value)
+    {
+        return preg_replace_callback('/(?<!@)@verbatim(.*?)@endverbatim/s', function ($matches) {
+            return $this->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('/(?<!@)@php(.*?)@endphp/s', function ($matches) {
+            return $this->storeRawBlock("<?php{$matches[1]}?>");
+        }, $value);
+    }
+
+    /**
+     * Store a raw block and return a unique raw placeholder.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function storeRawBlock($value)
+    {
+        return $this->getRawPlaceholder(
+            array_push($this->rawBlocks, $value) - 1
+        );
+    }
+
+    /**
+     * 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->getRawPlaceholder('(\d+)').'/', function ($matches) {
+            return $this->rawBlocks[$matches[1]];
+        }, $result);
+
+        $this->rawBlocks = [];
+
+        return $result;
+    }
+
+    /**
+     * Get a placeholder to temporary 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, PHP_EOL)
+                .PHP_EOL.implode(PHP_EOL, array_reverse($this->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->compilers as $type) {
+                $content = $this->{"compile{$type}"}($content);
+            }
+        }
+
+        return $content;
+    }
+
+    /**
+     * Execute the user defined extensions.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function compileExtensions($value)
+    {
+        foreach ($this->extensions as $compiler) {
+            $value = call_user_func($compiler, $value, $this);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Compile Blade statements that start with "@".
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function compileStatements($value)
+    {
+        return preg_replace_callback(
+            '/\B@(@?\w+(?:::\w+)?)([ \t]*)(\( ( (?>[^()]+) | (?3) )* \))?/x', function ($match) {
+                return $this->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->customDirectives[$match[1]])) {
+            $match[0] = $this->callCustomDirective($match[1], Arr::get($match, 3));
+        } elseif (method_exists($this, $method = 'compile'.ucfirst($match[1]))) {
+            $match[0] = $this->$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)
+    {
+        if (Str::startsWith($value, '(') && Str::endsWith($value, ')')) {
+            $value = Str::substr($value, 1, -1);
+        }
+
+        return call_user_func($this->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->extensions[] = $compiler;
+    }
+
+    /**
+     * Get the extensions used by the compiler.
+     *
+     * @return array
+     */
+    public function getExtensions()
+    {
+        return $this->extensions;
+    }
+
+    /**
+     * Register an "if" statement directive.
+     *
+     * @param  string  $name
+     * @param  callable  $callback
+     * @return void
+     */
+    public function if($name, callable $callback)
+    {
+        $this->conditions[$name] = $callback;
+
+        $this->directive($name, function ($expression) use ($name) {
+            return $expression !== ''
+                    ? "<?php if (\Illuminate\Support\Facades\Blade::check('{$name}', {$expression})): ?>"
+                    : "<?php if (\Illuminate\Support\Facades\Blade::check('{$name}')): ?>";
+        });
+
+        $this->directive('else'.$name, function ($expression) use ($name) {
+            return $expression !== ''
+                ? "<?php elseif (\Illuminate\Support\Facades\Blade::check('{$name}', {$expression})): ?>"
+                : "<?php elseif (\Illuminate\Support\Facades\Blade::check('{$name}')): ?>";
+        });
+
+        $this->directive('end'.$name, function () {
+            return '<?php endif; ?>';
+        });
+    }
+
+    /**
+     * Check the result of a condition.
+     *
+     * @param  string  $name
+     * @param  array  $parameters
+     * @return bool
+     */
+    public function check($name, ...$parameters)
+    {
+        return call_user_func($this->conditions[$name], ...$parameters);
+    }
+
+    /**
+     * Register a component alias directive.
+     *
+     * @param  string  $path
+     * @param  string|null  $alias
+     * @return void
+     */
+    public function component($path, $alias = null)
+    {
+        $alias = $alias ?: Arr::last(explode('.', $path));
+
+        $this->directive($alias, function ($expression) use ($path) {
+            return $expression
+                        ? "<?php \$__env->startComponent('{$path}', {$expression}); ?>"
+                        : "<?php \$__env->startComponent('{$path}'); ?>";
+        });
+
+        $this->directive('end'.$alias, function ($expression) {
+            return '<?php echo $__env->renderComponent(); ?>';
+        });
+    }
+
+    /**
+     * Register an include alias directive.
+     *
+     * @param  string  $path
+     * @param  string|null  $alias
+     * @return void
+     */
+    public function include($path, $alias = null)
+    {
+        $alias = $alias ?: Arr::last(explode('.', $path));
+
+        $this->directive($alias, function ($expression) use ($path) {
+            $expression = $this->stripParentheses($expression) ?: '[]';
+
+            return "<?php echo \$__env->make('{$path}', {$expression}, \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path']))->render(); ?>";
+        });
+    }
+
+    /**
+     * Register a handler for custom directives.
+     *
+     * @param  string  $name
+     * @param  callable  $handler
+     * @return void
+     */
+    public function directive($name, callable $handler)
+    {
+        if (! preg_match('/^\w+(?:::\w+)?$/x', $name)) {
+            throw new InvalidArgumentException("The directive name [{$name}] is not valid. Directive names must only contain alphanumeric characters and underscores.");
+        }
+
+        $this->customDirectives[$name] = $handler;
+    }
+
+    /**
+     * Get the list of custom directives.
+     *
+     * @return array
+     */
+    public function getCustomDirectives()
+    {
+        return $this->customDirectives;
+    }
+
+    /**
+     * Set the echo format to be used by the compiler.
+     *
+     * @param  string  $format
+     * @return void
+     */
+    public function setEchoFormat($format)
+    {
+        $this->echoFormat = $format;
+    }
+
+    /**
+     * Set the "echo" format to double encode entities.
+     *
+     * @return void
+     */
+    public function withDoubleEncoding()
+    {
+        $this->setEchoFormat('e(%s, true)');
+    }
+
+    /**
+     * Set the "echo" format to not double encode entities.
+     *
+     * @return void
+     */
+    public function withoutDoubleEncoding()
+    {
+        $this->setEchoFormat('e(%s, false)');
+    }
+}

vendor/illuminate/view/Compilers/Compiler.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Illuminate\View\Compilers;
+
+use InvalidArgumentException;
+use Illuminate\Filesystem\Filesystem;
+
+abstract class Compiler
+{
+    /**
+     * The Filesystem instance.
+     *
+     * @var \Illuminate\Filesystem\Filesystem
+     */
+    protected $files;
+
+    /**
+     * Get the cache path for the compiled views.
+     *
+     * @var string
+     */
+    protected $cachePath;
+
+    /**
+     * Create a new compiler instance.
+     *
+     * @param  \Illuminate\Filesystem\Filesystem  $files
+     * @param  string  $cachePath
+     * @return void
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(Filesystem $files, $cachePath)
+    {
+        if (! $cachePath) {
+            throw new InvalidArgumentException('Please provide a valid cache path.');
+        }
+
+        $this->files = $files;
+        $this->cachePath = $cachePath;
+    }
+
+    /**
+     * Get the path to the compiled version of a view.
+     *
+     * @param  string  $path
+     * @return string
+     */
+    public function getCompiledPath($path)
+    {
+        return $this->cachePath.'/'.sha1($path).'.php';
+    }
+
+    /**
+     * Determine if the view at the given path is expired.
+     *
+     * @param  string  $path
+     * @return bool
+     */
+    public function isExpired($path)
+    {
+        $compiled = $this->getCompiledPath($path);
+
+        // If the compiled file doesn't exist we will indicate that the view is expired
+        // so that it can be re-compiled. Else, we will verify the last modification
+        // of the views is less than the modification times of the compiled views.
+        if (! $this->files->exists($compiled)) {
+            return true;
+        }
+
+        return $this->files->lastModified($path) >=
+               $this->files->lastModified($compiled);
+    }
+}

vendor/illuminate/view/Compilers/CompilerInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Illuminate\View\Compilers;
+
+interface CompilerInterface
+{
+    /**
+     * Get the path to the compiled version of a view.
+     *
+     * @param  string  $path
+     * @return string
+     */
+    public function getCompiledPath($path);
+
+    /**
+     * Determine if the given view is expired.
+     *
+     * @param  string  $path
+     * @return bool
+     */
+    public function isExpired($path);
+
+    /**
+     * Compile the view at the given path.
+     *
+     * @param  string  $path
+     * @return void
+     */
+    public function compile($path);
+}

vendor/illuminate/view/Compilers/Concerns/CompilesAuthorizations.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesAuthorizations
+{
+    /**
+     * Compile the can statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileCan($expression)
+    {
+        return "<?php if (app(\Illuminate\\Contracts\\Auth\\Access\\Gate::class)->check{$expression}): ?>";
+    }
+
+    /**
+     * Compile the cannot statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileCannot($expression)
+    {
+        return "<?php if (app(\Illuminate\\Contracts\\Auth\\Access\\Gate::class)->denies{$expression}): ?>";
+    }
+
+    /**
+     * Compile the canany statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileCanany($expression)
+    {
+        return "<?php if (app(\Illuminate\\Contracts\\Auth\\Access\\Gate::class)->any{$expression}): ?>";
+    }
+
+    /**
+     * Compile the else-can statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileElsecan($expression)
+    {
+        return "<?php elseif (app(\Illuminate\\Contracts\\Auth\\Access\\Gate::class)->check{$expression}): ?>";
+    }
+
+    /**
+     * Compile the else-cannot statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileElsecannot($expression)
+    {
+        return "<?php elseif (app(\Illuminate\\Contracts\\Auth\\Access\\Gate::class)->denies{$expression}): ?>";
+    }
+
+    /**
+     * Compile the else-canany statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileElsecanany($expression)
+    {
+        return "<?php elseif (app(\Illuminate\\Contracts\\Auth\\Access\\Gate::class)->any{$expression}): ?>";
+    }
+
+    /**
+     * Compile the end-can statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndcan()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the end-cannot statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndcannot()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the end-canany statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndcanany()
+    {
+        return '<?php endif; ?>';
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesComments.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesComments
+{
+    /**
+     * Compile Blade comments into an empty string.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function compileComments($value)
+    {
+        $pattern = sprintf('/%s--(.*?)--%s/s', $this->contentTags[0], $this->contentTags[1]);
+
+        return preg_replace($pattern, '', $value);
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesComponents.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesComponents
+{
+    /**
+     * Compile the component statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileComponent($expression)
+    {
+        return "<?php \$__env->startComponent{$expression}; ?>";
+    }
+
+    /**
+     * Compile the end-component statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndComponent()
+    {
+        return '<?php echo $__env->renderComponent(); ?>';
+    }
+
+    /**
+     * Compile the slot statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileSlot($expression)
+    {
+        return "<?php \$__env->slot{$expression}; ?>";
+    }
+
+    /**
+     * Compile the end-slot statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndSlot()
+    {
+        return '<?php $__env->endSlot(); ?>';
+    }
+
+    /**
+     * Compile the component-first statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileComponentFirst($expression)
+    {
+        return "<?php \$__env->startComponentFirst{$expression}; ?>";
+    }
+
+    /**
+     * Compile the end-component-first statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndComponentFirst()
+    {
+        return $this->compileEndComponent();
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesConditionals.php

@@ -0,0 +1,230 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesConditionals
+{
+    /**
+     * Identifier for the first case in switch statement.
+     *
+     * @var bool
+     */
+    protected $firstCaseInSwitch = true;
+
+    /**
+     * Compile the if-auth statements into valid PHP.
+     *
+     * @param  string|null  $guard
+     * @return string
+     */
+    protected function compileAuth($guard = null)
+    {
+        $guard = is_null($guard) ? '()' : $guard;
+
+        return "<?php if(auth()->guard{$guard}->check()): ?>";
+    }
+
+    /**
+     * Compile the else-auth statements into valid PHP.
+     *
+     * @param  string|null  $guard
+     * @return string
+     */
+    protected function compileElseAuth($guard = null)
+    {
+        $guard = is_null($guard) ? '()' : $guard;
+
+        return "<?php elseif(auth()->guard{$guard}->check()): ?>";
+    }
+
+    /**
+     * Compile the end-auth statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndAuth()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the if-guest statements into valid PHP.
+     *
+     * @param  string|null  $guard
+     * @return string
+     */
+    protected function compileGuest($guard = null)
+    {
+        $guard = is_null($guard) ? '()' : $guard;
+
+        return "<?php if(auth()->guard{$guard}->guest()): ?>";
+    }
+
+    /**
+     * Compile the else-guest statements into valid PHP.
+     *
+     * @param  string|null  $guard
+     * @return string
+     */
+    protected function compileElseGuest($guard = null)
+    {
+        $guard = is_null($guard) ? '()' : $guard;
+
+        return "<?php elseif(auth()->guard{$guard}->guest()): ?>";
+    }
+
+    /**
+     * Compile the end-guest statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndGuest()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the has-section statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileHasSection($expression)
+    {
+        return "<?php if (! empty(trim(\$__env->yieldContent{$expression}))): ?>";
+    }
+
+    /**
+     * Compile the if statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileIf($expression)
+    {
+        return "<?php if{$expression}: ?>";
+    }
+
+    /**
+     * Compile the unless statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileUnless($expression)
+    {
+        return "<?php if (! {$expression}): ?>";
+    }
+
+    /**
+     * Compile the else-if statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileElseif($expression)
+    {
+        return "<?php elseif{$expression}: ?>";
+    }
+
+    /**
+     * Compile the else statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileElse()
+    {
+        return '<?php else: ?>';
+    }
+
+    /**
+     * Compile the end-if statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndif()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the end-unless statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndunless()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the if-isset statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileIsset($expression)
+    {
+        return "<?php if(isset{$expression}): ?>";
+    }
+
+    /**
+     * Compile the end-isset statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndIsset()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the switch statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileSwitch($expression)
+    {
+        $this->firstCaseInSwitch = true;
+
+        return "<?php switch{$expression}:";
+    }
+
+    /**
+     * Compile the case statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileCase($expression)
+    {
+        if ($this->firstCaseInSwitch) {
+            $this->firstCaseInSwitch = false;
+
+            return "case {$expression}: ?>";
+        }
+
+        return "<?php case {$expression}: ?>";
+    }
+
+    /**
+     * Compile the default statements in switch case into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileDefault()
+    {
+        return '<?php default: ?>';
+    }
+
+    /**
+     * Compile the end switch statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndSwitch()
+    {
+        return '<?php endswitch; ?>';
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesEchos.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesEchos
+{
+    /**
+     * Compile Blade echos into valid PHP.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function compileEchos($value)
+    {
+        foreach ($this->getEchoMethods() as $method) {
+            $value = $this->$method($value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Get the echo methods in the proper order for compilation.
+     *
+     * @return array
+     */
+    protected function getEchoMethods()
+    {
+        return [
+            'compileRawEchos',
+            'compileEscapedEchos',
+            'compileRegularEchos',
+        ];
+    }
+
+    /**
+     * Compile the "raw" echo statements.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function compileRawEchos($value)
+    {
+        $pattern = sprintf('/(@)?%s\s*(.+?)\s*%s(\r?\n)?/s', $this->rawTags[0], $this->rawTags[1]);
+
+        $callback = function ($matches) {
+            $whitespace = empty($matches[3]) ? '' : $matches[3].$matches[3];
+
+            return $matches[1] ? substr($matches[0], 1) : "<?php echo {$matches[2]}; ?>{$whitespace}";
+        };
+
+        return preg_replace_callback($pattern, $callback, $value);
+    }
+
+    /**
+     * Compile the "regular" echo statements.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function compileRegularEchos($value)
+    {
+        $pattern = sprintf('/(@)?%s\s*(.+?)\s*%s(\r?\n)?/s', $this->contentTags[0], $this->contentTags[1]);
+
+        $callback = function ($matches) {
+            $whitespace = empty($matches[3]) ? '' : $matches[3].$matches[3];
+
+            $wrapped = sprintf($this->echoFormat, $matches[2]);
+
+            return $matches[1] ? substr($matches[0], 1) : "<?php echo {$wrapped}; ?>{$whitespace}";
+        };
+
+        return preg_replace_callback($pattern, $callback, $value);
+    }
+
+    /**
+     * Compile the escaped echo statements.
+     *
+     * @param  string  $value
+     * @return string
+     */
+    protected function compileEscapedEchos($value)
+    {
+        $pattern = sprintf('/(@)?%s\s*(.+?)\s*%s(\r?\n)?/s', $this->escapedTags[0], $this->escapedTags[1]);
+
+        $callback = function ($matches) {
+            $whitespace = empty($matches[3]) ? '' : $matches[3].$matches[3];
+
+            return $matches[1] ? $matches[0] : "<?php echo e({$matches[2]}); ?>{$whitespace}";
+        };
+
+        return preg_replace_callback($pattern, $callback, $value);
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesErrors.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesErrors
+{
+    /**
+     * Compile the error statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileError($expression)
+    {
+        $expression = $this->stripParentheses($expression);
+
+        return '<?php if ($errors->has('.$expression.')) :
+if (isset($message)) { $messageCache = $message; }
+$message = $errors->first('.$expression.'); ?>';
+    }
+
+    /**
+     * Compile the enderror statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileEnderror($expression)
+    {
+        return '<?php unset($message);
+if (isset($messageCache)) { $message = $messageCache; }
+endif; ?>';
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesHelpers.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesHelpers
+{
+    /**
+     * Compile the CSRF statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileCsrf()
+    {
+        return '<?php echo csrf_field(); ?>';
+    }
+
+    /**
+     * Compile the "dd" statements into valid PHP.
+     *
+     * @param  string  $arguments
+     * @return string
+     */
+    protected function compileDd($arguments)
+    {
+        return "<?php dd{$arguments}; ?>";
+    }
+
+    /**
+     * Compile the "dump" statements into valid PHP.
+     *
+     * @param  string  $arguments
+     * @return string
+     */
+    protected function compileDump($arguments)
+    {
+        return "<?php dump{$arguments}; ?>";
+    }
+
+    /**
+     * Compile the method statements into valid PHP.
+     *
+     * @param  string  $method
+     * @return string
+     */
+    protected function compileMethod($method)
+    {
+        return "<?php echo method_field{$method}; ?>";
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesIncludes.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesIncludes
+{
+    /**
+     * Compile the each statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileEach($expression)
+    {
+        return "<?php echo \$__env->renderEach{$expression}; ?>";
+    }
+
+    /**
+     * Compile the include statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileInclude($expression)
+    {
+        $expression = $this->stripParentheses($expression);
+
+        return "<?php echo \$__env->make({$expression}, \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path']))->render(); ?>";
+    }
+
+    /**
+     * Compile the include-if statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileIncludeIf($expression)
+    {
+        $expression = $this->stripParentheses($expression);
+
+        return "<?php if (\$__env->exists({$expression})) echo \$__env->make({$expression}, \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path']))->render(); ?>";
+    }
+
+    /**
+     * Compile the include-when statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileIncludeWhen($expression)
+    {
+        $expression = $this->stripParentheses($expression);
+
+        return "<?php echo \$__env->renderWhen($expression, \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path'])); ?>";
+    }
+
+    /**
+     * Compile the include-first statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileIncludeFirst($expression)
+    {
+        $expression = $this->stripParentheses($expression);
+
+        return "<?php echo \$__env->first({$expression}, \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path']))->render(); ?>";
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesInjections.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesInjections
+{
+    /**
+     * Compile the inject statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileInject($expression)
+    {
+        $segments = explode(',', preg_replace("/[\(\)\\\"\']/", '', $expression));
+
+        $variable = trim($segments[0]);
+
+        $service = trim($segments[1]);
+
+        return "<?php \${$variable} = app('{$service}'); ?>";
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesJson.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesJson
+{
+    /**
+     * The default JSON encoding options.
+     *
+     * @var int
+     */
+    private $encodingOptions = JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_AMP | JSON_HEX_QUOT;
+
+    /**
+     * Compile the JSON statement into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileJson($expression)
+    {
+        $parts = explode(',', $this->stripParentheses($expression));
+
+        $options = isset($parts[1]) ? trim($parts[1]) : $this->encodingOptions;
+
+        $depth = isset($parts[2]) ? trim($parts[2]) : 512;
+
+        return "<?php echo json_encode($parts[0], $options, $depth) ?>";
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesLayouts.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+use Illuminate\View\Factory as ViewFactory;
+
+trait CompilesLayouts
+{
+    /**
+     * The name of the last section that was started.
+     *
+     * @var string
+     */
+    protected $lastSection;
+
+    /**
+     * Compile the extends statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileExtends($expression)
+    {
+        $expression = $this->stripParentheses($expression);
+
+        $echo = "<?php echo \$__env->make({$expression}, \Illuminate\Support\Arr::except(get_defined_vars(), ['__data', '__path']))->render(); ?>";
+
+        $this->footer[] = $echo;
+
+        return '';
+    }
+
+    /**
+     * Compile the section statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileSection($expression)
+    {
+        $this->lastSection = trim($expression, "()'\" ");
+
+        return "<?php \$__env->startSection{$expression}; ?>";
+    }
+
+    /**
+     * Replace the @parent directive to a placeholder.
+     *
+     * @return string
+     */
+    protected function compileParent()
+    {
+        return ViewFactory::parentPlaceholder($this->lastSection ?: '');
+    }
+
+    /**
+     * Compile the yield statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileYield($expression)
+    {
+        return "<?php echo \$__env->yieldContent{$expression}; ?>";
+    }
+
+    /**
+     * Compile the show statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileShow()
+    {
+        return '<?php echo $__env->yieldSection(); ?>';
+    }
+
+    /**
+     * Compile the append statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileAppend()
+    {
+        return '<?php $__env->appendSection(); ?>';
+    }
+
+    /**
+     * Compile the overwrite statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileOverwrite()
+    {
+        return '<?php $__env->stopSection(true); ?>';
+    }
+
+    /**
+     * Compile the stop statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileStop()
+    {
+        return '<?php $__env->stopSection(); ?>';
+    }
+
+    /**
+     * Compile the end-section statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndsection()
+    {
+        return '<?php $__env->stopSection(); ?>';
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesLoops.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesLoops
+{
+    /**
+     * Counter to keep track of nested forelse statements.
+     *
+     * @var int
+     */
+    protected $forElseCounter = 0;
+
+    /**
+     * Compile the for-else statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileForelse($expression)
+    {
+        $empty = '$__empty_'.++$this->forElseCounter;
+
+        preg_match('/\( *(.*) +as *(.*)\)$/is', $expression, $matches);
+
+        $iteratee = trim($matches[1]);
+
+        $iteration = trim($matches[2]);
+
+        $initLoop = "\$__currentLoopData = {$iteratee}; \$__env->addLoop(\$__currentLoopData);";
+
+        $iterateLoop = '$__env->incrementLoopIndices(); $loop = $__env->getLastLoop();';
+
+        return "<?php {$empty} = true; {$initLoop} foreach(\$__currentLoopData as {$iteration}): {$iterateLoop} {$empty} = false; ?>";
+    }
+
+    /**
+     * Compile the for-else-empty and empty statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileEmpty($expression)
+    {
+        if ($expression) {
+            return "<?php if(empty{$expression}): ?>";
+        }
+
+        $empty = '$__empty_'.$this->forElseCounter--;
+
+        return "<?php endforeach; \$__env->popLoop(); \$loop = \$__env->getLastLoop(); if ({$empty}): ?>";
+    }
+
+    /**
+     * Compile the end-for-else statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndforelse()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the end-empty statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndEmpty()
+    {
+        return '<?php endif; ?>';
+    }
+
+    /**
+     * Compile the for statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileFor($expression)
+    {
+        return "<?php for{$expression}: ?>";
+    }
+
+    /**
+     * Compile the for-each statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileForeach($expression)
+    {
+        preg_match('/\( *(.*) +as *(.*)\)$/is', $expression, $matches);
+
+        $iteratee = trim($matches[1]);
+
+        $iteration = trim($matches[2]);
+
+        $initLoop = "\$__currentLoopData = {$iteratee}; \$__env->addLoop(\$__currentLoopData);";
+
+        $iterateLoop = '$__env->incrementLoopIndices(); $loop = $__env->getLastLoop();';
+
+        return "<?php {$initLoop} foreach(\$__currentLoopData as {$iteration}): {$iterateLoop} ?>";
+    }
+
+    /**
+     * Compile the break statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileBreak($expression)
+    {
+        if ($expression) {
+            preg_match('/\(\s*(-?\d+)\s*\)$/', $expression, $matches);
+
+            return $matches ? '<?php break '.max(1, $matches[1]).'; ?>' : "<?php if{$expression} break; ?>";
+        }
+
+        return '<?php break; ?>';
+    }
+
+    /**
+     * Compile the continue statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileContinue($expression)
+    {
+        if ($expression) {
+            preg_match('/\(\s*(-?\d+)\s*\)$/', $expression, $matches);
+
+            return $matches ? '<?php continue '.max(1, $matches[1]).'; ?>' : "<?php if{$expression} continue; ?>";
+        }
+
+        return '<?php continue; ?>';
+    }
+
+    /**
+     * Compile the end-for statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndfor()
+    {
+        return '<?php endfor; ?>';
+    }
+
+    /**
+     * Compile the end-for-each statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndforeach()
+    {
+        return '<?php endforeach; $__env->popLoop(); $loop = $__env->getLastLoop(); ?>';
+    }
+
+    /**
+     * Compile the while statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileWhile($expression)
+    {
+        return "<?php while{$expression}: ?>";
+    }
+
+    /**
+     * Compile the end-while statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndwhile()
+    {
+        return '<?php endwhile; ?>';
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesRawPhp.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesRawPhp
+{
+    /**
+     * Compile the raw PHP statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compilePhp($expression)
+    {
+        if ($expression) {
+            return "<?php {$expression}; ?>";
+        }
+
+        return '@php';
+    }
+
+    /**
+     * Compile the unset statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileUnset($expression)
+    {
+        return "<?php unset{$expression}; ?>";
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesStacks.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesStacks
+{
+    /**
+     * Compile the stack statements into the content.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileStack($expression)
+    {
+        return "<?php echo \$__env->yieldPushContent{$expression}; ?>";
+    }
+
+    /**
+     * Compile the push statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compilePush($expression)
+    {
+        return "<?php \$__env->startPush{$expression}; ?>";
+    }
+
+    /**
+     * Compile the end-push statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndpush()
+    {
+        return '<?php $__env->stopPush(); ?>';
+    }
+
+    /**
+     * Compile the prepend statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compilePrepend($expression)
+    {
+        return "<?php \$__env->startPrepend{$expression}; ?>";
+    }
+
+    /**
+     * Compile the end-prepend statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndprepend()
+    {
+        return '<?php $__env->stopPrepend(); ?>';
+    }
+}

vendor/illuminate/view/Compilers/Concerns/CompilesTranslations.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Illuminate\View\Compilers\Concerns;
+
+trait CompilesTranslations
+{
+    /**
+     * Compile the lang statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileLang($expression)
+    {
+        if (is_null($expression)) {
+            return '<?php $__env->startTranslation(); ?>';
+        } elseif ($expression[1] === '[') {
+            return "<?php \$__env->startTranslation{$expression}; ?>";
+        }
+
+        return "<?php echo app('translator')->getFromJson{$expression}; ?>";
+    }
+
+    /**
+     * Compile the end-lang statements into valid PHP.
+     *
+     * @return string
+     */
+    protected function compileEndlang()
+    {
+        return '<?php echo $__env->renderTranslation(); ?>';
+    }
+
+    /**
+     * Compile the choice statements into valid PHP.
+     *
+     * @param  string  $expression
+     * @return string
+     */
+    protected function compileChoice($expression)
+    {
+        return "<?php echo app('translator')->choice{$expression}; ?>";
+    }
+}