Ajout des vendor

vendor/symfony/dotenv/CHANGELOG.md

@@ -0,0 +1,40 @@
+CHANGELOG
+=========
+
+5.4
+---
+
+ * Add `dotenv:dump` command to compile the contents of the .env files into a PHP-optimized file called `.env.local.php`
+ * Add `debug:dotenv` command to list all dotenv files with variables and values
+ * Add `$overrideExistingVars` on `Dotenv::bootEnv()` and `Dotenv::loadEnv()`
+
+5.1.0
+-----
+
+ * added `Dotenv::bootEnv()` to check for `.env.local.php` before calling `Dotenv::loadEnv()`
+ * added `Dotenv::setProdEnvs()` and `Dotenv::usePutenv()`
+ * made Dotenv's constructor accept `$envKey` and `$debugKey` arguments, to define
+   the name of the env vars that configure the env name and debug settings
+ * deprecated passing `$usePutenv` argument to Dotenv's constructor
+
+5.0.0
+-----
+
+ * using `putenv()` is disabled by default
+
+4.3.0
+-----
+
+ * deprecated use of `putenv()` by default. This feature will be opted-in with a constructor argument to `Dotenv`
+
+4.2.0
+-----
+
+ * added `Dotenv::overload()` and `$overrideExistingVars` as optional parameter of `Dotenv::populate()`
+ * added `Dotenv::loadEnv()` to load a .env file and its corresponding .env.local, .env.$env and .env.$env.local files if they exist
+
+3.3.0
+-----
+
+ * [BC BREAK] Since v3.3.7, the latest Dotenv files override the previous ones. Real env vars are not affected and are not overridden.
+ * added the component

vendor/symfony/dotenv/Command/DebugCommand.php

@@ -0,0 +1,143 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Dotenv\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use Symfony\Component\Dotenv\Dotenv;
+
+/**
+ * A console command to debug current dotenv files with variables and values.
+ *
+ * @author Christopher Hertel <mail@christopher-hertel.de>
+ */
+final class DebugCommand extends Command
+{
+    protected static $defaultName = 'debug:dotenv';
+    protected static $defaultDescription = 'Lists all dotenv files with variables and values';
+
+    private $kernelEnvironment;
+    private $projectDirectory;
+
+    public function __construct(string $kernelEnvironment, string $projectDirectory)
+    {
+        $this->kernelEnvironment = $kernelEnvironment;
+        $this->projectDirectory = $projectDirectory;
+
+        parent::__construct();
+    }
+
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $io = new SymfonyStyle($input, $output);
+        $io->title('Dotenv Variables & Files');
+
+        if (!\array_key_exists('SYMFONY_DOTENV_VARS', $_SERVER)) {
+            $io->error('Dotenv component is not initialized.');
+
+            return 1;
+        }
+
+        $envFiles = $this->getEnvFiles();
+        $availableFiles = array_filter($envFiles, function (string $file) {
+            return is_file($this->getFilePath($file));
+        });
+
+        if (\in_array('.env.local.php', $availableFiles, true)) {
+            $io->warning('Due to existing dump file (.env.local.php) all other dotenv files are skipped.');
+        }
+
+        if (is_file($this->getFilePath('.env')) && is_file($this->getFilePath('.env.dist'))) {
+            $io->warning('The file .env.dist gets skipped due to the existence of .env.');
+        }
+
+        $io->section('Scanned Files (in descending priority)');
+        $io->listing(array_map(static function (string $envFile) use ($availableFiles) {
+            return \in_array($envFile, $availableFiles, true)
+                ? sprintf('<fg=green>✓</> %s', $envFile)
+                : sprintf('<fg=red>⨯</> %s', $envFile);
+        }, $envFiles));
+
+        $io->section('Variables');
+        $io->table(
+            array_merge(['Variable', 'Value'], $availableFiles),
+            $this->getVariables($availableFiles)
+        );
+
+        $io->comment('Note real values might be different between web and CLI.');
+
+        return 0;
+    }
+
+    private function getVariables(array $envFiles): array
+    {
+        $vars = explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? '');
+        sort($vars);
+
+        $output = [];
+        $fileValues = [];
+        foreach ($vars as $var) {
+            $realValue = $_SERVER[$var];
+            $varDetails = [$var, $realValue];
+            foreach ($envFiles as $envFile) {
+                $values = $fileValues[$envFile] ?? $fileValues[$envFile] = $this->loadValues($envFile);
+
+                $varString = $values[$var] ?? '<fg=yellow>n/a</>';
+                $shortenedVar = $this->getHelper('formatter')->truncate($varString, 30);
+                $varDetails[] = $varString === $realValue ? '<fg=green>'.$shortenedVar.'</>' : $shortenedVar;
+            }
+
+            $output[] = $varDetails;
+        }
+
+        return $output;
+    }
+
+    private function getEnvFiles(): array
+    {
+        $files = [
+            '.env.local.php',
+            sprintf('.env.%s.local', $this->kernelEnvironment),
+            sprintf('.env.%s', $this->kernelEnvironment),
+        ];
+
+        if ('test' !== $this->kernelEnvironment) {
+            $files[] = '.env.local';
+        }
+
+        if (!is_file($this->getFilePath('.env')) && is_file($this->getFilePath('.env.dist'))) {
+            $files[] = '.env.dist';
+        } else {
+            $files[] = '.env';
+        }
+
+        return $files;
+    }
+
+    private function getFilePath(string $file): string
+    {
+        return $this->projectDirectory.\DIRECTORY_SEPARATOR.$file;
+    }
+
+    private function loadValues(string $file): array
+    {
+        $filePath = $this->getFilePath($file);
+
+        if (str_ends_with($filePath, '.php')) {
+            return include $filePath;
+        }
+
+        return (new Dotenv())->parse(file_get_contents($filePath));
+    }
+}

vendor/symfony/dotenv/Command/DotenvDumpCommand.php

@@ -0,0 +1,123 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Dotenv\Command;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autoconfigure;
+use Symfony\Component\Dotenv\Dotenv;
+
+/**
+ * A console command to compile .env files into a PHP-optimized file called .env.local.php.
+ *
+ * @internal
+ */
+#[Autoconfigure(bind: ['$projectDir' => '%kernel.project_dir%', '$defaultEnv' => '%kernel.environment%'])]
+final class DotenvDumpCommand extends Command
+{
+    protected static $defaultName = 'dotenv:dump';
+    protected static $defaultDescription = 'Compiles .env files to .env.local.php';
+
+    private $projectDir;
+    private $defaultEnv;
+
+    public function __construct(string $projectDir, string $defaultEnv = null)
+    {
+        $this->projectDir = $projectDir;
+        $this->defaultEnv = $defaultEnv;
+
+        parent::__construct();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function configure()
+    {
+        $this
+            ->setDefinition([
+                new InputArgument('env', null === $this->defaultEnv ? InputArgument::REQUIRED : InputArgument::OPTIONAL, 'The application environment to dump .env files for - e.g. "prod".'),
+            ])
+            ->addOption('empty', null, InputOption::VALUE_NONE, 'Ignore the content of .env files')
+            ->setHelp(<<<'EOT'
+The <info>%command.name%</info> command compiles .env files into a PHP-optimized file called .env.local.php.
+
+    <info>%command.full_name%</info>
+EOT
+            )
+        ;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $config = [];
+        if (is_file($projectDir = $this->projectDir)) {
+            $config = ['dotenv_path' => basename($projectDir)];
+            $projectDir = \dirname($projectDir);
+        }
+
+        $composerFile = $projectDir.'/composer.json';
+        $config += (is_file($composerFile) ? json_decode(file_get_contents($composerFile), true) : [])['extra']['runtime'] ?? [];
+        $dotenvPath = $projectDir.'/'.($config['dotenv_path'] ?? '.env');
+        $env = $input->getArgument('env') ?? $this->defaultEnv;
+        $envKey = $config['env_var_name'] ?? 'APP_ENV';
+
+        if ($input->getOption('empty')) {
+            $vars = [$envKey => $env];
+        } else {
+            $vars = $this->loadEnv($dotenvPath, $env, $config);
+            $env = $vars[$envKey];
+        }
+
+        $vars = var_export($vars, true);
+        $vars = <<<EOF
+<?php
+
+// This file was generated by running "php bin/console dotenv:dump $env"
+
+return $vars;
+
+EOF;
+        file_put_contents($dotenvPath.'.local.php', $vars, \LOCK_EX);
+
+        $output->writeln(sprintf('Successfully dumped .env files in <info>.env.local.php</> for the <info>%s</> environment.', $env));
+
+        return 0;
+    }
+
+    private function loadEnv(string $dotenvPath, string $env, array $config): array
+    {
+        $dotenv = new Dotenv();
+        $envKey = $config['env_var_name'] ?? 'APP_ENV';
+        $testEnvs = $config['test_envs'] ?? ['test'];
+
+        $globalsBackup = [$_SERVER, $_ENV];
+        unset($_SERVER[$envKey]);
+        $_ENV = [$envKey => $env];
+        $_SERVER['SYMFONY_DOTENV_VARS'] = implode(',', array_keys($_SERVER));
+
+        try {
+            $dotenv->loadEnv($dotenvPath, null, 'dev', $testEnvs);
+            unset($_ENV['SYMFONY_DOTENV_VARS']);
+
+            return $_ENV;
+        } finally {
+            [$_SERVER, $_ENV] = $globalsBackup;
+        }
+    }
+}

vendor/symfony/dotenv/Dotenv.php

@@ -0,0 +1,573 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Dotenv;
+
+use Symfony\Component\Dotenv\Exception\FormatException;
+use Symfony\Component\Dotenv\Exception\FormatExceptionContext;
+use Symfony\Component\Dotenv\Exception\PathException;
+use Symfony\Component\Process\Exception\ExceptionInterface as ProcessException;
+use Symfony\Component\Process\Process;
+
+/**
+ * Manages .env files.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+final class Dotenv
+{
+    public const VARNAME_REGEX = '(?i:[A-Z][A-Z0-9_]*+)';
+    public const STATE_VARNAME = 0;
+    public const STATE_VALUE = 1;
+
+    private $path;
+    private $cursor;
+    private $lineno;
+    private $data;
+    private $end;
+    private $values;
+    private $envKey;
+    private $debugKey;
+    private $prodEnvs = ['prod'];
+    private $usePutenv = false;
+
+    /**
+     * @param string $envKey
+     */
+    public function __construct($envKey = 'APP_ENV', string $debugKey = 'APP_DEBUG')
+    {
+        if (\in_array($envKey = (string) $envKey, ['1', ''], true)) {
+            trigger_deprecation('symfony/dotenv', '5.1', 'Passing a boolean to the constructor of "%s" is deprecated, use "Dotenv::usePutenv()".', __CLASS__);
+            $this->usePutenv = (bool) $envKey;
+            $envKey = 'APP_ENV';
+        }
+
+        $this->envKey = $envKey;
+        $this->debugKey = $debugKey;
+    }
+
+    /**
+     * @return $this
+     */
+    public function setProdEnvs(array $prodEnvs): self
+    {
+        $this->prodEnvs = $prodEnvs;
+
+        return $this;
+    }
+
+    /**
+     * @param bool $usePutenv If `putenv()` should be used to define environment variables or not.
+     *                        Beware that `putenv()` is not thread safe, that's why this setting defaults to false
+     *
+     * @return $this
+     */
+    public function usePutenv(bool $usePutenv = true): self
+    {
+        $this->usePutenv = $usePutenv;
+
+        return $this;
+    }
+
+    /**
+     * Loads one or several .env files.
+     *
+     * @param string   $path          A file to load
+     * @param string[] ...$extraPaths A list of additional files to load
+     *
+     * @throws FormatException when a file has a syntax error
+     * @throws PathException   when a file does not exist or is not readable
+     */
+    public function load(string $path, string ...$extraPaths): void
+    {
+        $this->doLoad(false, \func_get_args());
+    }
+
+    /**
+     * Loads a .env file and the corresponding .env.local, .env.$env and .env.$env.local files if they exist.
+     *
+     * .env.local is always ignored in test env because tests should produce the same results for everyone.
+     * .env.dist is loaded when it exists and .env is not found.
+     *
+     * @param string $path        A file to load
+     * @param string $envKey|null The name of the env vars that defines the app env
+     * @param string $defaultEnv  The app env to use when none is defined
+     * @param array  $testEnvs    A list of app envs for which .env.local should be ignored
+     *
+     * @throws FormatException when a file has a syntax error
+     * @throws PathException   when a file does not exist or is not readable
+     */
+    public function loadEnv(string $path, string $envKey = null, string $defaultEnv = 'dev', array $testEnvs = ['test'], bool $overrideExistingVars = false): void
+    {
+        $k = $envKey ?? $this->envKey;
+
+        if (is_file($path) || !is_file($p = "$path.dist")) {
+            $this->doLoad($overrideExistingVars, [$path]);
+        } else {
+            $this->doLoad($overrideExistingVars, [$p]);
+        }
+
+        if (null === $env = $_SERVER[$k] ?? $_ENV[$k] ?? null) {
+            $this->populate([$k => $env = $defaultEnv], $overrideExistingVars);
+        }
+
+        if (!\in_array($env, $testEnvs, true) && is_file($p = "$path.local")) {
+            $this->doLoad($overrideExistingVars, [$p]);
+            $env = $_SERVER[$k] ?? $_ENV[$k] ?? $env;
+        }
+
+        if ('local' === $env) {
+            return;
+        }
+
+        if (is_file($p = "$path.$env")) {
+            $this->doLoad($overrideExistingVars, [$p]);
+        }
+
+        if (is_file($p = "$path.$env.local")) {
+            $this->doLoad($overrideExistingVars, [$p]);
+        }
+    }
+
+    /**
+     * Loads env vars from .env.local.php if the file exists or from the other .env files otherwise.
+     *
+     * This method also configures the APP_DEBUG env var according to the current APP_ENV.
+     *
+     * See method loadEnv() for rules related to .env files.
+     */
+    public function bootEnv(string $path, string $defaultEnv = 'dev', array $testEnvs = ['test'], bool $overrideExistingVars = false): void
+    {
+        $p = $path.'.local.php';
+        $env = is_file($p) ? include $p : null;
+        $k = $this->envKey;
+
+        if (\is_array($env) && ($overrideExistingVars || !isset($env[$k]) || ($_SERVER[$k] ?? $_ENV[$k] ?? $env[$k]) === $env[$k])) {
+            $this->populate($env, $overrideExistingVars);
+        } else {
+            $this->loadEnv($path, $k, $defaultEnv, $testEnvs, $overrideExistingVars);
+        }
+
+        $_SERVER += $_ENV;
+
+        $k = $this->debugKey;
+        $debug = $_SERVER[$k] ?? !\in_array($_SERVER[$this->envKey], $this->prodEnvs, true);
+        $_SERVER[$k] = $_ENV[$k] = (int) $debug || (!\is_bool($debug) && filter_var($debug, \FILTER_VALIDATE_BOOLEAN)) ? '1' : '0';
+    }
+
+    /**
+     * Loads one or several .env files and enables override existing vars.
+     *
+     * @param string   $path          A file to load
+     * @param string[] ...$extraPaths A list of additional files to load
+     *
+     * @throws FormatException when a file has a syntax error
+     * @throws PathException   when a file does not exist or is not readable
+     */
+    public function overload(string $path, string ...$extraPaths): void
+    {
+        $this->doLoad(true, \func_get_args());
+    }
+
+    /**
+     * Sets values as environment variables (via putenv, $_ENV, and $_SERVER).
+     *
+     * @param array $values               An array of env variables
+     * @param bool  $overrideExistingVars true when existing environment variables must be overridden
+     */
+    public function populate(array $values, bool $overrideExistingVars = false): void
+    {
+        $updateLoadedVars = false;
+        $loadedVars = array_flip(explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? ''));
+
+        foreach ($values as $name => $value) {
+            $notHttpName = 0 !== strpos($name, 'HTTP_');
+            if (isset($_SERVER[$name]) && $notHttpName && !isset($_ENV[$name])) {
+                $_ENV[$name] = $_SERVER[$name];
+            }
+
+            // don't check existence with getenv() because of thread safety issues
+            if (!isset($loadedVars[$name]) && !$overrideExistingVars && isset($_ENV[$name])) {
+                continue;
+            }
+
+            if ($this->usePutenv) {
+                putenv("$name=$value");
+            }
+
+            $_ENV[$name] = $value;
+            if ($notHttpName) {
+                $_SERVER[$name] = $value;
+            }
+
+            if (!isset($loadedVars[$name])) {
+                $loadedVars[$name] = $updateLoadedVars = true;
+            }
+        }
+
+        if ($updateLoadedVars) {
+            unset($loadedVars['']);
+            $loadedVars = implode(',', array_keys($loadedVars));
+            $_ENV['SYMFONY_DOTENV_VARS'] = $_SERVER['SYMFONY_DOTENV_VARS'] = $loadedVars;
+
+            if ($this->usePutenv) {
+                putenv('SYMFONY_DOTENV_VARS='.$loadedVars);
+            }
+        }
+    }
+
+    /**
+     * Parses the contents of an .env file.
+     *
+     * @param string $data The data to be parsed
+     * @param string $path The original file name where data where stored (used for more meaningful error messages)
+     *
+     * @throws FormatException when a file has a syntax error
+     */
+    public function parse(string $data, string $path = '.env'): array
+    {
+        $this->path = $path;
+        $this->data = str_replace(["\r\n", "\r"], "\n", $data);
+        $this->lineno = 1;
+        $this->cursor = 0;
+        $this->end = \strlen($this->data);
+        $state = self::STATE_VARNAME;
+        $this->values = [];
+        $name = '';
+
+        $this->skipEmptyLines();
+
+        while ($this->cursor < $this->end) {
+            switch ($state) {
+                case self::STATE_VARNAME:
+                    $name = $this->lexVarname();
+                    $state = self::STATE_VALUE;
+                    break;
+
+                case self::STATE_VALUE:
+                    $this->values[$name] = $this->lexValue();
+                    $state = self::STATE_VARNAME;
+                    break;
+            }
+        }
+
+        if (self::STATE_VALUE === $state) {
+            $this->values[$name] = '';
+        }
+
+        try {
+            return $this->values;
+        } finally {
+            $this->values = [];
+            $this->data = null;
+            $this->path = null;
+        }
+    }
+
+    private function lexVarname(): string
+    {
+        // var name + optional export
+        if (!preg_match('/(export[ \t]++)?('.self::VARNAME_REGEX.')/A', $this->data, $matches, 0, $this->cursor)) {
+            throw $this->createFormatException('Invalid character in variable name');
+        }
+        $this->moveCursor($matches[0]);
+
+        if ($this->cursor === $this->end || "\n" === $this->data[$this->cursor] || '#' === $this->data[$this->cursor]) {
+            if ($matches[1]) {
+                throw $this->createFormatException('Unable to unset an environment variable');
+            }
+
+            throw $this->createFormatException('Missing = in the environment variable declaration');
+        }
+
+        if (' ' === $this->data[$this->cursor] || "\t" === $this->data[$this->cursor]) {
+            throw $this->createFormatException('Whitespace characters are not supported after the variable name');
+        }
+
+        if ('=' !== $this->data[$this->cursor]) {
+            throw $this->createFormatException('Missing = in the environment variable declaration');
+        }
+        ++$this->cursor;
+
+        return $matches[2];
+    }
+
+    private function lexValue(): string
+    {
+        if (preg_match('/[ \t]*+(?:#.*)?$/Am', $this->data, $matches, 0, $this->cursor)) {
+            $this->moveCursor($matches[0]);
+            $this->skipEmptyLines();
+
+            return '';
+        }
+
+        if (' ' === $this->data[$this->cursor] || "\t" === $this->data[$this->cursor]) {
+            throw $this->createFormatException('Whitespace are not supported before the value');
+        }
+
+        $loadedVars = array_flip(explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? ($_ENV['SYMFONY_DOTENV_VARS'] ?? '')));
+        unset($loadedVars['']);
+        $v = '';
+
+        do {
+            if ("'" === $this->data[$this->cursor]) {
+                $len = 0;
+
+                do {
+                    if ($this->cursor + ++$len === $this->end) {
+                        $this->cursor += $len;
+
+                        throw $this->createFormatException('Missing quote to end the value');
+                    }
+                } while ("'" !== $this->data[$this->cursor + $len]);
+
+                $v .= substr($this->data, 1 + $this->cursor, $len - 1);
+                $this->cursor += 1 + $len;
+            } elseif ('"' === $this->data[$this->cursor]) {
+                $value = '';
+
+                if (++$this->cursor === $this->end) {
+                    throw $this->createFormatException('Missing quote to end the value');
+                }
+
+                while ('"' !== $this->data[$this->cursor] || ('\\' === $this->data[$this->cursor - 1] && '\\' !== $this->data[$this->cursor - 2])) {
+                    $value .= $this->data[$this->cursor];
+                    ++$this->cursor;
+
+                    if ($this->cursor === $this->end) {
+                        throw $this->createFormatException('Missing quote to end the value');
+                    }
+                }
+                ++$this->cursor;
+                $value = str_replace(['\\"', '\r', '\n'], ['"', "\r", "\n"], $value);
+                $resolvedValue = $value;
+                $resolvedValue = $this->resolveVariables($resolvedValue, $loadedVars);
+                $resolvedValue = $this->resolveCommands($resolvedValue, $loadedVars);
+                $resolvedValue = str_replace('\\\\', '\\', $resolvedValue);
+                $v .= $resolvedValue;
+            } else {
+                $value = '';
+                $prevChr = $this->data[$this->cursor - 1];
+                while ($this->cursor < $this->end && !\in_array($this->data[$this->cursor], ["\n", '"', "'"], true) && !((' ' === $prevChr || "\t" === $prevChr) && '#' === $this->data[$this->cursor])) {
+                    if ('\\' === $this->data[$this->cursor] && isset($this->data[$this->cursor + 1]) && ('"' === $this->data[$this->cursor + 1] || "'" === $this->data[$this->cursor + 1])) {
+                        ++$this->cursor;
+                    }
+
+                    $value .= $prevChr = $this->data[$this->cursor];
+
+                    if ('$' === $this->data[$this->cursor] && isset($this->data[$this->cursor + 1]) && '(' === $this->data[$this->cursor + 1]) {
+                        ++$this->cursor;
+                        $value .= '('.$this->lexNestedExpression().')';
+                    }
+
+                    ++$this->cursor;
+                }
+                $value = rtrim($value);
+                $resolvedValue = $value;
+                $resolvedValue = $this->resolveVariables($resolvedValue, $loadedVars);
+                $resolvedValue = $this->resolveCommands($resolvedValue, $loadedVars);
+                $resolvedValue = str_replace('\\\\', '\\', $resolvedValue);
+
+                if ($resolvedValue === $value && preg_match('/\s+/', $value)) {
+                    throw $this->createFormatException('A value containing spaces must be surrounded by quotes');
+                }
+
+                $v .= $resolvedValue;
+
+                if ($this->cursor < $this->end && '#' === $this->data[$this->cursor]) {
+                    break;
+                }
+            }
+        } while ($this->cursor < $this->end && "\n" !== $this->data[$this->cursor]);
+
+        $this->skipEmptyLines();
+
+        return $v;
+    }
+
+    private function lexNestedExpression(): string
+    {
+        ++$this->cursor;
+        $value = '';
+
+        while ("\n" !== $this->data[$this->cursor] && ')' !== $this->data[$this->cursor]) {
+            $value .= $this->data[$this->cursor];
+
+            if ('(' === $this->data[$this->cursor]) {
+                $value .= $this->lexNestedExpression().')';
+            }
+
+            ++$this->cursor;
+
+            if ($this->cursor === $this->end) {
+                throw $this->createFormatException('Missing closing parenthesis.');
+            }
+        }
+
+        if ("\n" === $this->data[$this->cursor]) {
+            throw $this->createFormatException('Missing closing parenthesis.');
+        }
+
+        return $value;
+    }
+
+    private function skipEmptyLines()
+    {
+        if (preg_match('/(?:\s*+(?:#[^\n]*+)?+)++/A', $this->data, $match, 0, $this->cursor)) {
+            $this->moveCursor($match[0]);
+        }
+    }
+
+    private function resolveCommands(string $value, array $loadedVars): string
+    {
+        if (false === strpos($value, '$')) {
+            return $value;
+        }
+
+        $regex = '/
+            (\\\\)?               # escaped with a backslash?
+            \$
+            (?<cmd>
+                \(                # require opening parenthesis
+                ([^()]|\g<cmd>)+  # allow any number of non-parens, or balanced parens (by nesting the <cmd> expression recursively)
+                \)                # require closing paren
+            )
+        /x';
+
+        return preg_replace_callback($regex, function ($matches) use ($loadedVars) {
+            if ('\\' === $matches[1]) {
+                return substr($matches[0], 1);
+            }
+
+            if ('\\' === \DIRECTORY_SEPARATOR) {
+                throw new \LogicException('Resolving commands is not supported on Windows.');
+            }
+
+            if (!class_exists(Process::class)) {
+                throw new \LogicException('Resolving commands requires the Symfony Process component.');
+            }
+
+            $process = method_exists(Process::class, 'fromShellCommandline') ? Process::fromShellCommandline('echo '.$matches[0]) : new Process('echo '.$matches[0]);
+
+            if (!method_exists(Process::class, 'fromShellCommandline') && method_exists(Process::class, 'inheritEnvironmentVariables')) {
+                // Symfony 3.4 does not inherit env vars by default:
+                $process->inheritEnvironmentVariables();
+            }
+
+            $env = [];
+            foreach ($this->values as $name => $value) {
+                if (isset($loadedVars[$name]) || (!isset($_ENV[$name]) && !(isset($_SERVER[$name]) && 0 !== strpos($name, 'HTTP_')))) {
+                    $env[$name] = $value;
+                }
+            }
+            $process->setEnv($env);
+
+            try {
+                $process->mustRun();
+            } catch (ProcessException $e) {
+                throw $this->createFormatException(sprintf('Issue expanding a command (%s)', $process->getErrorOutput()));
+            }
+
+            return preg_replace('/[\r\n]+$/', '', $process->getOutput());
+        }, $value);
+    }
+
+    private function resolveVariables(string $value, array $loadedVars): string
+    {
+        if (false === strpos($value, '$')) {
+            return $value;
+        }
+
+        $regex = '/
+            (?<!\\\\)
+            (?P<backslashes>\\\\*)             # escaped with a backslash?
+            \$
+            (?!\()                             # no opening parenthesis
+            (?P<opening_brace>\{)?             # optional brace
+            (?P<name>'.self::VARNAME_REGEX.')? # var name
+            (?P<default_value>:[-=][^\}]++)?   # optional default value
+            (?P<closing_brace>\})?             # optional closing brace
+        /x';
+
+        $value = preg_replace_callback($regex, function ($matches) use ($loadedVars) {
+            // odd number of backslashes means the $ character is escaped
+            if (1 === \strlen($matches['backslashes']) % 2) {
+                return substr($matches[0], 1);
+            }
+
+            // unescaped $ not followed by variable name
+            if (!isset($matches['name'])) {
+                return $matches[0];
+            }
+
+            if ('{' === $matches['opening_brace'] && !isset($matches['closing_brace'])) {
+                throw $this->createFormatException('Unclosed braces on variable expansion');
+            }
+
+            $name = $matches['name'];
+            if (isset($loadedVars[$name]) && isset($this->values[$name])) {
+                $value = $this->values[$name];
+            } elseif (isset($_ENV[$name])) {
+                $value = $_ENV[$name];
+            } elseif (isset($_SERVER[$name]) && 0 !== strpos($name, 'HTTP_')) {
+                $value = $_SERVER[$name];
+            } elseif (isset($this->values[$name])) {
+                $value = $this->values[$name];
+            } else {
+                $value = (string) getenv($name);
+            }
+
+            if ('' === $value && isset($matches['default_value']) && '' !== $matches['default_value']) {
+                $unsupportedChars = strpbrk($matches['default_value'], '\'"{$');
+                if (false !== $unsupportedChars) {
+                    throw $this->createFormatException(sprintf('Unsupported character "%s" found in the default value of variable "$%s".', $unsupportedChars[0], $name));
+                }
+
+                $value = substr($matches['default_value'], 2);
+
+                if ('=' === $matches['default_value'][1]) {
+                    $this->values[$name] = $value;
+                }
+            }
+
+            if (!$matches['opening_brace'] && isset($matches['closing_brace'])) {
+                $value .= '}';
+            }
+
+            return $matches['backslashes'].$value;
+        }, $value);
+
+        return $value;
+    }
+
+    private function moveCursor(string $text)
+    {
+        $this->cursor += \strlen($text);
+        $this->lineno += substr_count($text, "\n");
+    }
+
+    private function createFormatException(string $message): FormatException
+    {
+        return new FormatException($message, new FormatExceptionContext($this->data, $this->path, $this->lineno, $this->cursor));
+    }
+
+    private function doLoad(bool $overrideExistingVars, array $paths): void
+    {
+        foreach ($paths as $path) {
+            if (!is_readable($path) || is_dir($path)) {
+                throw new PathException($path);
+            }
+
+            $this->populate($this->parse(file_get_contents($path), $path), $overrideExistingVars);
+        }
+    }
+}

vendor/symfony/dotenv/Exception/ExceptionInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Dotenv\Exception;
+
+/**
+ * Interface for exceptions.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface ExceptionInterface extends \Throwable
+{
+}

vendor/symfony/dotenv/Exception/FormatException.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Dotenv\Exception;
+
+/**
+ * Thrown when a file has a syntax error.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+final class FormatException extends \LogicException implements ExceptionInterface
+{
+    private $context;
+
+    public function __construct(string $message, FormatExceptionContext $context, int $code = 0, \Throwable $previous = null)
+    {
+        $this->context = $context;
+
+        parent::__construct(sprintf("%s in \"%s\" at line %d.\n%s", $message, $context->getPath(), $context->getLineno(), $context->getDetails()), $code, $previous);
+    }
+
+    public function getContext(): FormatExceptionContext
+    {
+        return $this->context;
+    }
+}

vendor/symfony/dotenv/Exception/FormatExceptionContext.php

@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Dotenv\Exception;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+final class FormatExceptionContext
+{
+    private $data;
+    private $path;
+    private $lineno;
+    private $cursor;
+
+    public function __construct(string $data, string $path, int $lineno, int $cursor)
+    {
+        $this->data = $data;
+        $this->path = $path;
+        $this->lineno = $lineno;
+        $this->cursor = $cursor;
+    }
+
+    public function getPath(): string
+    {
+        return $this->path;
+    }
+
+    public function getLineno(): int
+    {
+        return $this->lineno;
+    }
+
+    public function getDetails(): string
+    {
+        $before = str_replace("\n", '\n', substr($this->data, max(0, $this->cursor - 20), min(20, $this->cursor)));
+        $after = str_replace("\n", '\n', substr($this->data, $this->cursor, 20));
+
+        return '...'.$before.$after."...\n".str_repeat(' ', \strlen($before) + 2).'^ line '.$this->lineno.' offset '.$this->cursor;
+    }
+}

vendor/symfony/dotenv/Exception/PathException.php

@@ -0,0 +1,25 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Dotenv\Exception;
+
+/**
+ * Thrown when a file does not exist or is not readable.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+final class PathException extends \RuntimeException implements ExceptionInterface
+{
+    public function __construct(string $path, int $code = 0, \Throwable $previous = null)
+    {
+        parent::__construct(sprintf('Unable to read the "%s" environment file.', $path), $code, $previous);
+    }
+}

vendor/symfony/dotenv/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016-2022 Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/symfony/dotenv/README.md

@@ -0,0 +1,36 @@
+Dotenv Component
+================
+
+Symfony Dotenv parses `.env` files to make environment variables stored in them
+accessible via `$_SERVER` or `$_ENV`.
+
+Getting Started
+---------------
+
+```
+$ composer require symfony/dotenv
+```
+
+```php
+use Symfony\Component\Dotenv\Dotenv;
+
+$dotenv = new Dotenv();
+$dotenv->load(__DIR__.'/.env');
+
+// you can also load several files
+$dotenv->load(__DIR__.'/.env', __DIR__.'/.env.dev');
+
+// overwrites existing env variables
+$dotenv->overload(__DIR__.'/.env');
+
+// loads .env, .env.local, and .env.$APP_ENV.local or .env.$APP_ENV
+$dotenv->loadEnv(__DIR__.'/.env');
+```
+
+Resources
+---------
+
+ * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+ * [Report issues](https://github.com/symfony/symfony/issues) and
+   [send Pull Requests](https://github.com/symfony/symfony/pulls)
+   in the [main Symfony repository](https://github.com/symfony/symfony)

vendor/symfony/dotenv/composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "symfony/dotenv",
+    "type": "library",
+    "description": "Registers environment variables from a .env file",
+    "keywords": ["environment", "env", "dotenv"],
+    "homepage": "https://symfony.com",
+    "license" : "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=7.2.5",
+        "symfony/deprecation-contracts": "^2.1|^3"
+    },
+    "require-dev": {
+        "symfony/console": "^4.4|^5.0|^6.0",
+        "symfony/process": "^4.4|^5.0|^6.0"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\Dotenv\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev"
+}