first commit

wp-content/plugins/brizy/vendor/symfony/deprecation-contracts/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020-2021 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.

wp-content/plugins/brizy/vendor/symfony/deprecation-contracts/function.php

@@ -0,0 +1,27 @@
+<?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.
+ */
+
+if (!function_exists('trigger_deprecation')) {
+    /**
+     * Triggers a silenced deprecation notice.
+     *
+     * @param string $package The name of the Composer package that is triggering the deprecation
+     * @param string $version The version of the package that introduced the deprecation
+     * @param string $message The message of the deprecation
+     * @param mixed  ...$args Values to insert in the message using printf() formatting
+     *
+     * @author Nicolas Grekas <p@tchwork.com>
+     */
+    function trigger_deprecation(string $package, string $version, string $message, ...$args): void
+    {
+        @trigger_error(($package || $version ? "Since $package $version: " : '').($args ? vsprintf($message, $args) : $message), \E_USER_DEPRECATED);
+    }
+}

wp-content/plugins/brizy/vendor/symfony/dotenv/Dotenv.php

@@ -0,0 +1,571 @@
+<?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']): void
+    {
+        $k = $envKey ?? $this->envKey;
+
+        if (is_file($path) || !is_file($p = "$path.dist")) {
+            $this->load($path);
+        } else {
+            $this->load($p);
+        }
+
+        if (null === $env = $_SERVER[$k] ?? $_ENV[$k] ?? null) {
+            $this->populate([$k => $env = $defaultEnv]);
+        }
+
+        if (!\in_array($env, $testEnvs, true) && is_file($p = "$path.local")) {
+            $this->load($p);
+            $env = $_SERVER[$k] ?? $_ENV[$k] ?? $env;
+        }
+
+        if ('local' === $env) {
+            return;
+        }
+
+        if (is_file($p = "$path.$env")) {
+            $this->load($p);
+        }
+
+        if (is_file($p = "$path.$env.local")) {
+            $this->load($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']): void
+    {
+        $p = $path.'.local.php';
+        $env = is_file($p) ? include $p : null;
+        $k = $this->envKey;
+
+        if (\is_array($env) && (!isset($env[$k]) || ($_SERVER[$k] ?? $_ENV[$k] ?? $env[$k]) === $env[$k])) {
+            $this->populate($env);
+        } else {
+            $this->loadEnv($path, $k, $defaultEnv, $testEnvs);
+        }
+
+        $_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_');
+            // don't check existence with getenv() because of thread safety issues
+            if (!isset($loadedVars[$name]) && (!$overrideExistingVars && (isset($_ENV[$name]) || (isset($_SERVER[$name]) && $notHttpName)))) {
+                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)
+     *
+     * @return array
+     *
+     * @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);
+        }
+    }
+}

wp-content/plugins/brizy/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
+{
+}

wp-content/plugins/brizy/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;
+    }
+}

wp-content/plugins/brizy/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;
+    }
+}

wp-content/plugins/brizy/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);
+    }
+}

wp-content/plugins/brizy/vendor/symfony/dotenv/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016-2021 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.

wp-content/plugins/brizy/vendor/symfony/dotenv/Tests/DotenvTest.php

@@ -0,0 +1,500 @@
+<?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\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Dotenv\Dotenv;
+use Symfony\Component\Dotenv\Exception\FormatException;
+use Symfony\Component\Dotenv\Exception\PathException;
+
+class DotenvTest extends TestCase
+{
+    /**
+     * @dataProvider getEnvDataWithFormatErrors
+     */
+    public function testParseWithFormatError($data, $error)
+    {
+        $dotenv = new Dotenv();
+
+        try {
+            $dotenv->parse($data);
+            $this->fail('Should throw a FormatException');
+        } catch (FormatException $e) {
+            $this->assertStringMatchesFormat($error, $e->getMessage());
+        }
+    }
+
+    public function getEnvDataWithFormatErrors()
+    {
+        $tests = [
+            ['FOO=BAR BAZ', "A value containing spaces must be surrounded by quotes in \".env\" at line 1.\n...FOO=BAR BAZ...\n             ^ line 1 offset 11"],
+            ['FOO BAR=BAR', "Whitespace characters are not supported after the variable name in \".env\" at line 1.\n...FOO BAR=BAR...\n     ^ line 1 offset 3"],
+            ['FOO', "Missing = in the environment variable declaration in \".env\" at line 1.\n...FOO...\n     ^ line 1 offset 3"],
+            ['FOO="foo', "Missing quote to end the value in \".env\" at line 1.\n...FOO=\"foo...\n          ^ line 1 offset 8"],
+            ['FOO=\'foo', "Missing quote to end the value in \".env\" at line 1.\n...FOO='foo...\n          ^ line 1 offset 8"],
+            ["FOO=\"foo\nBAR=\"bar\"", "Missing quote to end the value in \".env\" at line 1.\n...FOO=\"foo\\nBAR=\"bar\"...\n                     ^ line 1 offset 18"],
+            ['FOO=\'foo'."\n", "Missing quote to end the value in \".env\" at line 1.\n...FOO='foo\\n...\n            ^ line 1 offset 9"],
+            ['export FOO', "Unable to unset an environment variable in \".env\" at line 1.\n...export FOO...\n            ^ line 1 offset 10"],
+            ['FOO=${FOO', "Unclosed braces on variable expansion in \".env\" at line 1.\n...FOO=\${FOO...\n           ^ line 1 offset 9"],
+            ['FOO= BAR', "Whitespace are not supported before the value in \".env\" at line 1.\n...FOO= BAR...\n      ^ line 1 offset 4"],
+            ['Стасян', "Invalid character in variable name in \".env\" at line 1.\n...Стасян...\n  ^ line 1 offset 0"],
+            ['FOO!', "Missing = in the environment variable declaration in \".env\" at line 1.\n...FOO!...\n     ^ line 1 offset 3"],
+            ['FOO=$(echo foo', "Missing closing parenthesis. in \".env\" at line 1.\n...FOO=$(echo foo...\n                ^ line 1 offset 14"],
+            ['FOO=$(echo foo'."\n", "Missing closing parenthesis. in \".env\" at line 1.\n...FOO=$(echo foo\\n...\n                ^ line 1 offset 14"],
+            ["FOO=\nBAR=\${FOO:-\'a{a}a}", "Unsupported character \"'\" found in the default value of variable \"\$FOO\". in \".env\" at line 2.\n...\\nBAR=\${FOO:-\'a{a}a}...\n                       ^ line 2 offset 24"],
+            ["FOO=\nBAR=\${FOO:-a\$a}", "Unsupported character \"\$\" found in the default value of variable \"\$FOO\". in \".env\" at line 2.\n...FOO=\\nBAR=\${FOO:-a\$a}...\n                       ^ line 2 offset 20"],
+            ["FOO=\nBAR=\${FOO:-a\"a}", "Unclosed braces on variable expansion in \".env\" at line 2.\n...FOO=\\nBAR=\${FOO:-a\"a}...\n                    ^ line 2 offset 17"],
+        ];
+
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $tests[] = ['FOO=$((1dd2))', "Issue expanding a command (%s\n) in \".env\" at line 1.\n...FOO=$((1dd2))...\n               ^ line 1 offset 13"];
+        }
+
+        return $tests;
+    }
+
+    /**
+     * @dataProvider getEnvData
+     */
+    public function testParse($data, $expected)
+    {
+        $dotenv = new Dotenv();
+        $this->assertSame($expected, $dotenv->parse($data));
+    }
+
+    public function getEnvData()
+    {
+        putenv('LOCAL=local');
+        $_ENV['LOCAL'] = 'local';
+        $_ENV['REMOTE'] = 'remote';
+        $_SERVER['SERVERVAR'] = 'servervar';
+
+        $tests = [
+            // backslashes
+            ['FOO=foo\\\\bar', ['FOO' => 'foo\\bar']],
+            ["FOO='foo\\\\bar'", ['FOO' => 'foo\\\\bar']],
+            ['FOO="foo\\\\bar"', ['FOO' => 'foo\\bar']],
+
+            // escaped backslash in front of variable
+            ["BAR=bar\nFOO=foo\\\\\$BAR", ['BAR' => 'bar', 'FOO' => 'foo\\bar']],
+            ["BAR=bar\nFOO='foo\\\\\$BAR'", ['BAR' => 'bar', 'FOO' => 'foo\\\\$BAR']],
+            ["BAR=bar\nFOO=\"foo\\\\\$BAR\"", ['BAR' => 'bar', 'FOO' => 'foo\\bar']],
+
+            ['FOO=foo\\\\\\$BAR', ['FOO' => 'foo\\$BAR']],
+            ['FOO=\'foo\\\\\\$BAR\'', ['FOO' => 'foo\\\\\\$BAR']],
+            ['FOO="foo\\\\\\$BAR"', ['FOO' => 'foo\\$BAR']],
+
+            // spaces
+            ['FOO=bar', ['FOO' => 'bar']],
+            [' FOO=bar ', ['FOO' => 'bar']],
+            ['FOO=', ['FOO' => '']],
+            ["FOO=\n\n\nBAR=bar", ['FOO' => '', 'BAR' => 'bar']],
+            ['FOO=  ', ['FOO' => '']],
+            ["FOO=\nBAR=bar", ['FOO' => '', 'BAR' => 'bar']],
+
+            // newlines
+            ["\n\nFOO=bar\r\n\n", ['FOO' => 'bar']],
+            ["FOO=bar\r\nBAR=foo", ['FOO' => 'bar', 'BAR' => 'foo']],
+            ["FOO=bar\rBAR=foo", ['FOO' => 'bar', 'BAR' => 'foo']],
+            ["FOO=bar\nBAR=foo", ['FOO' => 'bar', 'BAR' => 'foo']],
+
+            // quotes
+            ["FOO=\"bar\"\n", ['FOO' => 'bar']],
+            ["FOO=\"bar'foo\"\n", ['FOO' => 'bar\'foo']],
+            ["FOO='bar'\n", ['FOO' => 'bar']],
+            ["FOO='bar\"foo'\n", ['FOO' => 'bar"foo']],
+            ["FOO=\"bar\\\"foo\"\n", ['FOO' => 'bar"foo']],
+            ['FOO="bar\nfoo"', ['FOO' => "bar\nfoo"]],
+            ['FOO="bar\rfoo"', ['FOO' => "bar\rfoo"]],
+            ['FOO=\'bar\nfoo\'', ['FOO' => 'bar\nfoo']],
+            ['FOO=\'bar\rfoo\'', ['FOO' => 'bar\rfoo']],
+            ["FOO='bar\nfoo'", ['FOO' => "bar\nfoo"]],
+            ['FOO=" FOO "', ['FOO' => ' FOO ']],
+            ['FOO="  "', ['FOO' => '  ']],
+            ['PATH="c:\\\\"', ['PATH' => 'c:\\']],
+            ["FOO=\"bar\nfoo\"", ['FOO' => "bar\nfoo"]],
+            ['FOO=BAR\\"', ['FOO' => 'BAR"']],
+            ["FOO=BAR\\'BAZ", ['FOO' => "BAR'BAZ"]],
+            ['FOO=\\"BAR', ['FOO' => '"BAR']],
+
+            // concatenated values
+            ["FOO='bar''foo'\n", ['FOO' => 'barfoo']],
+            ["FOO='bar '' baz'", ['FOO' => 'bar  baz']],
+            ["FOO=bar\nBAR='baz'\"\$FOO\"", ['FOO' => 'bar', 'BAR' => 'bazbar']],
+            ["FOO='bar '\\'' baz'", ['FOO' => "bar ' baz"]],
+
+            // comments
+            ["#FOO=bar\nBAR=foo", ['BAR' => 'foo']],
+            ["#FOO=bar # Comment\nBAR=foo", ['BAR' => 'foo']],
+            ["FOO='bar foo' # Comment", ['FOO' => 'bar foo']],
+            ["FOO='bar#foo' # Comment", ['FOO' => 'bar#foo']],
+            ["# Comment\r\nFOO=bar\n# Comment\nBAR=foo", ['FOO' => 'bar', 'BAR' => 'foo']],
+            ["FOO=bar # Another comment\nBAR=foo", ['FOO' => 'bar', 'BAR' => 'foo']],
+            ["FOO=\n\n# comment\nBAR=bar", ['FOO' => '', 'BAR' => 'bar']],
+            ['FOO=NOT#COMMENT', ['FOO' => 'NOT#COMMENT']],
+            ['FOO=  # Comment', ['FOO' => '']],
+
+            // edge cases (no conversions, only strings as values)
+            ['FOO=0', ['FOO' => '0']],
+            ['FOO=false', ['FOO' => 'false']],
+            ['FOO=null', ['FOO' => 'null']],
+
+            // export
+            ['export FOO=bar', ['FOO' => 'bar']],
+            ['  export   FOO=bar', ['FOO' => 'bar']],
+
+            // variable expansion
+            ["FOO=BAR\nBAR=\$FOO", ['FOO' => 'BAR', 'BAR' => 'BAR']],
+            ["FOO=BAR\nBAR=\"\$FOO\"", ['FOO' => 'BAR', 'BAR' => 'BAR']],
+            ["FOO=BAR\nBAR='\$FOO'", ['FOO' => 'BAR', 'BAR' => '$FOO']],
+            ["FOO_BAR9=BAR\nBAR=\$FOO_BAR9", ['FOO_BAR9' => 'BAR', 'BAR' => 'BAR']],
+            ["FOO=BAR\nBAR=\${FOO}Z", ['FOO' => 'BAR', 'BAR' => 'BARZ']],
+            ["FOO=BAR\nBAR=\$FOO}", ['FOO' => 'BAR', 'BAR' => 'BAR}']],
+            ["FOO=BAR\nBAR=\\\$FOO", ['FOO' => 'BAR', 'BAR' => '$FOO']],
+            ['FOO=" \\$ "', ['FOO' => ' $ ']],
+            ['FOO=" $ "', ['FOO' => ' $ ']],
+            ['BAR=$LOCAL', ['BAR' => 'local']],
+            ['BAR=$REMOTE', ['BAR' => 'remote']],
+            ['BAR=$SERVERVAR', ['BAR' => 'servervar']],
+            ['FOO=$NOTDEFINED', ['FOO' => '']],
+            ["FOO=BAR\nBAR=\${FOO:-TEST}", ['FOO' => 'BAR', 'BAR' => 'BAR']],
+            ["FOO=BAR\nBAR=\${NOTDEFINED:-TEST}", ['FOO' => 'BAR', 'BAR' => 'TEST']],
+            ["FOO=\nBAR=\${FOO:-TEST}", ['FOO' => '', 'BAR' => 'TEST']],
+            ["FOO=\nBAR=\$FOO:-TEST}", ['FOO' => '', 'BAR' => 'TEST}']],
+            ["FOO=BAR\nBAR=\${FOO:=TEST}", ['FOO' => 'BAR', 'BAR' => 'BAR']],
+            ["FOO=BAR\nBAR=\${NOTDEFINED:=TEST}", ['FOO' => 'BAR', 'NOTDEFINED' => 'TEST', 'BAR' => 'TEST']],
+            ["FOO=\nBAR=\${FOO:=TEST}", ['FOO' => 'TEST', 'BAR' => 'TEST']],
+            ["FOO=\nBAR=\$FOO:=TEST}", ['FOO' => 'TEST', 'BAR' => 'TEST}']],
+            ["FOO=foo\nFOOBAR=\${FOO}\${BAR}", ['FOO' => 'foo', 'FOOBAR' => 'foo']],
+        ];
+
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $tests = array_merge($tests, [
+                // command expansion
+                ['FOO=$(echo foo)', ['FOO' => 'foo']],
+                ['FOO=$((1+2))', ['FOO' => '3']],
+                ['FOO=FOO$((1+2))BAR', ['FOO' => 'FOO3BAR']],
+                ['FOO=$(echo "$(echo "$(echo "$(echo foo)")")")', ['FOO' => 'foo']],
+                ["FOO=$(echo \"Quotes won't be a problem\")", ['FOO' => 'Quotes won\'t be a problem']],
+                ["FOO=bar\nBAR=$(echo \"FOO is \$FOO\")", ['FOO' => 'bar', 'BAR' => 'FOO is bar']],
+            ]);
+        }
+
+        return $tests;
+    }
+
+    public function testLoad()
+    {
+        unset($_ENV['FOO']);
+        unset($_ENV['BAR']);
+        unset($_SERVER['FOO']);
+        unset($_SERVER['BAR']);
+        putenv('FOO');
+        putenv('BAR');
+
+        @mkdir($tmpdir = sys_get_temp_dir().'/dotenv');
+
+        $path1 = tempnam($tmpdir, 'sf-');
+        $path2 = tempnam($tmpdir, 'sf-');
+
+        file_put_contents($path1, 'FOO=BAR');
+        file_put_contents($path2, 'BAR=BAZ');
+
+        (new Dotenv())->usePutenv()->load($path1, $path2);
+
+        $foo = getenv('FOO');
+        $bar = getenv('BAR');
+
+        putenv('FOO');
+        putenv('BAR');
+        unlink($path1);
+        unlink($path2);
+        rmdir($tmpdir);
+
+        $this->assertSame('BAR', $foo);
+        $this->assertSame('BAZ', $bar);
+    }
+
+    public function testLoadEnv()
+    {
+        unset($_ENV['FOO']);
+        unset($_ENV['BAR']);
+        unset($_SERVER['FOO']);
+        unset($_SERVER['BAR']);
+        putenv('FOO');
+        putenv('BAR');
+
+        @mkdir($tmpdir = sys_get_temp_dir().'/dotenv');
+
+        $path = tempnam($tmpdir, 'sf-');
+
+        // .env
+
+        file_put_contents($path, 'FOO=BAR');
+        (new Dotenv())->usePutenv()->loadEnv($path, 'TEST_APP_ENV');
+        $this->assertSame('BAR', getenv('FOO'));
+        $this->assertSame('dev', getenv('TEST_APP_ENV'));
+
+        // .env.local
+
+        $_SERVER['TEST_APP_ENV'] = 'local';
+        file_put_contents("$path.local", 'FOO=localBAR');
+        (new Dotenv())->usePutenv()->loadEnv($path, 'TEST_APP_ENV');
+        $this->assertSame('localBAR', getenv('FOO'));
+
+        // special case for test
+
+        $_SERVER['TEST_APP_ENV'] = 'test';
+        (new Dotenv())->usePutenv()->loadEnv($path, 'TEST_APP_ENV');
+        $this->assertSame('BAR', getenv('FOO'));
+
+        // .env.dev
+
+        unset($_SERVER['TEST_APP_ENV']);
+        file_put_contents("$path.dev", 'FOO=devBAR');
+        (new Dotenv())->usePutenv()->loadEnv($path, 'TEST_APP_ENV');
+        $this->assertSame('devBAR', getenv('FOO'));
+
+        // .env.dev.local
+
+        file_put_contents("$path.dev.local", 'FOO=devlocalBAR');
+        (new Dotenv())->usePutenv()->loadEnv($path, 'TEST_APP_ENV');
+        $this->assertSame('devlocalBAR', getenv('FOO'));
+
+        // .env.dist
+
+        unlink($path);
+        file_put_contents("$path.dist", 'BAR=distBAR');
+        (new Dotenv())->usePutenv()->loadEnv($path, 'TEST_APP_ENV');
+        $this->assertSame('distBAR', getenv('BAR'));
+
+        putenv('FOO');
+        putenv('BAR');
+        unlink("$path.dist");
+        unlink("$path.local");
+        unlink("$path.dev");
+        unlink("$path.dev.local");
+        rmdir($tmpdir);
+    }
+
+    public function testOverload()
+    {
+        unset($_ENV['FOO']);
+        unset($_ENV['BAR']);
+        unset($_SERVER['FOO']);
+        unset($_SERVER['BAR']);
+
+        putenv('FOO=initial_foo_value');
+        putenv('BAR=initial_bar_value');
+        $_ENV['FOO'] = 'initial_foo_value';
+        $_ENV['BAR'] = 'initial_bar_value';
+
+        @mkdir($tmpdir = sys_get_temp_dir().'/dotenv');
+
+        $path1 = tempnam($tmpdir, 'sf-');
+        $path2 = tempnam($tmpdir, 'sf-');
+
+        file_put_contents($path1, 'FOO=BAR');
+        file_put_contents($path2, 'BAR=BAZ');
+
+        (new Dotenv())->usePutenv()->overload($path1, $path2);
+
+        $foo = getenv('FOO');
+        $bar = getenv('BAR');
+
+        putenv('FOO');
+        putenv('BAR');
+        unlink($path1);
+        unlink($path2);
+        rmdir($tmpdir);
+
+        $this->assertSame('BAR', $foo);
+        $this->assertSame('BAZ', $bar);
+    }
+
+    public function testLoadDirectory()
+    {
+        $this->expectException(PathException::class);
+        $dotenv = new Dotenv();
+        $dotenv->load(__DIR__);
+    }
+
+    public function testServerSuperglobalIsNotOverridden()
+    {
+        $originalValue = $_SERVER['argc'];
+
+        $dotenv = new Dotenv();
+        $dotenv->populate(['argc' => 'new_value']);
+
+        $this->assertSame($originalValue, $_SERVER['argc']);
+    }
+
+    public function testEnvVarIsNotOverridden()
+    {
+        putenv('TEST_ENV_VAR=original_value');
+        $_SERVER['TEST_ENV_VAR'] = 'original_value';
+
+        $dotenv = (new Dotenv())->usePutenv();
+        $dotenv->populate(['TEST_ENV_VAR' => 'new_value']);
+
+        $this->assertSame('original_value', getenv('TEST_ENV_VAR'));
+    }
+
+    public function testHttpVarIsPartiallyOverridden()
+    {
+        $_SERVER['HTTP_TEST_ENV_VAR'] = 'http_value';
+
+        $dotenv = (new Dotenv())->usePutenv();
+        $dotenv->populate(['HTTP_TEST_ENV_VAR' => 'env_value']);
+
+        $this->assertSame('env_value', getenv('HTTP_TEST_ENV_VAR'));
+        $this->assertSame('env_value', $_ENV['HTTP_TEST_ENV_VAR']);
+        $this->assertSame('http_value', $_SERVER['HTTP_TEST_ENV_VAR']);
+    }
+
+    public function testEnvVarIsOverriden()
+    {
+        putenv('TEST_ENV_VAR_OVERRIDEN=original_value');
+
+        $dotenv = (new Dotenv())->usePutenv();
+        $dotenv->populate(['TEST_ENV_VAR_OVERRIDEN' => 'new_value'], true);
+
+        $this->assertSame('new_value', getenv('TEST_ENV_VAR_OVERRIDEN'));
+        $this->assertSame('new_value', $_ENV['TEST_ENV_VAR_OVERRIDEN']);
+        $this->assertSame('new_value', $_SERVER['TEST_ENV_VAR_OVERRIDEN']);
+    }
+
+    public function testMemorizingLoadedVarsNamesInSpecialVar()
+    {
+        // Special variable not exists
+        unset($_ENV['SYMFONY_DOTENV_VARS']);
+        unset($_SERVER['SYMFONY_DOTENV_VARS']);
+        putenv('SYMFONY_DOTENV_VARS');
+
+        unset($_ENV['APP_DEBUG']);
+        unset($_SERVER['APP_DEBUG']);
+        putenv('APP_DEBUG');
+        unset($_ENV['DATABASE_URL']);
+        unset($_SERVER['DATABASE_URL']);
+        putenv('DATABASE_URL');
+
+        $dotenv = (new Dotenv())->usePutenv();
+        $dotenv->populate(['APP_DEBUG' => '1', 'DATABASE_URL' => 'mysql://root@localhost/db']);
+
+        $this->assertSame('APP_DEBUG,DATABASE_URL', getenv('SYMFONY_DOTENV_VARS'));
+
+        // Special variable has a value
+        $_ENV['SYMFONY_DOTENV_VARS'] = 'APP_ENV';
+        $_SERVER['SYMFONY_DOTENV_VARS'] = 'APP_ENV';
+        putenv('SYMFONY_DOTENV_VARS=APP_ENV');
+
+        $_ENV['APP_DEBUG'] = '1';
+        $_SERVER['APP_DEBUG'] = '1';
+        putenv('APP_DEBUG=1');
+        unset($_ENV['DATABASE_URL']);
+        unset($_SERVER['DATABASE_URL']);
+        putenv('DATABASE_URL');
+
+        $dotenv = (new Dotenv())->usePutenv();
+        $dotenv->populate(['APP_DEBUG' => '0', 'DATABASE_URL' => 'mysql://root@localhost/db']);
+        $dotenv->populate(['DATABASE_URL' => 'sqlite:///somedb.sqlite']);
+
+        $this->assertSame('APP_ENV,DATABASE_URL', getenv('SYMFONY_DOTENV_VARS'));
+    }
+
+    public function testOverridingEnvVarsWithNamesMemorizedInSpecialVar()
+    {
+        putenv('SYMFONY_DOTENV_VARS='.$_SERVER['SYMFONY_DOTENV_VARS'] = 'FOO,BAR,BAZ');
+
+        putenv('FOO=foo');
+        putenv('BAR=bar');
+        putenv('BAZ=baz');
+        putenv('DOCUMENT_ROOT=/var/www');
+
+        $dotenv = (new Dotenv())->usePutenv();
+        $dotenv->populate(['FOO' => 'foo1', 'BAR' => 'bar1', 'BAZ' => 'baz1', 'DOCUMENT_ROOT' => '/boot']);
+
+        $this->assertSame('foo1', getenv('FOO'));
+        $this->assertSame('bar1', getenv('BAR'));
+        $this->assertSame('baz1', getenv('BAZ'));
+        $this->assertSame('/var/www', getenv('DOCUMENT_ROOT'));
+    }
+
+    public function testGetVariablesValueFromEnvFirst()
+    {
+        $_ENV['APP_ENV'] = 'prod';
+        $dotenv = new Dotenv();
+
+        $test = "APP_ENV=dev\nTEST1=foo1_\${APP_ENV}";
+        $values = $dotenv->parse($test);
+        $this->assertSame('foo1_prod', $values['TEST1']);
+
+        if ('\\' !== \DIRECTORY_SEPARATOR) {
+            $test = "APP_ENV=dev\nTEST2=foo2_\$(php -r 'echo \$_SERVER[\"APP_ENV\"];')";
+            $values = $dotenv->parse($test);
+            $this->assertSame('foo2_prod', $values['TEST2']);
+        }
+    }
+
+    public function testGetVariablesValueFromGetenv()
+    {
+        putenv('Foo=Bar');
+
+        $dotenv = new Dotenv();
+
+        try {
+            $values = $dotenv->parse('Foo=${Foo}');
+            $this->assertSame('Bar', $values['Foo']);
+        } finally {
+            putenv('Foo');
+        }
+    }
+
+    public function testNoDeprecationWarning()
+    {
+        $dotenv = new Dotenv();
+        $this->assertInstanceOf(Dotenv::class, $dotenv);
+    }
+
+    public function testDoNotUsePutenv()
+    {
+        $dotenv = new Dotenv();
+        $dotenv->populate(['TEST_USE_PUTENV' => 'no']);
+
+        $this->assertSame('no', $_SERVER['TEST_USE_PUTENV']);
+        $this->assertSame('no', $_ENV['TEST_USE_PUTENV']);
+        $this->assertFalse(getenv('TEST_USE_PUTENV'));
+    }
+
+    public function testBootEnv()
+    {
+        @mkdir($tmpdir = sys_get_temp_dir().'/dotenv');
+        $path = tempnam($tmpdir, 'sf-');
+
+        file_put_contents($path, 'FOO=BAR');
+        (new Dotenv('TEST_APP_ENV', 'TEST_APP_DEBUG'))->bootEnv($path);
+
+        $this->assertSame('BAR', $_SERVER['FOO']);
+
+        unset($_SERVER['FOO'], $_ENV['FOO']);
+        unlink($path);
+
+        file_put_contents($path.'.local.php', '<?php return ["TEST_APP_ENV" => "dev", "FOO" => "BAR"];');
+        (new Dotenv('TEST_APP_ENV', 'TEST_APP_DEBUG'))->bootEnv($path);
+        $this->assertSame('BAR', $_SERVER['FOO']);
+        $this->assertSame('1', $_SERVER['TEST_APP_DEBUG']);
+
+        unset($_SERVER['FOO'], $_ENV['FOO']);
+        unlink($path.'.local.php');
+        rmdir($tmpdir);
+    }
+}

wp-content/plugins/brizy/vendor/symfony/polyfill-ctype/Ctype.php

@@ -0,0 +1,227 @@
+<?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\Polyfill\Ctype;
+
+/**
+ * Ctype implementation through regex.
+ *
+ * @internal
+ *
+ * @author Gert de Pagter <BackEndTea@gmail.com>
+ */
+final class Ctype
+{
+    /**
+     * Returns TRUE if every character in text is either a letter or a digit, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-alnum
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_alnum($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Za-z0-9]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a letter, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-alpha
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_alpha($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Za-z]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a control character from the current locale, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-cntrl
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_cntrl($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^\x00-\x1f\x7f]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in the string text is a decimal digit, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-digit
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_digit($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^0-9]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is printable and actually creates visible output (no white space), FALSE otherwise.
+     *
+     * @see https://php.net/ctype-graph
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_graph($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^!-~]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a lowercase letter.
+     *
+     * @see https://php.net/ctype-lower
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_lower($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^a-z]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text will actually create output (including blanks). Returns FALSE if text contains control characters or characters that do not have any output or control function at all.
+     *
+     * @see https://php.net/ctype-print
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_print($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^ -~]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is printable, but neither letter, digit or blank, FALSE otherwise.
+     *
+     * @see https://php.net/ctype-punct
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_punct($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^!-\/\:-@\[-`\{-~]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text creates some sort of white space, FALSE otherwise. Besides the blank character this also includes tab, vertical tab, line feed, carriage return and form feed characters.
+     *
+     * @see https://php.net/ctype-space
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_space($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^\s]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is an uppercase letter.
+     *
+     * @see https://php.net/ctype-upper
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_upper($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Z]/', $text);
+    }
+
+    /**
+     * Returns TRUE if every character in text is a hexadecimal 'digit', that is a decimal digit or a character from [A-Fa-f] , FALSE otherwise.
+     *
+     * @see https://php.net/ctype-xdigit
+     *
+     * @param string|int $text
+     *
+     * @return bool
+     */
+    public static function ctype_xdigit($text)
+    {
+        $text = self::convert_int_to_char_for_ctype($text);
+
+        return \is_string($text) && '' !== $text && !preg_match('/[^A-Fa-f0-9]/', $text);
+    }
+
+    /**
+     * Converts integers to their char versions according to normal ctype behaviour, if needed.
+     *
+     * If an integer between -128 and 255 inclusive is provided,
+     * it is interpreted as the ASCII value of a single character
+     * (negative values have 256 added in order to allow characters in the Extended ASCII range).
+     * Any other integer is interpreted as a string containing the decimal digits of the integer.
+     *
+     * @param string|int $int
+     *
+     * @return mixed
+     */
+    private static function convert_int_to_char_for_ctype($int)
+    {
+        if (!\is_int($int)) {
+            return $int;
+        }
+
+        if ($int < -128 || $int > 255) {
+            return (string) $int;
+        }
+
+        if ($int < 0) {
+            $int += 256;
+        }
+
+        return \chr($int);
+    }
+}

wp-content/plugins/brizy/vendor/symfony/polyfill-ctype/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018-2019 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.

wp-content/plugins/brizy/vendor/symfony/polyfill-ctype/bootstrap.php

@@ -0,0 +1,50 @@
+<?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.
+ */
+
+use Symfony\Polyfill\Ctype as p;
+
+if (\PHP_VERSION_ID >= 80000) {
+    return require __DIR__.'/bootstrap80.php';
+}
+
+if (!function_exists('ctype_alnum')) {
+    function ctype_alnum($text) { return p\Ctype::ctype_alnum($text); }
+}
+if (!function_exists('ctype_alpha')) {
+    function ctype_alpha($text) { return p\Ctype::ctype_alpha($text); }
+}
+if (!function_exists('ctype_cntrl')) {
+    function ctype_cntrl($text) { return p\Ctype::ctype_cntrl($text); }
+}
+if (!function_exists('ctype_digit')) {
+    function ctype_digit($text) { return p\Ctype::ctype_digit($text); }
+}
+if (!function_exists('ctype_graph')) {
+    function ctype_graph($text) { return p\Ctype::ctype_graph($text); }
+}
+if (!function_exists('ctype_lower')) {
+    function ctype_lower($text) { return p\Ctype::ctype_lower($text); }
+}
+if (!function_exists('ctype_print')) {
+    function ctype_print($text) { return p\Ctype::ctype_print($text); }
+}
+if (!function_exists('ctype_punct')) {
+    function ctype_punct($text) { return p\Ctype::ctype_punct($text); }
+}
+if (!function_exists('ctype_space')) {
+    function ctype_space($text) { return p\Ctype::ctype_space($text); }
+}
+if (!function_exists('ctype_upper')) {
+    function ctype_upper($text) { return p\Ctype::ctype_upper($text); }
+}
+if (!function_exists('ctype_xdigit')) {
+    function ctype_xdigit($text) { return p\Ctype::ctype_xdigit($text); }
+}

wp-content/plugins/brizy/vendor/symfony/polyfill-ctype/bootstrap80.php

@@ -0,0 +1,46 @@
+<?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.
+ */
+
+use Symfony\Polyfill\Ctype as p;
+
+if (!function_exists('ctype_alnum')) {
+    function ctype_alnum(mixed $text): bool { return p\Ctype::ctype_alnum($text); }
+}
+if (!function_exists('ctype_alpha')) {
+    function ctype_alpha(mixed $text): bool { return p\Ctype::ctype_alpha($text); }
+}
+if (!function_exists('ctype_cntrl')) {
+    function ctype_cntrl(mixed $text): bool { return p\Ctype::ctype_cntrl($text); }
+}
+if (!function_exists('ctype_digit')) {
+    function ctype_digit(mixed $text): bool { return p\Ctype::ctype_digit($text); }
+}
+if (!function_exists('ctype_graph')) {
+    function ctype_graph(mixed $text): bool { return p\Ctype::ctype_graph($text); }
+}
+if (!function_exists('ctype_lower')) {
+    function ctype_lower(mixed $text): bool { return p\Ctype::ctype_lower($text); }
+}
+if (!function_exists('ctype_print')) {
+    function ctype_print(mixed $text): bool { return p\Ctype::ctype_print($text); }
+}
+if (!function_exists('ctype_punct')) {
+    function ctype_punct(mixed $text): bool { return p\Ctype::ctype_punct($text); }
+}
+if (!function_exists('ctype_space')) {
+    function ctype_space(mixed $text): bool { return p\Ctype::ctype_space($text); }
+}
+if (!function_exists('ctype_upper')) {
+    function ctype_upper(mixed $text): bool { return p\Ctype::ctype_upper($text); }
+}
+if (!function_exists('ctype_xdigit')) {
+    function ctype_xdigit(mixed $text): bool { return p\Ctype::ctype_xdigit($text); }
+}