init web ems all

phpMyAdmin/vendor/symfony/expression-language/CHANGELOG.md

@@ -0,0 +1,12 @@
+CHANGELOG
+=========
+
+2.6.0
+-----
+
+ * Added ExpressionFunction and ExpressionFunctionProviderInterface
+
+2.4.0
+-----
+
+ * added the component

phpMyAdmin/vendor/symfony/expression-language/Compiler.php

@@ -0,0 +1,146 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Compiles a node to PHP code.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Compiler
+{
+    private $source;
+    private $functions;
+
+    public function __construct(array $functions)
+    {
+        $this->functions = $functions;
+    }
+
+    public function getFunction($name)
+    {
+        return $this->functions[$name];
+    }
+
+    /**
+     * Gets the current PHP code after compilation.
+     *
+     * @return string The PHP code
+     */
+    public function getSource()
+    {
+        return $this->source;
+    }
+
+    public function reset()
+    {
+        $this->source = '';
+
+        return $this;
+    }
+
+    /**
+     * Compiles a node.
+     *
+     * @return $this
+     */
+    public function compile(Node\Node $node)
+    {
+        $node->compile($this);
+
+        return $this;
+    }
+
+    public function subcompile(Node\Node $node)
+    {
+        $current = $this->source;
+        $this->source = '';
+
+        $node->compile($this);
+
+        $source = $this->source;
+        $this->source = $current;
+
+        return $source;
+    }
+
+    /**
+     * Adds a raw string to the compiled code.
+     *
+     * @param string $string The string
+     *
+     * @return $this
+     */
+    public function raw($string)
+    {
+        $this->source .= $string;
+
+        return $this;
+    }
+
+    /**
+     * Adds a quoted string to the compiled code.
+     *
+     * @param string $value The string
+     *
+     * @return $this
+     */
+    public function string($value)
+    {
+        $this->source .= sprintf('"%s"', addcslashes($value, "\0\t\"\$\\"));
+
+        return $this;
+    }
+
+    /**
+     * Returns a PHP representation of a given value.
+     *
+     * @param mixed $value The value to convert
+     *
+     * @return $this
+     */
+    public function repr($value)
+    {
+        if (\is_int($value) || \is_float($value)) {
+            if (false !== $locale = setlocale(LC_NUMERIC, 0)) {
+                setlocale(LC_NUMERIC, 'C');
+            }
+
+            $this->raw($value);
+
+            if (false !== $locale) {
+                setlocale(LC_NUMERIC, $locale);
+            }
+        } elseif (null === $value) {
+            $this->raw('null');
+        } elseif (\is_bool($value)) {
+            $this->raw($value ? 'true' : 'false');
+        } elseif (\is_array($value)) {
+            $this->raw('array(');
+            $first = true;
+            foreach ($value as $key => $value) {
+                if (!$first) {
+                    $this->raw(', ');
+                }
+                $first = false;
+                $this->repr($key);
+                $this->raw(' => ');
+                $this->repr($value);
+            }
+            $this->raw(')');
+        } else {
+            $this->string($value);
+        }
+
+        return $this;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Expression.php

@@ -0,0 +1,40 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Represents an expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Expression
+{
+    protected $expression;
+
+    /**
+     * @param string $expression An expression
+     */
+    public function __construct($expression)
+    {
+        $this->expression = (string) $expression;
+    }
+
+    /**
+     * Gets the expression.
+     *
+     * @return string The expression
+     */
+    public function __toString()
+    {
+        return $this->expression;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/ExpressionFunction.php

@@ -0,0 +1,63 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Represents a function that can be used in an expression.
+ *
+ * A function is defined by two PHP callables. The callables are used
+ * by the language to compile and/or evaluate the function.
+ *
+ * The "compiler" function is used at compilation time and must return a
+ * PHP representation of the function call (it receives the function
+ * arguments as arguments).
+ *
+ * The "evaluator" function is used for expression evaluation and must return
+ * the value of the function call based on the values defined for the
+ * expression (it receives the values as a first argument and the function
+ * arguments as remaining arguments).
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ExpressionFunction
+{
+    private $name;
+    private $compiler;
+    private $evaluator;
+
+    /**
+     * @param string   $name      The function name
+     * @param callable $compiler  A callable able to compile the function
+     * @param callable $evaluator A callable able to evaluate the function
+     */
+    public function __construct($name, $compiler, $evaluator)
+    {
+        $this->name = $name;
+        $this->compiler = $compiler;
+        $this->evaluator = $evaluator;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function getCompiler()
+    {
+        return $this->compiler;
+    }
+
+    public function getEvaluator()
+    {
+        return $this->evaluator;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/ExpressionFunctionProviderInterface.php

@@ -0,0 +1,23 @@
+<?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\ExpressionLanguage;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+interface ExpressionFunctionProviderInterface
+{
+    /**
+     * @return ExpressionFunction[] An array of Function instances
+     */
+    public function getFunctions();
+}

phpMyAdmin/vendor/symfony/expression-language/ExpressionLanguage.php

@@ -0,0 +1,170 @@
+<?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\ExpressionLanguage;
+
+use Symfony\Component\ExpressionLanguage\ParserCache\ArrayParserCache;
+use Symfony\Component\ExpressionLanguage\ParserCache\ParserCacheInterface;
+
+/**
+ * Allows to compile and evaluate expressions written in your own DSL.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ExpressionLanguage
+{
+    private $cache;
+    private $lexer;
+    private $parser;
+    private $compiler;
+
+    protected $functions = array();
+
+    /**
+     * @param ParserCacheInterface                  $cache
+     * @param ExpressionFunctionProviderInterface[] $providers
+     */
+    public function __construct(ParserCacheInterface $cache = null, array $providers = array())
+    {
+        $this->cache = $cache ?: new ArrayParserCache();
+        $this->registerFunctions();
+        foreach ($providers as $provider) {
+            $this->registerProvider($provider);
+        }
+    }
+
+    /**
+     * Compiles an expression source code.
+     *
+     * @param Expression|string $expression The expression to compile
+     * @param array             $names      An array of valid names
+     *
+     * @return string The compiled PHP source code
+     */
+    public function compile($expression, $names = array())
+    {
+        return $this->getCompiler()->compile($this->parse($expression, $names)->getNodes())->getSource();
+    }
+
+    /**
+     * Evaluate an expression.
+     *
+     * @param Expression|string $expression The expression to compile
+     * @param array             $values     An array of values
+     *
+     * @return mixed The result of the evaluation of the expression
+     */
+    public function evaluate($expression, $values = array())
+    {
+        return $this->parse($expression, array_keys($values))->getNodes()->evaluate($this->functions, $values);
+    }
+
+    /**
+     * Parses an expression.
+     *
+     * @param Expression|string $expression The expression to parse
+     * @param array             $names      An array of valid names
+     *
+     * @return ParsedExpression A ParsedExpression instance
+     */
+    public function parse($expression, $names)
+    {
+        if ($expression instanceof ParsedExpression) {
+            return $expression;
+        }
+
+        asort($names);
+        $cacheKeyItems = array();
+
+        foreach ($names as $nameKey => $name) {
+            $cacheKeyItems[] = \is_int($nameKey) ? $name : $nameKey.':'.$name;
+        }
+
+        $key = $expression.'//'.implode('|', $cacheKeyItems);
+
+        if (null === $parsedExpression = $this->cache->fetch($key)) {
+            $nodes = $this->getParser()->parse($this->getLexer()->tokenize((string) $expression), $names);
+            $parsedExpression = new ParsedExpression((string) $expression, $nodes);
+
+            $this->cache->save($key, $parsedExpression);
+        }
+
+        return $parsedExpression;
+    }
+
+    /**
+     * Registers a function.
+     *
+     * @param string   $name      The function name
+     * @param callable $compiler  A callable able to compile the function
+     * @param callable $evaluator A callable able to evaluate the function
+     *
+     * @throws \LogicException when registering a function after calling evaluate(), compile() or parse()
+     *
+     * @see ExpressionFunction
+     */
+    public function register($name, $compiler, $evaluator)
+    {
+        if (null !== $this->parser) {
+            throw new \LogicException('Registering functions after calling evaluate(), compile() or parse() is not supported.');
+        }
+
+        $this->functions[$name] = array('compiler' => $compiler, 'evaluator' => $evaluator);
+    }
+
+    public function addFunction(ExpressionFunction $function)
+    {
+        $this->register($function->getName(), $function->getCompiler(), $function->getEvaluator());
+    }
+
+    public function registerProvider(ExpressionFunctionProviderInterface $provider)
+    {
+        foreach ($provider->getFunctions() as $function) {
+            $this->addFunction($function);
+        }
+    }
+
+    protected function registerFunctions()
+    {
+        $this->register('constant', function ($constant) {
+            return sprintf('constant(%s)', $constant);
+        }, function (array $values, $constant) {
+            return \constant($constant);
+        });
+    }
+
+    private function getLexer()
+    {
+        if (null === $this->lexer) {
+            $this->lexer = new Lexer();
+        }
+
+        return $this->lexer;
+    }
+
+    private function getParser()
+    {
+        if (null === $this->parser) {
+            $this->parser = new Parser($this->functions);
+        }
+
+        return $this->parser;
+    }
+
+    private function getCompiler()
+    {
+        if (null === $this->compiler) {
+            $this->compiler = new Compiler($this->functions);
+        }
+
+        return $this->compiler->reset();
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/LICENSE

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

phpMyAdmin/vendor/symfony/expression-language/Lexer.php

@@ -0,0 +1,103 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Lexes an expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Lexer
+{
+    /**
+     * Tokenizes an expression.
+     *
+     * @param string $expression The expression to tokenize
+     *
+     * @return TokenStream A token stream instance
+     *
+     * @throws SyntaxError
+     */
+    public function tokenize($expression)
+    {
+        $expression = str_replace(array("\r", "\n", "\t", "\v", "\f"), ' ', $expression);
+        $cursor = 0;
+        $tokens = array();
+        $brackets = array();
+        $end = \strlen($expression);
+
+        while ($cursor < $end) {
+            if (' ' == $expression[$cursor]) {
+                ++$cursor;
+
+                continue;
+            }
+
+            if (preg_match('/[0-9]+(?:\.[0-9]+)?/A', $expression, $match, 0, $cursor)) {
+                // numbers
+                $number = (float) $match[0];  // floats
+                if (preg_match('/^[0-9]+$/', $match[0]) && $number <= PHP_INT_MAX) {
+                    $number = (int) $match[0]; // integers lower than the maximum
+                }
+                $tokens[] = new Token(Token::NUMBER_TYPE, $number, $cursor + 1);
+                $cursor += \strlen($match[0]);
+            } elseif (false !== strpos('([{', $expression[$cursor])) {
+                // opening bracket
+                $brackets[] = array($expression[$cursor], $cursor);
+
+                $tokens[] = new Token(Token::PUNCTUATION_TYPE, $expression[$cursor], $cursor + 1);
+                ++$cursor;
+            } elseif (false !== strpos(')]}', $expression[$cursor])) {
+                // closing bracket
+                if (empty($brackets)) {
+                    throw new SyntaxError(sprintf('Unexpected "%s"', $expression[$cursor]), $cursor, $expression);
+                }
+
+                list($expect, $cur) = array_pop($brackets);
+                if ($expression[$cursor] != strtr($expect, '([{', ')]}')) {
+                    throw new SyntaxError(sprintf('Unclosed "%s"', $expect), $cur, $expression);
+                }
+
+                $tokens[] = new Token(Token::PUNCTUATION_TYPE, $expression[$cursor], $cursor + 1);
+                ++$cursor;
+            } elseif (preg_match('/"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As', $expression, $match, 0, $cursor)) {
+                // strings
+                $tokens[] = new Token(Token::STRING_TYPE, stripcslashes(substr($match[0], 1, -1)), $cursor + 1);
+                $cursor += \strlen($match[0]);
+            } elseif (preg_match('/not in(?=[\s(])|\!\=\=|not(?=[\s(])|and(?=[\s(])|\=\=\=|\>\=|or(?=[\s(])|\<\=|\*\*|\.\.|in(?=[\s(])|&&|\|\||matches|\=\=|\!\=|\*|~|%|\/|\>|\||\!|\^|&|\+|\<|\-/A', $expression, $match, 0, $cursor)) {
+                // operators
+                $tokens[] = new Token(Token::OPERATOR_TYPE, $match[0], $cursor + 1);
+                $cursor += \strlen($match[0]);
+            } elseif (false !== strpos('.,?:', $expression[$cursor])) {
+                // punctuation
+                $tokens[] = new Token(Token::PUNCTUATION_TYPE, $expression[$cursor], $cursor + 1);
+                ++$cursor;
+            } elseif (preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A', $expression, $match, 0, $cursor)) {
+                // names
+                $tokens[] = new Token(Token::NAME_TYPE, $match[0], $cursor + 1);
+                $cursor += \strlen($match[0]);
+            } else {
+                // unlexable
+                throw new SyntaxError(sprintf('Unexpected character "%s"', $expression[$cursor]), $cursor, $expression);
+            }
+        }
+
+        $tokens[] = new Token(Token::EOF_TYPE, null, $cursor + 1);
+
+        if (!empty($brackets)) {
+            list($expect, $cur) = array_pop($brackets);
+            throw new SyntaxError(sprintf('Unclosed "%s"', $expect), $cur, $expression);
+        }
+
+        return new TokenStream($tokens, $expression);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/ArgumentsNode.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.
+ */
+
+namespace Symfony\Component\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ArgumentsNode extends ArrayNode
+{
+    public function compile(Compiler $compiler)
+    {
+        $this->compileArguments($compiler, false);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/ArrayNode.php

@@ -0,0 +1,88 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ArrayNode extends Node
+{
+    protected $index;
+
+    public function __construct()
+    {
+        $this->index = -1;
+    }
+
+    public function addElement(Node $value, Node $key = null)
+    {
+        if (null === $key) {
+            $key = new ConstantNode(++$this->index);
+        }
+
+        array_push($this->nodes, $key, $value);
+    }
+
+    /**
+     * Compiles the node to PHP.
+     */
+    public function compile(Compiler $compiler)
+    {
+        $compiler->raw('array(');
+        $this->compileArguments($compiler);
+        $compiler->raw(')');
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $result = array();
+        foreach ($this->getKeyValuePairs() as $pair) {
+            $result[$pair['key']->evaluate($functions, $values)] = $pair['value']->evaluate($functions, $values);
+        }
+
+        return $result;
+    }
+
+    protected function getKeyValuePairs()
+    {
+        $pairs = array();
+        foreach (array_chunk($this->nodes, 2) as $pair) {
+            $pairs[] = array('key' => $pair[0], 'value' => $pair[1]);
+        }
+
+        return $pairs;
+    }
+
+    protected function compileArguments(Compiler $compiler, $withKeys = true)
+    {
+        $first = true;
+        foreach ($this->getKeyValuePairs() as $pair) {
+            if (!$first) {
+                $compiler->raw(', ');
+            }
+            $first = false;
+
+            if ($withKeys) {
+                $compiler
+                    ->compile($pair['key'])
+                    ->raw(' => ')
+                ;
+            }
+
+            $compiler->compile($pair['value']);
+        }
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/BinaryNode.php

@@ -0,0 +1,157 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class BinaryNode extends Node
+{
+    private static $operators = array(
+        '~' => '.',
+        'and' => '&&',
+        'or' => '||',
+    );
+
+    private static $functions = array(
+        '**' => 'pow',
+        '..' => 'range',
+        'in' => 'in_array',
+        'not in' => '!in_array',
+    );
+
+    public function __construct($operator, Node $left, Node $right)
+    {
+        parent::__construct(
+            array('left' => $left, 'right' => $right),
+            array('operator' => $operator)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $operator = $this->attributes['operator'];
+
+        if ('matches' == $operator) {
+            $compiler
+                ->raw('preg_match(')
+                ->compile($this->nodes['right'])
+                ->raw(', ')
+                ->compile($this->nodes['left'])
+                ->raw(')')
+            ;
+
+            return;
+        }
+
+        if (isset(self::$functions[$operator])) {
+            $compiler
+                ->raw(sprintf('%s(', self::$functions[$operator]))
+                ->compile($this->nodes['left'])
+                ->raw(', ')
+                ->compile($this->nodes['right'])
+                ->raw(')')
+            ;
+
+            return;
+        }
+
+        if (isset(self::$operators[$operator])) {
+            $operator = self::$operators[$operator];
+        }
+
+        $compiler
+            ->raw('(')
+            ->compile($this->nodes['left'])
+            ->raw(' ')
+            ->raw($operator)
+            ->raw(' ')
+            ->compile($this->nodes['right'])
+            ->raw(')')
+        ;
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $operator = $this->attributes['operator'];
+        $left = $this->nodes['left']->evaluate($functions, $values);
+
+        if (isset(self::$functions[$operator])) {
+            $right = $this->nodes['right']->evaluate($functions, $values);
+
+            if ('not in' === $operator) {
+                return !\in_array($left, $right);
+            }
+            $f = self::$functions[$operator];
+
+            return $f($left, $right);
+        }
+
+        switch ($operator) {
+            case 'or':
+            case '||':
+                return $left || $this->nodes['right']->evaluate($functions, $values);
+            case 'and':
+            case '&&':
+                return $left && $this->nodes['right']->evaluate($functions, $values);
+        }
+
+        $right = $this->nodes['right']->evaluate($functions, $values);
+
+        switch ($operator) {
+            case '|':
+                return $left | $right;
+            case '^':
+                return $left ^ $right;
+            case '&':
+                return $left & $right;
+            case '==':
+                return $left == $right;
+            case '===':
+                return $left === $right;
+            case '!=':
+                return $left != $right;
+            case '!==':
+                return $left !== $right;
+            case '<':
+                return $left < $right;
+            case '>':
+                return $left > $right;
+            case '>=':
+                return $left >= $right;
+            case '<=':
+                return $left <= $right;
+            case 'not in':
+                return !\in_array($left, $right);
+            case 'in':
+                return \in_array($left, $right);
+            case '+':
+                return $left + $right;
+            case '-':
+                return $left - $right;
+            case '~':
+                return $left.$right;
+            case '*':
+                return $left * $right;
+            case '/':
+                return $left / $right;
+            case '%':
+                return $left % $right;
+            case 'matches':
+                return preg_match($right, $left);
+        }
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/ConditionalNode.php

@@ -0,0 +1,51 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ConditionalNode extends Node
+{
+    public function __construct(Node $expr1, Node $expr2, Node $expr3)
+    {
+        parent::__construct(
+            array('expr1' => $expr1, 'expr2' => $expr2, 'expr3' => $expr3)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler
+            ->raw('((')
+            ->compile($this->nodes['expr1'])
+            ->raw(') ? (')
+            ->compile($this->nodes['expr2'])
+            ->raw(') : (')
+            ->compile($this->nodes['expr3'])
+            ->raw('))')
+        ;
+    }
+
+    public function evaluate($functions, $values)
+    {
+        if ($this->nodes['expr1']->evaluate($functions, $values)) {
+            return $this->nodes['expr2']->evaluate($functions, $values);
+        }
+
+        return $this->nodes['expr3']->evaluate($functions, $values);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/ConstantNode.php

@@ -0,0 +1,40 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class ConstantNode extends Node
+{
+    public function __construct($value)
+    {
+        parent::__construct(
+            array(),
+            array('value' => $value)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler->repr($this->attributes['value']);
+    }
+
+    public function evaluate($functions, $values)
+    {
+        return $this->attributes['value'];
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/FunctionNode.php

@@ -0,0 +1,52 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class FunctionNode extends Node
+{
+    public function __construct($name, Node $arguments)
+    {
+        parent::__construct(
+            array('arguments' => $arguments),
+            array('name' => $name)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $arguments = array();
+        foreach ($this->nodes['arguments']->nodes as $node) {
+            $arguments[] = $compiler->subcompile($node);
+        }
+
+        $function = $compiler->getFunction($this->attributes['name']);
+
+        $compiler->raw(\call_user_func_array($function['compiler'], $arguments));
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $arguments = array($values);
+        foreach ($this->nodes['arguments']->nodes as $node) {
+            $arguments[] = $node->evaluate($functions, $values);
+        }
+
+        return \call_user_func_array($functions[$this->attributes['name']]['evaluator'], $arguments);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/GetAttrNode.php

@@ -0,0 +1,100 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class GetAttrNode extends Node
+{
+    const PROPERTY_CALL = 1;
+    const METHOD_CALL = 2;
+    const ARRAY_CALL = 3;
+
+    public function __construct(Node $node, Node $attribute, ArrayNode $arguments, $type)
+    {
+        parent::__construct(
+            array('node' => $node, 'attribute' => $attribute, 'arguments' => $arguments),
+            array('type' => $type)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        switch ($this->attributes['type']) {
+            case self::PROPERTY_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw('->')
+                    ->raw($this->nodes['attribute']->attributes['value'])
+                ;
+                break;
+
+            case self::METHOD_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw('->')
+                    ->raw($this->nodes['attribute']->attributes['value'])
+                    ->raw('(')
+                    ->compile($this->nodes['arguments'])
+                    ->raw(')')
+                ;
+                break;
+
+            case self::ARRAY_CALL:
+                $compiler
+                    ->compile($this->nodes['node'])
+                    ->raw('[')
+                    ->compile($this->nodes['attribute'])->raw(']')
+                ;
+                break;
+        }
+    }
+
+    public function evaluate($functions, $values)
+    {
+        switch ($this->attributes['type']) {
+            case self::PROPERTY_CALL:
+                $obj = $this->nodes['node']->evaluate($functions, $values);
+                if (!\is_object($obj)) {
+                    throw new \RuntimeException('Unable to get a property on a non-object.');
+                }
+
+                $property = $this->nodes['attribute']->attributes['value'];
+
+                return $obj->$property;
+
+            case self::METHOD_CALL:
+                $obj = $this->nodes['node']->evaluate($functions, $values);
+                if (!\is_object($obj)) {
+                    throw new \RuntimeException('Unable to get a property on a non-object.');
+                }
+                if (!\is_callable($toCall = array($obj, $this->nodes['attribute']->attributes['value']))) {
+                    throw new \RuntimeException(sprintf('Unable to call method "%s" of object "%s".', $this->nodes['attribute']->attributes['value'], \get_class($obj)));
+                }
+
+                return \call_user_func_array($toCall, $this->nodes['arguments']->evaluate($functions, $values));
+
+            case self::ARRAY_CALL:
+                $array = $this->nodes['node']->evaluate($functions, $values);
+                if (!\is_array($array) && !$array instanceof \ArrayAccess) {
+                    throw new \RuntimeException('Unable to get an item on a non-array.');
+                }
+
+                return $array[$this->nodes['attribute']->evaluate($functions, $values)];
+        }
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/NameNode.php

@@ -0,0 +1,40 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class NameNode extends Node
+{
+    public function __construct($name)
+    {
+        parent::__construct(
+            array(),
+            array('name' => $name)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler->raw('$'.$this->attributes['name']);
+    }
+
+    public function evaluate($functions, $values)
+    {
+        return $values[$this->attributes['name']];
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/Node.php

@@ -0,0 +1,76 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * Represents a node in the AST.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Node
+{
+    public $nodes = array();
+    public $attributes = array();
+
+    /**
+     * @param array $nodes      An array of nodes
+     * @param array $attributes An array of attributes
+     */
+    public function __construct(array $nodes = array(), array $attributes = array())
+    {
+        $this->nodes = $nodes;
+        $this->attributes = $attributes;
+    }
+
+    public function __toString()
+    {
+        $attributes = array();
+        foreach ($this->attributes as $name => $value) {
+            $attributes[] = sprintf('%s: %s', $name, str_replace("\n", '', var_export($value, true)));
+        }
+
+        $repr = array(str_replace('Symfony\Component\ExpressionLanguage\Node\\', '', \get_class($this)).'('.implode(', ', $attributes));
+
+        if (\count($this->nodes)) {
+            foreach ($this->nodes as $node) {
+                foreach (explode("\n", (string) $node) as $line) {
+                    $repr[] = '    '.$line;
+                }
+            }
+
+            $repr[] = ')';
+        } else {
+            $repr[0] .= ')';
+        }
+
+        return implode("\n", $repr);
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        foreach ($this->nodes as $node) {
+            $node->compile($compiler);
+        }
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $results = array();
+        foreach ($this->nodes as $node) {
+            $results[] = $node->evaluate($functions, $values);
+        }
+
+        return $results;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Node/UnaryNode.php

@@ -0,0 +1,61 @@
+<?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\ExpressionLanguage\Node;
+
+use Symfony\Component\ExpressionLanguage\Compiler;
+
+/**
+ * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @internal
+ */
+class UnaryNode extends Node
+{
+    private static $operators = array(
+        '!' => '!',
+        'not' => '!',
+        '+' => '+',
+        '-' => '-',
+    );
+
+    public function __construct($operator, Node $node)
+    {
+        parent::__construct(
+            array('node' => $node),
+            array('operator' => $operator)
+        );
+    }
+
+    public function compile(Compiler $compiler)
+    {
+        $compiler
+            ->raw('(')
+            ->raw(self::$operators[$this->attributes['operator']])
+            ->compile($this->nodes['node'])
+            ->raw(')')
+        ;
+    }
+
+    public function evaluate($functions, $values)
+    {
+        $value = $this->nodes['node']->evaluate($functions, $values);
+        switch ($this->attributes['operator']) {
+            case 'not':
+            case '!':
+                return !$value;
+            case '-':
+                return -$value;
+        }
+
+        return $value;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/ParsedExpression.php

@@ -0,0 +1,40 @@
+<?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\ExpressionLanguage;
+
+use Symfony\Component\ExpressionLanguage\Node\Node;
+
+/**
+ * Represents an already parsed expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ParsedExpression extends Expression
+{
+    private $nodes;
+
+    /**
+     * @param string $expression An expression
+     * @param Node   $nodes      A Node representing the expression
+     */
+    public function __construct($expression, Node $nodes)
+    {
+        parent::__construct($expression);
+
+        $this->nodes = $nodes;
+    }
+
+    public function getNodes()
+    {
+        return $this->nodes;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Parser.php

@@ -0,0 +1,384 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Parsers a token stream.
+ *
+ * This parser implements a "Precedence climbing" algorithm.
+ *
+ * @see http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm
+ * @see http://en.wikipedia.org/wiki/Operator-precedence_parser
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Parser
+{
+    const OPERATOR_LEFT = 1;
+    const OPERATOR_RIGHT = 2;
+
+    private $stream;
+    private $unaryOperators;
+    private $binaryOperators;
+    private $functions;
+    private $names;
+
+    public function __construct(array $functions)
+    {
+        $this->functions = $functions;
+
+        $this->unaryOperators = array(
+            'not' => array('precedence' => 50),
+            '!' => array('precedence' => 50),
+            '-' => array('precedence' => 500),
+            '+' => array('precedence' => 500),
+        );
+        $this->binaryOperators = array(
+            'or' => array('precedence' => 10, 'associativity' => self::OPERATOR_LEFT),
+            '||' => array('precedence' => 10, 'associativity' => self::OPERATOR_LEFT),
+            'and' => array('precedence' => 15, 'associativity' => self::OPERATOR_LEFT),
+            '&&' => array('precedence' => 15, 'associativity' => self::OPERATOR_LEFT),
+            '|' => array('precedence' => 16, 'associativity' => self::OPERATOR_LEFT),
+            '^' => array('precedence' => 17, 'associativity' => self::OPERATOR_LEFT),
+            '&' => array('precedence' => 18, 'associativity' => self::OPERATOR_LEFT),
+            '==' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '===' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '!=' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '!==' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '<' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '>' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '>=' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '<=' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            'not in' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            'in' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            'matches' => array('precedence' => 20, 'associativity' => self::OPERATOR_LEFT),
+            '..' => array('precedence' => 25, 'associativity' => self::OPERATOR_LEFT),
+            '+' => array('precedence' => 30, 'associativity' => self::OPERATOR_LEFT),
+            '-' => array('precedence' => 30, 'associativity' => self::OPERATOR_LEFT),
+            '~' => array('precedence' => 40, 'associativity' => self::OPERATOR_LEFT),
+            '*' => array('precedence' => 60, 'associativity' => self::OPERATOR_LEFT),
+            '/' => array('precedence' => 60, 'associativity' => self::OPERATOR_LEFT),
+            '%' => array('precedence' => 60, 'associativity' => self::OPERATOR_LEFT),
+            '**' => array('precedence' => 200, 'associativity' => self::OPERATOR_RIGHT),
+        );
+    }
+
+    /**
+     * Converts a token stream to a node tree.
+     *
+     * The valid names is an array where the values
+     * are the names that the user can use in an expression.
+     *
+     * If the variable name in the compiled PHP code must be
+     * different, define it as the key.
+     *
+     * For instance, ['this' => 'container'] means that the
+     * variable 'container' can be used in the expression
+     * but the compiled code will use 'this'.
+     *
+     * @param TokenStream $stream A token stream instance
+     * @param array       $names  An array of valid names
+     *
+     * @return Node\Node A node tree
+     *
+     * @throws SyntaxError
+     */
+    public function parse(TokenStream $stream, $names = array())
+    {
+        $this->stream = $stream;
+        $this->names = $names;
+
+        $node = $this->parseExpression();
+        if (!$stream->isEOF()) {
+            throw new SyntaxError(sprintf('Unexpected token "%s" of value "%s"', $stream->current->type, $stream->current->value), $stream->current->cursor, $stream->getExpression());
+        }
+
+        return $node;
+    }
+
+    public function parseExpression($precedence = 0)
+    {
+        $expr = $this->getPrimary();
+        $token = $this->stream->current;
+        while ($token->test(Token::OPERATOR_TYPE) && isset($this->binaryOperators[$token->value]) && $this->binaryOperators[$token->value]['precedence'] >= $precedence) {
+            $op = $this->binaryOperators[$token->value];
+            $this->stream->next();
+
+            $expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence']);
+            $expr = new Node\BinaryNode($token->value, $expr, $expr1);
+
+            $token = $this->stream->current;
+        }
+
+        if (0 === $precedence) {
+            return $this->parseConditionalExpression($expr);
+        }
+
+        return $expr;
+    }
+
+    protected function getPrimary()
+    {
+        $token = $this->stream->current;
+
+        if ($token->test(Token::OPERATOR_TYPE) && isset($this->unaryOperators[$token->value])) {
+            $operator = $this->unaryOperators[$token->value];
+            $this->stream->next();
+            $expr = $this->parseExpression($operator['precedence']);
+
+            return $this->parsePostfixExpression(new Node\UnaryNode($token->value, $expr));
+        }
+
+        if ($token->test(Token::PUNCTUATION_TYPE, '(')) {
+            $this->stream->next();
+            $expr = $this->parseExpression();
+            $this->stream->expect(Token::PUNCTUATION_TYPE, ')', 'An opened parenthesis is not properly closed');
+
+            return $this->parsePostfixExpression($expr);
+        }
+
+        return $this->parsePrimaryExpression();
+    }
+
+    protected function parseConditionalExpression($expr)
+    {
+        while ($this->stream->current->test(Token::PUNCTUATION_TYPE, '?')) {
+            $this->stream->next();
+            if (!$this->stream->current->test(Token::PUNCTUATION_TYPE, ':')) {
+                $expr2 = $this->parseExpression();
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, ':')) {
+                    $this->stream->next();
+                    $expr3 = $this->parseExpression();
+                } else {
+                    $expr3 = new Node\ConstantNode(null);
+                }
+            } else {
+                $this->stream->next();
+                $expr2 = $expr;
+                $expr3 = $this->parseExpression();
+            }
+
+            $expr = new Node\ConditionalNode($expr, $expr2, $expr3);
+        }
+
+        return $expr;
+    }
+
+    public function parsePrimaryExpression()
+    {
+        $token = $this->stream->current;
+        switch ($token->type) {
+            case Token::NAME_TYPE:
+                $this->stream->next();
+                switch ($token->value) {
+                    case 'true':
+                    case 'TRUE':
+                        return new Node\ConstantNode(true);
+
+                    case 'false':
+                    case 'FALSE':
+                        return new Node\ConstantNode(false);
+
+                    case 'null':
+                    case 'NULL':
+                        return new Node\ConstantNode(null);
+
+                    default:
+                        if ('(' === $this->stream->current->value) {
+                            if (false === isset($this->functions[$token->value])) {
+                                throw new SyntaxError(sprintf('The function "%s" does not exist', $token->value), $token->cursor, $this->stream->getExpression());
+                            }
+
+                            $node = new Node\FunctionNode($token->value, $this->parseArguments());
+                        } else {
+                            if (!\in_array($token->value, $this->names, true)) {
+                                throw new SyntaxError(sprintf('Variable "%s" is not valid', $token->value), $token->cursor, $this->stream->getExpression());
+                            }
+
+                            // is the name used in the compiled code different
+                            // from the name used in the expression?
+                            if (\is_int($name = array_search($token->value, $this->names))) {
+                                $name = $token->value;
+                            }
+
+                            $node = new Node\NameNode($name);
+                        }
+                }
+                break;
+
+            case Token::NUMBER_TYPE:
+            case Token::STRING_TYPE:
+                $this->stream->next();
+
+                return new Node\ConstantNode($token->value);
+
+            default:
+                if ($token->test(Token::PUNCTUATION_TYPE, '[')) {
+                    $node = $this->parseArrayExpression();
+                } elseif ($token->test(Token::PUNCTUATION_TYPE, '{')) {
+                    $node = $this->parseHashExpression();
+                } else {
+                    throw new SyntaxError(sprintf('Unexpected token "%s" of value "%s"', $token->type, $token->value), $token->cursor, $this->stream->getExpression());
+                }
+        }
+
+        return $this->parsePostfixExpression($node);
+    }
+
+    public function parseArrayExpression()
+    {
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '[', 'An array element was expected');
+
+        $node = new Node\ArrayNode();
+        $first = true;
+        while (!$this->stream->current->test(Token::PUNCTUATION_TYPE, ']')) {
+            if (!$first) {
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ',', 'An array element must be followed by a comma');
+
+                // trailing ,?
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, ']')) {
+                    break;
+                }
+            }
+            $first = false;
+
+            $node->addElement($this->parseExpression());
+        }
+        $this->stream->expect(Token::PUNCTUATION_TYPE, ']', 'An opened array is not properly closed');
+
+        return $node;
+    }
+
+    public function parseHashExpression()
+    {
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '{', 'A hash element was expected');
+
+        $node = new Node\ArrayNode();
+        $first = true;
+        while (!$this->stream->current->test(Token::PUNCTUATION_TYPE, '}')) {
+            if (!$first) {
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ',', 'A hash value must be followed by a comma');
+
+                // trailing ,?
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, '}')) {
+                    break;
+                }
+            }
+            $first = false;
+
+            // a hash key can be:
+            //
+            //  * a number -- 12
+            //  * a string -- 'a'
+            //  * a name, which is equivalent to a string -- a
+            //  * an expression, which must be enclosed in parentheses -- (1 + 2)
+            if ($this->stream->current->test(Token::STRING_TYPE) || $this->stream->current->test(Token::NAME_TYPE) || $this->stream->current->test(Token::NUMBER_TYPE)) {
+                $key = new Node\ConstantNode($this->stream->current->value);
+                $this->stream->next();
+            } elseif ($this->stream->current->test(Token::PUNCTUATION_TYPE, '(')) {
+                $key = $this->parseExpression();
+            } else {
+                $current = $this->stream->current;
+
+                throw new SyntaxError(sprintf('A hash key must be a quoted string, a number, a name, or an expression enclosed in parentheses (unexpected token "%s" of value "%s"', $current->type, $current->value), $current->cursor, $this->stream->getExpression());
+            }
+
+            $this->stream->expect(Token::PUNCTUATION_TYPE, ':', 'A hash key must be followed by a colon (:)');
+            $value = $this->parseExpression();
+
+            $node->addElement($value, $key);
+        }
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '}', 'An opened hash is not properly closed');
+
+        return $node;
+    }
+
+    public function parsePostfixExpression($node)
+    {
+        $token = $this->stream->current;
+        while (Token::PUNCTUATION_TYPE == $token->type) {
+            if ('.' === $token->value) {
+                $this->stream->next();
+                $token = $this->stream->current;
+                $this->stream->next();
+
+                if (
+                    Token::NAME_TYPE !== $token->type
+                    &&
+                    // Operators like "not" and "matches" are valid method or property names,
+                    //
+                    // In other words, besides NAME_TYPE, OPERATOR_TYPE could also be parsed as a property or method.
+                    // This is because operators are processed by the lexer prior to names. So "not" in "foo.not()" or "matches" in "foo.matches" will be recognized as an operator first.
+                    // But in fact, "not" and "matches" in such expressions shall be parsed as method or property names.
+                    //
+                    // And this ONLY works if the operator consists of valid characters for a property or method name.
+                    //
+                    // Other types, such as STRING_TYPE and NUMBER_TYPE, can't be parsed as property nor method names.
+                    //
+                    // As a result, if $token is NOT an operator OR $token->value is NOT a valid property or method name, an exception shall be thrown.
+                    (Token::OPERATOR_TYPE !== $token->type || !preg_match('/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A', $token->value))
+                ) {
+                    throw new SyntaxError('Expected name', $token->cursor, $this->stream->getExpression());
+                }
+
+                $arg = new Node\ConstantNode($token->value);
+
+                $arguments = new Node\ArgumentsNode();
+                if ($this->stream->current->test(Token::PUNCTUATION_TYPE, '(')) {
+                    $type = Node\GetAttrNode::METHOD_CALL;
+                    foreach ($this->parseArguments()->nodes as $n) {
+                        $arguments->addElement($n);
+                    }
+                } else {
+                    $type = Node\GetAttrNode::PROPERTY_CALL;
+                }
+
+                $node = new Node\GetAttrNode($node, $arg, $arguments, $type);
+            } elseif ('[' === $token->value) {
+                if ($node instanceof Node\GetAttrNode && Node\GetAttrNode::METHOD_CALL === $node->attributes['type'] && \PHP_VERSION_ID < 50400) {
+                    throw new SyntaxError('Array calls on a method call is only supported on PHP 5.4+', $token->cursor, $this->stream->getExpression());
+                }
+
+                $this->stream->next();
+                $arg = $this->parseExpression();
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ']');
+
+                $node = new Node\GetAttrNode($node, $arg, new Node\ArgumentsNode(), Node\GetAttrNode::ARRAY_CALL);
+            } else {
+                break;
+            }
+
+            $token = $this->stream->current;
+        }
+
+        return $node;
+    }
+
+    /**
+     * Parses arguments.
+     */
+    public function parseArguments()
+    {
+        $args = array();
+        $this->stream->expect(Token::PUNCTUATION_TYPE, '(', 'A list of arguments must begin with an opening parenthesis');
+        while (!$this->stream->current->test(Token::PUNCTUATION_TYPE, ')')) {
+            if (!empty($args)) {
+                $this->stream->expect(Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma');
+            }
+
+            $args[] = $this->parseExpression();
+        }
+        $this->stream->expect(Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis');
+
+        return new Node\Node($args);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/ParserCache/ArrayParserCache.php

@@ -0,0 +1,38 @@
+<?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\ExpressionLanguage\ParserCache;
+
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
+
+/**
+ * @author Adrien Brault <adrien.brault@gmail.com>
+ */
+class ArrayParserCache implements ParserCacheInterface
+{
+    private $cache = array();
+
+    /**
+     * {@inheritdoc}
+     */
+    public function fetch($key)
+    {
+        return isset($this->cache[$key]) ? $this->cache[$key] : null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function save($key, ParsedExpression $expression)
+    {
+        $this->cache[$key] = $expression;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/ParserCache/ParserCacheInterface.php

@@ -0,0 +1,37 @@
+<?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\ExpressionLanguage\ParserCache;
+
+use Symfony\Component\ExpressionLanguage\ParsedExpression;
+
+/**
+ * @author Adrien Brault <adrien.brault@gmail.com>
+ */
+interface ParserCacheInterface
+{
+    /**
+     * Saves an expression in the cache.
+     *
+     * @param string           $key        The cache key
+     * @param ParsedExpression $expression A ParsedExpression instance to store in the cache
+     */
+    public function save($key, ParsedExpression $expression);
+
+    /**
+     * Fetches an expression from the cache.
+     *
+     * @param string $key The cache key
+     *
+     * @return ParsedExpression|null
+     */
+    public function fetch($key);
+}

phpMyAdmin/vendor/symfony/expression-language/README.md

@@ -0,0 +1,15 @@
+ExpressionLanguage Component
+============================
+
+The ExpressionLanguage component provides an engine that can compile and
+evaluate expressions. An expression is a one-liner that returns a value
+(mostly, but not limited to, Booleans).
+
+Resources
+---------
+
+  * [Documentation](https://symfony.com/doc/current/components/expression_language/introduction.html)
+  * [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)

phpMyAdmin/vendor/symfony/expression-language/SerializedParsedExpression.php

@@ -0,0 +1,37 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Represents an already parsed expression.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class SerializedParsedExpression extends ParsedExpression
+{
+    private $nodes;
+
+    /**
+     * @param string $expression An expression
+     * @param string $nodes      The serialized nodes for the expression
+     */
+    public function __construct($expression, $nodes)
+    {
+        $this->expression = (string) $expression;
+        $this->nodes = $nodes;
+    }
+
+    public function getNodes()
+    {
+        return unserialize($this->nodes);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/SyntaxError.php

@@ -0,0 +1,26 @@
+<?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\ExpressionLanguage;
+
+class SyntaxError extends \LogicException
+{
+    public function __construct($message, $cursor = 0, $expression = '')
+    {
+        $message = sprintf('%s around position %d', $message, $cursor);
+        if ($expression) {
+            $message = sprintf('%s for expression `%s`', $message, $expression);
+        }
+        $message .= '.';
+
+        parent::__construct($message);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/Token.php

@@ -0,0 +1,66 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Represents a Token.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class Token
+{
+    public $value;
+    public $type;
+    public $cursor;
+
+    const EOF_TYPE = 'end of expression';
+    const NAME_TYPE = 'name';
+    const NUMBER_TYPE = 'number';
+    const STRING_TYPE = 'string';
+    const OPERATOR_TYPE = 'operator';
+    const PUNCTUATION_TYPE = 'punctuation';
+
+    /**
+     * @param string                $type   The type of the token (self::*_TYPE)
+     * @param string|int|float|null $value  The token value
+     * @param int                   $cursor The cursor position in the source
+     */
+    public function __construct($type, $value, $cursor)
+    {
+        $this->type = $type;
+        $this->value = $value;
+        $this->cursor = $cursor;
+    }
+
+    /**
+     * Returns a string representation of the token.
+     *
+     * @return string A string representation of the token
+     */
+    public function __toString()
+    {
+        return sprintf('%3d %-11s %s', $this->cursor, strtoupper($this->type), $this->value);
+    }
+
+    /**
+     * Tests the current token for a type and/or a value.
+     *
+     * @param array|int   $type  The type to test
+     * @param string|null $value The token value
+     *
+     * @return bool
+     */
+    public function test($type, $value = null)
+    {
+        return $this->type === $type && (null === $value || $this->value == $value);
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/TokenStream.php

@@ -0,0 +1,97 @@
+<?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\ExpressionLanguage;
+
+/**
+ * Represents a token stream.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class TokenStream
+{
+    public $current;
+
+    private $tokens;
+    private $position = 0;
+    private $expression;
+
+    /**
+     * @param array  $tokens     An array of tokens
+     * @param string $expression
+     */
+    public function __construct(array $tokens, $expression = '')
+    {
+        $this->tokens = $tokens;
+        $this->current = $tokens[0];
+        $this->expression = $expression;
+    }
+
+    /**
+     * Returns a string representation of the token stream.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return implode("\n", $this->tokens);
+    }
+
+    /**
+     * Sets the pointer to the next token and returns the old one.
+     */
+    public function next()
+    {
+        ++$this->position;
+
+        if (!isset($this->tokens[$this->position])) {
+            throw new SyntaxError('Unexpected end of expression', $this->current->cursor, $this->expression);
+        }
+
+        $this->current = $this->tokens[$this->position];
+    }
+
+    /**
+     * Tests a token.
+     *
+     * @param array|int   $type    The type to test
+     * @param string|null $value   The token value
+     * @param string|null $message The syntax error message
+     */
+    public function expect($type, $value = null, $message = null)
+    {
+        $token = $this->current;
+        if (!$token->test($type, $value)) {
+            throw new SyntaxError(sprintf('%sUnexpected token "%s" of value "%s" ("%s" expected%s)', $message ? $message.'. ' : '', $token->type, $token->value, $type, $value ? sprintf(' with value "%s"', $value) : ''), $token->cursor, $this->expression);
+        }
+        $this->next();
+    }
+
+    /**
+     * Checks if end of stream was reached.
+     *
+     * @return bool
+     */
+    public function isEOF()
+    {
+        return Token::EOF_TYPE === $this->current->type;
+    }
+
+    /**
+     * @internal
+     *
+     * @return string
+     */
+    public function getExpression()
+    {
+        return $this->expression;
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "symfony/expression-language",
+    "type": "library",
+    "description": "Symfony ExpressionLanguage Component",
+    "keywords": [],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.9"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Component\\ExpressionLanguage\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-master": "2.8-dev"
+        }
+    }
+}

phpMyAdmin/vendor/symfony/expression-language/phpunit.xml.dist

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/5.2/phpunit.xsd"
+         backupGlobals="false"
+         colors="true"
+         bootstrap="vendor/autoload.php"
+         failOnRisky="true"
+         failOnWarning="true"
+>
+    <php>
+        <ini name="error_reporting" value="-1" />
+    </php>
+
+    <testsuites>
+        <testsuite name="Symfony ExpressionLanguage Component Test Suite">
+            <directory>./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>

phpMyAdmin/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);
+    }
+}

phpMyAdmin/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.

phpMyAdmin/vendor/symfony/polyfill-ctype/README.md

@@ -0,0 +1,12 @@
+Symfony Polyfill / Ctype
+========================
+
+This component provides `ctype_*` functions to users who run php versions without the ctype extension.
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/master/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

phpMyAdmin/vendor/symfony/polyfill-ctype/bootstrap.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($input) { return p\Ctype::ctype_alnum($input); }
+}
+if (!function_exists('ctype_alpha')) {
+    function ctype_alpha($input) { return p\Ctype::ctype_alpha($input); }
+}
+if (!function_exists('ctype_cntrl')) {
+    function ctype_cntrl($input) { return p\Ctype::ctype_cntrl($input); }
+}
+if (!function_exists('ctype_digit')) {
+    function ctype_digit($input) { return p\Ctype::ctype_digit($input); }
+}
+if (!function_exists('ctype_graph')) {
+    function ctype_graph($input) { return p\Ctype::ctype_graph($input); }
+}
+if (!function_exists('ctype_lower')) {
+    function ctype_lower($input) { return p\Ctype::ctype_lower($input); }
+}
+if (!function_exists('ctype_print')) {
+    function ctype_print($input) { return p\Ctype::ctype_print($input); }
+}
+if (!function_exists('ctype_punct')) {
+    function ctype_punct($input) { return p\Ctype::ctype_punct($input); }
+}
+if (!function_exists('ctype_space')) {
+    function ctype_space($input) { return p\Ctype::ctype_space($input); }
+}
+if (!function_exists('ctype_upper')) {
+    function ctype_upper($input) { return p\Ctype::ctype_upper($input); }
+}
+if (!function_exists('ctype_xdigit')) {
+    function ctype_xdigit($input) { return p\Ctype::ctype_xdigit($input); }
+}

phpMyAdmin/vendor/symfony/polyfill-ctype/composer.json

@@ -0,0 +1,38 @@
+{
+    "name": "symfony/polyfill-ctype",
+    "type": "library",
+    "description": "Symfony polyfill for ctype functions",
+    "keywords": ["polyfill", "compatibility", "portable", "ctype"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Gert de Pagter",
+            "email": "BackEndTea@gmail.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.3"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Ctype\\": "" },
+        "files": [ "bootstrap.php" ]
+    },
+    "suggest": {
+        "ext-ctype": "For best performance"
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-main": "1.19-dev"
+        },
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-mbstring/LICENSE

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

phpMyAdmin/vendor/symfony/polyfill-mbstring/Mbstring.php

@@ -0,0 +1,848 @@
+<?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\Mbstring;
+
+/**
+ * Partial mbstring implementation in PHP, iconv based, UTF-8 centric.
+ *
+ * Implemented:
+ * - mb_chr                  - Returns a specific character from its Unicode code point
+ * - mb_convert_encoding     - Convert character encoding
+ * - mb_convert_variables    - Convert character code in variable(s)
+ * - mb_decode_mimeheader    - Decode string in MIME header field
+ * - mb_encode_mimeheader    - Encode string for MIME header XXX NATIVE IMPLEMENTATION IS REALLY BUGGED
+ * - mb_decode_numericentity - Decode HTML numeric string reference to character
+ * - mb_encode_numericentity - Encode character to HTML numeric string reference
+ * - mb_convert_case         - Perform case folding on a string
+ * - mb_detect_encoding      - Detect character encoding
+ * - mb_get_info             - Get internal settings of mbstring
+ * - mb_http_input           - Detect HTTP input character encoding
+ * - mb_http_output          - Set/Get HTTP output character encoding
+ * - mb_internal_encoding    - Set/Get internal character encoding
+ * - mb_list_encodings       - Returns an array of all supported encodings
+ * - mb_ord                  - Returns the Unicode code point of a character
+ * - mb_output_handler       - Callback function converts character encoding in output buffer
+ * - mb_scrub                - Replaces ill-formed byte sequences with substitute characters
+ * - mb_strlen               - Get string length
+ * - mb_strpos               - Find position of first occurrence of string in a string
+ * - mb_strrpos              - Find position of last occurrence of a string in a string
+ * - mb_str_split            - Convert a string to an array
+ * - mb_strtolower           - Make a string lowercase
+ * - mb_strtoupper           - Make a string uppercase
+ * - mb_substitute_character - Set/Get substitution character
+ * - mb_substr               - Get part of string
+ * - mb_stripos              - Finds position of first occurrence of a string within another, case insensitive
+ * - mb_stristr              - Finds first occurrence of a string within another, case insensitive
+ * - mb_strrchr              - Finds the last occurrence of a character in a string within another
+ * - mb_strrichr             - Finds the last occurrence of a character in a string within another, case insensitive
+ * - mb_strripos             - Finds position of last occurrence of a string within another, case insensitive
+ * - mb_strstr               - Finds first occurrence of a string within another
+ * - mb_strwidth             - Return width of string
+ * - mb_substr_count         - Count the number of substring occurrences
+ *
+ * Not implemented:
+ * - mb_convert_kana         - Convert "kana" one from another ("zen-kaku", "han-kaku" and more)
+ * - mb_ereg_*               - Regular expression with multibyte support
+ * - mb_parse_str            - Parse GET/POST/COOKIE data and set global variable
+ * - mb_preferred_mime_name  - Get MIME charset string
+ * - mb_regex_encoding       - Returns current encoding for multibyte regex as string
+ * - mb_regex_set_options    - Set/Get the default options for mbregex functions
+ * - mb_send_mail            - Send encoded mail
+ * - mb_split                - Split multibyte string using regular expression
+ * - mb_strcut               - Get part of string
+ * - mb_strimwidth           - Get truncated string with specified width
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+final class Mbstring
+{
+    const MB_CASE_FOLD = PHP_INT_MAX;
+
+    private static $encodingList = array('ASCII', 'UTF-8');
+    private static $language = 'neutral';
+    private static $internalEncoding = 'UTF-8';
+    private static $caseFold = array(
+        array('µ', 'ſ', "\xCD\x85", 'ς', "\xCF\x90", "\xCF\x91", "\xCF\x95", "\xCF\x96", "\xCF\xB0", "\xCF\xB1", "\xCF\xB5", "\xE1\xBA\x9B", "\xE1\xBE\xBE"),
+        array('μ', 's', 'ι',        'σ', 'β',        'θ',        'φ',        'π',        'κ',        'ρ',        'ε',        "\xE1\xB9\xA1", 'ι'),
+    );
+
+    public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null)
+    {
+        if (\is_array($fromEncoding) || false !== strpos($fromEncoding, ',')) {
+            $fromEncoding = self::mb_detect_encoding($s, $fromEncoding);
+        } else {
+            $fromEncoding = self::getEncoding($fromEncoding);
+        }
+
+        $toEncoding = self::getEncoding($toEncoding);
+
+        if ('BASE64' === $fromEncoding) {
+            $s = base64_decode($s);
+            $fromEncoding = $toEncoding;
+        }
+
+        if ('BASE64' === $toEncoding) {
+            return base64_encode($s);
+        }
+
+        if ('HTML-ENTITIES' === $toEncoding || 'HTML' === $toEncoding) {
+            if ('HTML-ENTITIES' === $fromEncoding || 'HTML' === $fromEncoding) {
+                $fromEncoding = 'Windows-1252';
+            }
+            if ('UTF-8' !== $fromEncoding) {
+                $s = iconv($fromEncoding, 'UTF-8//IGNORE', $s);
+            }
+
+            return preg_replace_callback('/[\x80-\xFF]+/', array(__CLASS__, 'html_encoding_callback'), $s);
+        }
+
+        if ('HTML-ENTITIES' === $fromEncoding) {
+            $s = html_entity_decode($s, ENT_COMPAT, 'UTF-8');
+            $fromEncoding = 'UTF-8';
+        }
+
+        return iconv($fromEncoding, $toEncoding.'//IGNORE', $s);
+    }
+
+    public static function mb_convert_variables($toEncoding, $fromEncoding, &$a = null, &$b = null, &$c = null, &$d = null, &$e = null, &$f = null)
+    {
+        $vars = array(&$a, &$b, &$c, &$d, &$e, &$f);
+
+        $ok = true;
+        array_walk_recursive($vars, function (&$v) use (&$ok, $toEncoding, $fromEncoding) {
+            if (false === $v = Mbstring::mb_convert_encoding($v, $toEncoding, $fromEncoding)) {
+                $ok = false;
+            }
+        });
+
+        return $ok ? $fromEncoding : false;
+    }
+
+    public static function mb_decode_mimeheader($s)
+    {
+        return iconv_mime_decode($s, 2, self::$internalEncoding);
+    }
+
+    public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null)
+    {
+        trigger_error('mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', E_USER_WARNING);
+    }
+
+    public static function mb_decode_numericentity($s, $convmap, $encoding = null)
+    {
+        if (null !== $s && !\is_scalar($s) && !(\is_object($s) && \method_exists($s, '__toString'))) {
+            trigger_error('mb_decode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        if (!\is_array($convmap) || !$convmap) {
+            return false;
+        }
+
+        if (null !== $encoding && !\is_scalar($encoding)) {
+            trigger_error('mb_decode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return '';  // Instead of null (cf. mb_encode_numericentity).
+        }
+
+        $s = (string) $s;
+        if ('' === $s) {
+            return '';
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding) {
+            $encoding = null;
+            if (!preg_match('//u', $s)) {
+                $s = @iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            }
+        } else {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        $cnt = floor(\count($convmap) / 4) * 4;
+
+        for ($i = 0; $i < $cnt; $i += 4) {
+            // collector_decode_htmlnumericentity ignores $convmap[$i + 3]
+            $convmap[$i] += $convmap[$i + 2];
+            $convmap[$i + 1] += $convmap[$i + 2];
+        }
+
+        $s = preg_replace_callback('/&#(?:0*([0-9]+)|x0*([0-9a-fA-F]+))(?!&);?/', function (array $m) use ($cnt, $convmap) {
+            $c = isset($m[2]) ? (int) hexdec($m[2]) : $m[1];
+            for ($i = 0; $i < $cnt; $i += 4) {
+                if ($c >= $convmap[$i] && $c <= $convmap[$i + 1]) {
+                    return Mbstring::mb_chr($c - $convmap[$i + 2]);
+                }
+            }
+
+            return $m[0];
+        }, $s);
+
+        if (null === $encoding) {
+            return $s;
+        }
+
+        return iconv('UTF-8', $encoding.'//IGNORE', $s);
+    }
+
+    public static function mb_encode_numericentity($s, $convmap, $encoding = null, $is_hex = false)
+    {
+        if (null !== $s && !\is_scalar($s) && !(\is_object($s) && \method_exists($s, '__toString'))) {
+            trigger_error('mb_encode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        if (!\is_array($convmap) || !$convmap) {
+            return false;
+        }
+
+        if (null !== $encoding && !\is_scalar($encoding)) {
+            trigger_error('mb_encode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;  // Instead of '' (cf. mb_decode_numericentity).
+        }
+
+        if (null !== $is_hex && !\is_scalar($is_hex)) {
+            trigger_error('mb_encode_numericentity() expects parameter 4 to be boolean, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        $s = (string) $s;
+        if ('' === $s) {
+            return '';
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding) {
+            $encoding = null;
+            if (!preg_match('//u', $s)) {
+                $s = @iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            }
+        } else {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        static $ulenMask = array("\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4);
+
+        $cnt = floor(\count($convmap) / 4) * 4;
+        $i = 0;
+        $len = \strlen($s);
+        $result = '';
+
+        while ($i < $len) {
+            $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
+            $uchr = substr($s, $i, $ulen);
+            $i += $ulen;
+            $c = self::mb_ord($uchr);
+
+            for ($j = 0; $j < $cnt; $j += 4) {
+                if ($c >= $convmap[$j] && $c <= $convmap[$j + 1]) {
+                    $cOffset = ($c + $convmap[$j + 2]) & $convmap[$j + 3];
+                    $result .= $is_hex ? sprintf('&#x%X;', $cOffset) : '&#'.$cOffset.';';
+                    continue 2;
+                }
+            }
+            $result .= $uchr;
+        }
+
+        if (null === $encoding) {
+            return $result;
+        }
+
+        return iconv('UTF-8', $encoding.'//IGNORE', $result);
+    }
+
+    public static function mb_convert_case($s, $mode, $encoding = null)
+    {
+        $s = (string) $s;
+        if ('' === $s) {
+            return '';
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding) {
+            $encoding = null;
+            if (!preg_match('//u', $s)) {
+                $s = @iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            }
+        } else {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        if (MB_CASE_TITLE == $mode) {
+            static $titleRegexp = null;
+            if (null === $titleRegexp) {
+                $titleRegexp = self::getData('titleCaseRegexp');
+            }
+            $s = preg_replace_callback($titleRegexp, array(__CLASS__, 'title_case'), $s);
+        } else {
+            if (MB_CASE_UPPER == $mode) {
+                static $upper = null;
+                if (null === $upper) {
+                    $upper = self::getData('upperCase');
+                }
+                $map = $upper;
+            } else {
+                if (self::MB_CASE_FOLD === $mode) {
+                    $s = str_replace(self::$caseFold[0], self::$caseFold[1], $s);
+                }
+
+                static $lower = null;
+                if (null === $lower) {
+                    $lower = self::getData('lowerCase');
+                }
+                $map = $lower;
+            }
+
+            static $ulenMask = array("\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4);
+
+            $i = 0;
+            $len = \strlen($s);
+
+            while ($i < $len) {
+                $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
+                $uchr = substr($s, $i, $ulen);
+                $i += $ulen;
+
+                if (isset($map[$uchr])) {
+                    $uchr = $map[$uchr];
+                    $nlen = \strlen($uchr);
+
+                    if ($nlen == $ulen) {
+                        $nlen = $i;
+                        do {
+                            $s[--$nlen] = $uchr[--$ulen];
+                        } while ($ulen);
+                    } else {
+                        $s = substr_replace($s, $uchr, $i - $ulen, $ulen);
+                        $len += $nlen - $ulen;
+                        $i += $nlen - $ulen;
+                    }
+                }
+            }
+        }
+
+        if (null === $encoding) {
+            return $s;
+        }
+
+        return iconv('UTF-8', $encoding.'//IGNORE', $s);
+    }
+
+    public static function mb_internal_encoding($encoding = null)
+    {
+        if (null === $encoding) {
+            return self::$internalEncoding;
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding || false !== @iconv($encoding, $encoding, ' ')) {
+            self::$internalEncoding = $encoding;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public static function mb_language($lang = null)
+    {
+        if (null === $lang) {
+            return self::$language;
+        }
+
+        switch ($lang = strtolower($lang)) {
+            case 'uni':
+            case 'neutral':
+                self::$language = $lang;
+
+                return true;
+        }
+
+        return false;
+    }
+
+    public static function mb_list_encodings()
+    {
+        return array('UTF-8');
+    }
+
+    public static function mb_encoding_aliases($encoding)
+    {
+        switch (strtoupper($encoding)) {
+            case 'UTF8':
+            case 'UTF-8':
+                return array('utf8');
+        }
+
+        return false;
+    }
+
+    public static function mb_check_encoding($var = null, $encoding = null)
+    {
+        if (null === $encoding) {
+            if (null === $var) {
+                return false;
+            }
+            $encoding = self::$internalEncoding;
+        }
+
+        return self::mb_detect_encoding($var, array($encoding)) || false !== @iconv($encoding, $encoding, $var);
+    }
+
+    public static function mb_detect_encoding($str, $encodingList = null, $strict = false)
+    {
+        if (null === $encodingList) {
+            $encodingList = self::$encodingList;
+        } else {
+            if (!\is_array($encodingList)) {
+                $encodingList = array_map('trim', explode(',', $encodingList));
+            }
+            $encodingList = array_map('strtoupper', $encodingList);
+        }
+
+        foreach ($encodingList as $enc) {
+            switch ($enc) {
+                case 'ASCII':
+                    if (!preg_match('/[\x80-\xFF]/', $str)) {
+                        return $enc;
+                    }
+                    break;
+
+                case 'UTF8':
+                case 'UTF-8':
+                    if (preg_match('//u', $str)) {
+                        return 'UTF-8';
+                    }
+                    break;
+
+                default:
+                    if (0 === strncmp($enc, 'ISO-8859-', 9)) {
+                        return $enc;
+                    }
+            }
+        }
+
+        return false;
+    }
+
+    public static function mb_detect_order($encodingList = null)
+    {
+        if (null === $encodingList) {
+            return self::$encodingList;
+        }
+
+        if (!\is_array($encodingList)) {
+            $encodingList = array_map('trim', explode(',', $encodingList));
+        }
+        $encodingList = array_map('strtoupper', $encodingList);
+
+        foreach ($encodingList as $enc) {
+            switch ($enc) {
+                default:
+                    if (strncmp($enc, 'ISO-8859-', 9)) {
+                        return false;
+                    }
+                    // no break
+                case 'ASCII':
+                case 'UTF8':
+                case 'UTF-8':
+            }
+        }
+
+        self::$encodingList = $encodingList;
+
+        return true;
+    }
+
+    public static function mb_strlen($s, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return \strlen($s);
+        }
+
+        return @iconv_strlen($s, $encoding);
+    }
+
+    public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return strpos($haystack, $needle, $offset);
+        }
+
+        $needle = (string) $needle;
+        if ('' === $needle) {
+            trigger_error(__METHOD__.': Empty delimiter', E_USER_WARNING);
+
+            return false;
+        }
+
+        return iconv_strpos($haystack, $needle, $offset, $encoding);
+    }
+
+    public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return strrpos($haystack, $needle, $offset);
+        }
+
+        if ($offset != (int) $offset) {
+            $offset = 0;
+        } elseif ($offset = (int) $offset) {
+            if ($offset < 0) {
+                if (0 > $offset += self::mb_strlen($needle)) {
+                    $haystack = self::mb_substr($haystack, 0, $offset, $encoding);
+                }
+                $offset = 0;
+            } else {
+                $haystack = self::mb_substr($haystack, $offset, 2147483647, $encoding);
+            }
+        }
+
+        $pos = iconv_strrpos($haystack, $needle, $encoding);
+
+        return false !== $pos ? $offset + $pos : false;
+    }
+
+    public static function mb_str_split($string, $split_length = 1, $encoding = null)
+    {
+        if (null !== $string && !\is_scalar($string) && !(\is_object($string) && \method_exists($string, '__toString'))) {
+            trigger_error('mb_str_split() expects parameter 1 to be string, '.\gettype($string).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        if (1 > $split_length = (int) $split_length) {
+            trigger_error('The length of each segment must be greater than zero', E_USER_WARNING);
+
+            return false;
+        }
+
+        if (null === $encoding) {
+            $encoding = mb_internal_encoding();
+        }
+
+        if ('UTF-8' === $encoding = self::getEncoding($encoding)) {
+            $rx = '/(';
+            while (65535 < $split_length) {
+                $rx .= '.{65535}';
+                $split_length -= 65535;
+            }
+            $rx .= '.{'.$split_length.'})/us';
+
+            return preg_split($rx, $string, null, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
+        }
+
+        $result = array();
+        $length = mb_strlen($string, $encoding);
+
+        for ($i = 0; $i < $length; $i += $split_length) {
+            $result[] = mb_substr($string, $i, $split_length, $encoding);
+        }
+
+        return $result;
+    }
+
+    public static function mb_strtolower($s, $encoding = null)
+    {
+        return self::mb_convert_case($s, MB_CASE_LOWER, $encoding);
+    }
+
+    public static function mb_strtoupper($s, $encoding = null)
+    {
+        return self::mb_convert_case($s, MB_CASE_UPPER, $encoding);
+    }
+
+    public static function mb_substitute_character($c = null)
+    {
+        if (0 === strcasecmp($c, 'none')) {
+            return true;
+        }
+
+        return null !== $c ? false : 'none';
+    }
+
+    public static function mb_substr($s, $start, $length = null, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return (string) substr($s, $start, null === $length ? 2147483647 : $length);
+        }
+
+        if ($start < 0) {
+            $start = iconv_strlen($s, $encoding) + $start;
+            if ($start < 0) {
+                $start = 0;
+            }
+        }
+
+        if (null === $length) {
+            $length = 2147483647;
+        } elseif ($length < 0) {
+            $length = iconv_strlen($s, $encoding) + $length - $start;
+            if ($length < 0) {
+                return '';
+            }
+        }
+
+        return (string) iconv_substr($s, $start, $length, $encoding);
+    }
+
+    public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
+        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+
+        return self::mb_strpos($haystack, $needle, $offset, $encoding);
+    }
+
+    public static function mb_stristr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $pos = self::mb_stripos($haystack, $needle, 0, $encoding);
+
+        return self::getSubpart($pos, $part, $haystack, $encoding);
+    }
+
+    public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            $pos = strrpos($haystack, $needle);
+        } else {
+            $needle = self::mb_substr($needle, 0, 1, $encoding);
+            $pos = iconv_strrpos($haystack, $needle, $encoding);
+        }
+
+        return self::getSubpart($pos, $part, $haystack, $encoding);
+    }
+
+    public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $needle = self::mb_substr($needle, 0, 1, $encoding);
+        $pos = self::mb_strripos($haystack, $needle, $encoding);
+
+        return self::getSubpart($pos, $part, $haystack, $encoding);
+    }
+
+    public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
+        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+
+        return self::mb_strrpos($haystack, $needle, $offset, $encoding);
+    }
+
+    public static function mb_strstr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $pos = strpos($haystack, $needle);
+        if (false === $pos) {
+            return false;
+        }
+        if ($part) {
+            return substr($haystack, 0, $pos);
+        }
+
+        return substr($haystack, $pos);
+    }
+
+    public static function mb_get_info($type = 'all')
+    {
+        $info = array(
+            'internal_encoding' => self::$internalEncoding,
+            'http_output' => 'pass',
+            'http_output_conv_mimetypes' => '^(text/|application/xhtml\+xml)',
+            'func_overload' => 0,
+            'func_overload_list' => 'no overload',
+            'mail_charset' => 'UTF-8',
+            'mail_header_encoding' => 'BASE64',
+            'mail_body_encoding' => 'BASE64',
+            'illegal_chars' => 0,
+            'encoding_translation' => 'Off',
+            'language' => self::$language,
+            'detect_order' => self::$encodingList,
+            'substitute_character' => 'none',
+            'strict_detection' => 'Off',
+        );
+
+        if ('all' === $type) {
+            return $info;
+        }
+        if (isset($info[$type])) {
+            return $info[$type];
+        }
+
+        return false;
+    }
+
+    public static function mb_http_input($type = '')
+    {
+        return false;
+    }
+
+    public static function mb_http_output($encoding = null)
+    {
+        return null !== $encoding ? 'pass' === $encoding : 'pass';
+    }
+
+    public static function mb_strwidth($s, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' !== $encoding) {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        $s = preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $s, -1, $wide);
+
+        return ($wide << 1) + iconv_strlen($s, 'UTF-8');
+    }
+
+    public static function mb_substr_count($haystack, $needle, $encoding = null)
+    {
+        return substr_count($haystack, $needle);
+    }
+
+    public static function mb_output_handler($contents, $status)
+    {
+        return $contents;
+    }
+
+    public static function mb_chr($code, $encoding = null)
+    {
+        if (0x80 > $code %= 0x200000) {
+            $s = \chr($code);
+        } elseif (0x800 > $code) {
+            $s = \chr(0xC0 | $code >> 6).\chr(0x80 | $code & 0x3F);
+        } elseif (0x10000 > $code) {
+            $s = \chr(0xE0 | $code >> 12).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+        } else {
+            $s = \chr(0xF0 | $code >> 18).\chr(0x80 | $code >> 12 & 0x3F).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+        }
+
+        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
+            $s = mb_convert_encoding($s, $encoding, 'UTF-8');
+        }
+
+        return $s;
+    }
+
+    public static function mb_ord($s, $encoding = null)
+    {
+        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
+            $s = mb_convert_encoding($s, 'UTF-8', $encoding);
+        }
+
+        if (1 === \strlen($s)) {
+            return \ord($s);
+        }
+
+        $code = ($s = unpack('C*', substr($s, 0, 4))) ? $s[1] : 0;
+        if (0xF0 <= $code) {
+            return (($code - 0xF0) << 18) + (($s[2] - 0x80) << 12) + (($s[3] - 0x80) << 6) + $s[4] - 0x80;
+        }
+        if (0xE0 <= $code) {
+            return (($code - 0xE0) << 12) + (($s[2] - 0x80) << 6) + $s[3] - 0x80;
+        }
+        if (0xC0 <= $code) {
+            return (($code - 0xC0) << 6) + $s[2] - 0x80;
+        }
+
+        return $code;
+    }
+
+    private static function getSubpart($pos, $part, $haystack, $encoding)
+    {
+        if (false === $pos) {
+            return false;
+        }
+        if ($part) {
+            return self::mb_substr($haystack, 0, $pos, $encoding);
+        }
+
+        return self::mb_substr($haystack, $pos, null, $encoding);
+    }
+
+    private static function html_encoding_callback(array $m)
+    {
+        $i = 1;
+        $entities = '';
+        $m = unpack('C*', htmlentities($m[0], ENT_COMPAT, 'UTF-8'));
+
+        while (isset($m[$i])) {
+            if (0x80 > $m[$i]) {
+                $entities .= \chr($m[$i++]);
+                continue;
+            }
+            if (0xF0 <= $m[$i]) {
+                $c = (($m[$i++] - 0xF0) << 18) + (($m[$i++] - 0x80) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
+            } elseif (0xE0 <= $m[$i]) {
+                $c = (($m[$i++] - 0xE0) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
+            } else {
+                $c = (($m[$i++] - 0xC0) << 6) + $m[$i++] - 0x80;
+            }
+
+            $entities .= '&#'.$c.';';
+        }
+
+        return $entities;
+    }
+
+    private static function title_case(array $s)
+    {
+        return self::mb_convert_case($s[1], MB_CASE_UPPER, 'UTF-8').self::mb_convert_case($s[2], MB_CASE_LOWER, 'UTF-8');
+    }
+
+    private static function getData($file)
+    {
+        if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
+            return require $file;
+        }
+
+        return false;
+    }
+
+    private static function getEncoding($encoding)
+    {
+        if (null === $encoding) {
+            return self::$internalEncoding;
+        }
+
+        if ('UTF-8' === $encoding) {
+            return 'UTF-8';
+        }
+
+        $encoding = strtoupper($encoding);
+
+        if ('8BIT' === $encoding || 'BINARY' === $encoding) {
+            return 'CP850';
+        }
+
+        if ('UTF8' === $encoding) {
+            return 'UTF-8';
+        }
+
+        return $encoding;
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-mbstring/README.md

@@ -0,0 +1,13 @@
+Symfony Polyfill / Mbstring
+===========================
+
+This component provides a partial, native PHP implementation for the
+[Mbstring](https://php.net/mbstring) extension.
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/master/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

phpMyAdmin/vendor/symfony/polyfill-mbstring/Resources/mb_convert_variables.php8

@@ -0,0 +1,31 @@
+<?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\Mbstring as p;
+
+if (!function_exists('mb_convert_variables')) {
+    /**
+     * Convert character code in variable(s)
+     */
+    function mb_convert_variables($to_encoding, $from_encoding, &$var, &...$vars)
+    {
+        $vars = [&$var, ...$vars];
+
+        $ok = true;
+        array_walk_recursive($vars, function (&$v) use (&$ok, $to_encoding, $from_encoding) {
+            if (false === $v = p\Mbstring::mb_convert_encoding($v, $to_encoding, $from_encoding)) {
+                $ok = false;
+            }
+        });
+
+        return $ok ? $from_encoding : false;
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-mbstring/bootstrap.php

@@ -0,0 +1,145 @@
+<?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\Mbstring as p;
+
+if (!function_exists('mb_convert_encoding')) {
+    function mb_convert_encoding($string, $to_encoding, $from_encoding = null) { return p\Mbstring::mb_convert_encoding($string, $to_encoding, $from_encoding); }
+}
+if (!function_exists('mb_decode_mimeheader')) {
+    function mb_decode_mimeheader($string) { return p\Mbstring::mb_decode_mimeheader($string); }
+}
+if (!function_exists('mb_encode_mimeheader')) {
+    function mb_encode_mimeheader($string, $charset = null, $transfer_encoding = null, $newline = null, $indent = null) { return p\Mbstring::mb_encode_mimeheader($string, $charset, $transfer_encoding, $newline, $indent); }
+}
+if (!function_exists('mb_decode_numericentity')) {
+    function mb_decode_numericentity($string, $map, $encoding = null) { return p\Mbstring::mb_decode_numericentity($string, $map, $encoding); }
+}
+if (!function_exists('mb_encode_numericentity')) {
+    function mb_encode_numericentity($string, $map, $encoding = null, $hex = false) { return p\Mbstring::mb_encode_numericentity($string, $map, $encoding, $hex); }
+}
+if (!function_exists('mb_convert_case')) {
+    function mb_convert_case($string, $mode, $encoding = null) { return p\Mbstring::mb_convert_case($string, $mode, $encoding); }
+}
+if (!function_exists('mb_internal_encoding')) {
+    function mb_internal_encoding($encoding = null) { return p\Mbstring::mb_internal_encoding($encoding); }
+}
+if (!function_exists('mb_language')) {
+    function mb_language($language = null) { return p\Mbstring::mb_language($language); }
+}
+if (!function_exists('mb_list_encodings')) {
+    function mb_list_encodings() { return p\Mbstring::mb_list_encodings(); }
+}
+if (!function_exists('mb_encoding_aliases')) {
+    function mb_encoding_aliases($encoding) { return p\Mbstring::mb_encoding_aliases($encoding); }
+}
+if (!function_exists('mb_check_encoding')) {
+    function mb_check_encoding($value = null, $encoding = null) { return p\Mbstring::mb_check_encoding($value, $encoding); }
+}
+if (!function_exists('mb_detect_encoding')) {
+    function mb_detect_encoding($string, $encodings = null, $strict = false) { return p\Mbstring::mb_detect_encoding($string, $encodings, $strict); }
+}
+if (!function_exists('mb_detect_order')) {
+    function mb_detect_order($encoding = null) { return p\Mbstring::mb_detect_order($encoding); }
+}
+if (!function_exists('mb_parse_str')) {
+    function mb_parse_str($string, &$result = array()) { parse_str($string, $result); }
+}
+if (!function_exists('mb_strlen')) {
+    function mb_strlen($string, $encoding = null) { return p\Mbstring::mb_strlen($string, $encoding); }
+}
+if (!function_exists('mb_strpos')) {
+    function mb_strpos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_strpos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_strtolower')) {
+    function mb_strtolower($string, $encoding = null) { return p\Mbstring::mb_strtolower($string, $encoding); }
+}
+if (!function_exists('mb_strtoupper')) {
+    function mb_strtoupper($string, $encoding = null) { return p\Mbstring::mb_strtoupper($string, $encoding); }
+}
+if (!function_exists('mb_substitute_character')) {
+    function mb_substitute_character($substitute_character = null) { return p\Mbstring::mb_substitute_character($substitute_character); }
+}
+if (!function_exists('mb_substr')) {
+    function mb_substr($string, $start, $length = 2147483647, $encoding = null) { return p\Mbstring::mb_substr($string, $start, $length, $encoding); }
+}
+if (!function_exists('mb_stripos')) {
+    function mb_stripos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_stripos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_stristr')) {
+    function mb_stristr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_stristr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_strrchr')) {
+    function mb_strrchr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_strrchr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_strrichr')) {
+    function mb_strrichr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_strrichr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_strripos')) {
+    function mb_strripos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_strripos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_strrpos')) {
+    function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null) { return p\Mbstring::mb_strrpos($haystack, $needle, $offset, $encoding); }
+}
+if (!function_exists('mb_strstr')) {
+    function mb_strstr($haystack, $needle, $before_needle = false, $encoding = null) { return p\Mbstring::mb_strstr($haystack, $needle, $before_needle, $encoding); }
+}
+if (!function_exists('mb_get_info')) {
+    function mb_get_info($type = 'all') { return p\Mbstring::mb_get_info($type); }
+}
+if (!function_exists('mb_http_output')) {
+    function mb_http_output($encoding = null) { return p\Mbstring::mb_http_output($encoding); }
+}
+if (!function_exists('mb_strwidth')) {
+    function mb_strwidth($string, $encoding = null) { return p\Mbstring::mb_strwidth($string, $encoding); }
+}
+if (!function_exists('mb_substr_count')) {
+    function mb_substr_count($haystack, $needle, $encoding = null) { return p\Mbstring::mb_substr_count($haystack, $needle, $encoding); }
+}
+if (!function_exists('mb_output_handler')) {
+    function mb_output_handler($string, $status) { return p\Mbstring::mb_output_handler($string, $status); }
+}
+if (!function_exists('mb_http_input')) {
+    function mb_http_input($type = '') { return p\Mbstring::mb_http_input($type); }
+}
+
+if (PHP_VERSION_ID >= 80000) {
+    require_once __DIR__.'/Resources/mb_convert_variables.php8';
+} elseif (!function_exists('mb_convert_variables')) {
+    function mb_convert_variables($toEncoding, $fromEncoding, &$a = null, &$b = null, &$c = null, &$d = null, &$e = null, &$f = null) { return p\Mbstring::mb_convert_variables($toEncoding, $fromEncoding, $a, $b, $c, $d, $e, $f); }
+}
+
+if (!function_exists('mb_ord')) {
+    function mb_ord($string, $encoding = null) { return p\Mbstring::mb_ord($string, $encoding); }
+}
+if (!function_exists('mb_chr')) {
+    function mb_chr($codepoint, $encoding = null) { return p\Mbstring::mb_chr($codepoint, $encoding); }
+}
+if (!function_exists('mb_scrub')) {
+    function mb_scrub($string, $encoding = null) { $encoding = null === $encoding ? mb_internal_encoding() : $encoding; return mb_convert_encoding($string, $encoding, $encoding); }
+}
+if (!function_exists('mb_str_split')) {
+    function mb_str_split($string, $length = 1, $encoding = null) { return p\Mbstring::mb_str_split($string, $length, $encoding); }
+}
+
+if (extension_loaded('mbstring')) {
+    return;
+}
+
+if (!defined('MB_CASE_UPPER')) {
+    define('MB_CASE_UPPER', 0);
+}
+if (!defined('MB_CASE_LOWER')) {
+    define('MB_CASE_LOWER', 1);
+}
+if (!defined('MB_CASE_TITLE')) {
+    define('MB_CASE_TITLE', 2);
+}

phpMyAdmin/vendor/symfony/polyfill-mbstring/composer.json

@@ -0,0 +1,38 @@
+{
+    "name": "symfony/polyfill-mbstring",
+    "type": "library",
+    "description": "Symfony polyfill for the Mbstring extension",
+    "keywords": ["polyfill", "shim", "compatibility", "portable", "mbstring"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Grekas",
+            "email": "p@tchwork.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.3"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Mbstring\\": "" },
+        "files": [ "bootstrap.php" ]
+    },
+    "suggest": {
+        "ext-mbstring": "For best performance"
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-main": "1.19-dev"
+        },
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-php56/LICENSE

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

phpMyAdmin/vendor/symfony/polyfill-php56/Php56.php

@@ -0,0 +1,138 @@
+<?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\Php56;
+
+use Symfony\Polyfill\Util\Binary;
+
+/**
+ * @internal
+ */
+final class Php56
+{
+    const LDAP_ESCAPE_FILTER = 1;
+    const LDAP_ESCAPE_DN = 2;
+
+    public static function hash_equals($knownString, $userInput)
+    {
+        if (!\is_string($knownString)) {
+            trigger_error('Expected known_string to be a string, '.\gettype($knownString).' given', E_USER_WARNING);
+
+            return false;
+        }
+
+        if (!\is_string($userInput)) {
+            trigger_error('Expected user_input to be a string, '.\gettype($userInput).' given', E_USER_WARNING);
+
+            return false;
+        }
+
+        $knownLen = Binary::strlen($knownString);
+        $userLen = Binary::strlen($userInput);
+
+        if ($knownLen !== $userLen) {
+            return false;
+        }
+
+        $result = 0;
+
+        for ($i = 0; $i < $knownLen; ++$i) {
+            $result |= \ord($knownString[$i]) ^ \ord($userInput[$i]);
+        }
+
+        return 0 === $result;
+    }
+
+    /**
+     * Stub implementation of the {@link ldap_escape()} function of the ldap
+     * extension.
+     *
+     * Escape strings for safe use in LDAP filters and DNs.
+     *
+     * @author Chris Wright <ldapi@daverandom.com>
+     *
+     * @param string $subject
+     * @param string $ignore
+     * @param int    $flags
+     *
+     * @return string
+     *
+     * @see http://stackoverflow.com/a/8561604
+     */
+    public static function ldap_escape($subject, $ignore = '', $flags = 0)
+    {
+        static $charMaps = null;
+
+        if (null === $charMaps) {
+            $charMaps = array(
+                self::LDAP_ESCAPE_FILTER => array('\\', '*', '(', ')', "\x00"),
+                self::LDAP_ESCAPE_DN => array('\\', ',', '=', '+', '<', '>', ';', '"', '#', "\r"),
+            );
+
+            $charMaps[0] = array();
+
+            for ($i = 0; $i < 256; ++$i) {
+                $charMaps[0][\chr($i)] = sprintf('\\%02x', $i);
+            }
+
+            for ($i = 0, $l = \count($charMaps[self::LDAP_ESCAPE_FILTER]); $i < $l; ++$i) {
+                $chr = $charMaps[self::LDAP_ESCAPE_FILTER][$i];
+                unset($charMaps[self::LDAP_ESCAPE_FILTER][$i]);
+                $charMaps[self::LDAP_ESCAPE_FILTER][$chr] = $charMaps[0][$chr];
+            }
+
+            for ($i = 0, $l = \count($charMaps[self::LDAP_ESCAPE_DN]); $i < $l; ++$i) {
+                $chr = $charMaps[self::LDAP_ESCAPE_DN][$i];
+                unset($charMaps[self::LDAP_ESCAPE_DN][$i]);
+                $charMaps[self::LDAP_ESCAPE_DN][$chr] = $charMaps[0][$chr];
+            }
+        }
+
+        // Create the base char map to escape
+        $flags = (int) $flags;
+        $charMap = array();
+
+        if ($flags & self::LDAP_ESCAPE_FILTER) {
+            $charMap += $charMaps[self::LDAP_ESCAPE_FILTER];
+        }
+
+        if ($flags & self::LDAP_ESCAPE_DN) {
+            $charMap += $charMaps[self::LDAP_ESCAPE_DN];
+        }
+
+        if (!$charMap) {
+            $charMap = $charMaps[0];
+        }
+
+        // Remove any chars to ignore from the list
+        $ignore = (string) $ignore;
+
+        for ($i = 0, $l = \strlen($ignore); $i < $l; ++$i) {
+            unset($charMap[$ignore[$i]]);
+        }
+
+        // Do the main replacement
+        $result = strtr($subject, $charMap);
+
+        // Encode leading/trailing spaces if self::LDAP_ESCAPE_DN is passed
+        if ($flags & self::LDAP_ESCAPE_DN) {
+            if (' ' === $result[0]) {
+                $result = '\\20'.substr($result, 1);
+            }
+
+            if (' ' === $result[\strlen($result) - 1]) {
+                $result = substr($result, 0, -1).'\\20';
+            }
+        }
+
+        return $result;
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-php56/README.md

@@ -0,0 +1,15 @@
+Symfony Polyfill / Php56
+========================
+
+This component provides functions unavailable in releases prior to PHP 5.6:
+
+- [`hash_equals`](https://php.net/hash_equals)  (part of [hash](https://php.net/hash) extension)
+- [`ldap_escape`](https://php.net/ldap_escape) (part of [ldap](https://php.net/ldap) extension)
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/master/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

phpMyAdmin/vendor/symfony/polyfill-php56/bootstrap.php

@@ -0,0 +1,44 @@
+<?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\Php56 as p;
+
+if (PHP_VERSION_ID >= 50600) {
+    return;
+}
+
+if (!function_exists('hash_equals')) {
+    function hash_equals($known_string, $user_string) { return p\Php56::hash_equals($known_string, $user_string); }
+}
+if (extension_loaded('ldap') && !defined('LDAP_ESCAPE_FILTER')) {
+    define('LDAP_ESCAPE_FILTER', 1);
+}
+if (extension_loaded('ldap') && !defined('LDAP_ESCAPE_DN')) {
+    define('LDAP_ESCAPE_DN', 2);
+}
+
+if (extension_loaded('ldap') && !function_exists('ldap_escape')) {
+    function ldap_escape($value, $ignore = '', $flags = 0) { return p\Php56::ldap_escape($value, $ignore, $flags); }
+}
+
+if (50509 === PHP_VERSION_ID && 4 === PHP_INT_SIZE) {
+    // Missing functions in PHP 5.5.9 - affects 32 bit builds of Ubuntu 14.04LTS
+    // See https://bugs.launchpad.net/ubuntu/+source/php5/+bug/1315888
+    if (!function_exists('gzopen') && function_exists('gzopen64')) {
+        function gzopen($filename, $mode, $use_include_path = 0) { return gzopen64($filename, $mode, $use_include_path); }
+    }
+    if (!function_exists('gzseek') && function_exists('gzseek64')) {
+        function gzseek($fp, $offset, $whence = SEEK_SET) { return gzseek64($fp, $offset, $whence); }
+    }
+    if (!function_exists('gztell') && function_exists('gztell64')) {
+        function gztell($fp) { return gztell64($fp); }
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-php56/composer.json

@@ -0,0 +1,36 @@
+{
+    "name": "symfony/polyfill-php56",
+    "type": "library",
+    "description": "Symfony polyfill backporting some PHP 5.6+ features to lower PHP versions",
+    "keywords": ["polyfill", "shim", "compatibility", "portable"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Grekas",
+            "email": "p@tchwork.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.3",
+        "symfony/polyfill-util": "~1.0"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Php56\\": "" },
+        "files": [ "bootstrap.php" ]
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-main": "1.19-dev"
+        },
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/Binary.php

@@ -0,0 +1,22 @@
+<?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\Util;
+
+if (\extension_loaded('mbstring')) {
+    class Binary extends BinaryOnFuncOverload
+    {
+    }
+} else {
+    class Binary extends BinaryNoFuncOverload
+    {
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/BinaryNoFuncOverload.php

@@ -0,0 +1,65 @@
+<?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\Util;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class BinaryNoFuncOverload
+{
+    public static function strlen($s)
+    {
+        return \strlen($s);
+    }
+
+    public static function strpos($haystack, $needle, $offset = 0)
+    {
+        return strpos($haystack, $needle, $offset);
+    }
+
+    public static function strrpos($haystack, $needle, $offset = 0)
+    {
+        return strrpos($haystack, $needle, $offset);
+    }
+
+    public static function substr($string, $start, $length = PHP_INT_MAX)
+    {
+        return substr($string, $start, $length);
+    }
+
+    public static function stripos($s, $needle, $offset = 0)
+    {
+        return stripos($s, $needle, $offset);
+    }
+
+    public static function stristr($s, $needle, $part = false)
+    {
+        return stristr($s, $needle, $part);
+    }
+
+    public static function strrchr($s, $needle, $part = false)
+    {
+        return strrchr($s, $needle, $part);
+    }
+
+    public static function strripos($s, $needle, $offset = 0)
+    {
+        return strripos($s, $needle, $offset);
+    }
+
+    public static function strstr($s, $needle, $part = false)
+    {
+        return strstr($s, $needle, $part);
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/BinaryOnFuncOverload.php

@@ -0,0 +1,67 @@
+<?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\Util;
+
+/**
+ * Binary safe version of string functions overloaded when MB_OVERLOAD_STRING is enabled.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class BinaryOnFuncOverload
+{
+    public static function strlen($s)
+    {
+        return mb_strlen($s, '8bit');
+    }
+
+    public static function strpos($haystack, $needle, $offset = 0)
+    {
+        return mb_strpos($haystack, $needle, $offset, '8bit');
+    }
+
+    public static function strrpos($haystack, $needle, $offset = 0)
+    {
+        return mb_strrpos($haystack, $needle, $offset, '8bit');
+    }
+
+    public static function substr($string, $start, $length = 2147483647)
+    {
+        return mb_substr($string, $start, $length, '8bit');
+    }
+
+    public static function stripos($s, $needle, $offset = 0)
+    {
+        return mb_stripos($s, $needle, $offset, '8bit');
+    }
+
+    public static function stristr($s, $needle, $part = false)
+    {
+        return mb_stristr($s, $needle, $part, '8bit');
+    }
+
+    public static function strrchr($s, $needle, $part = false)
+    {
+        return mb_strrchr($s, $needle, $part, '8bit');
+    }
+
+    public static function strripos($s, $needle, $offset = 0)
+    {
+        return mb_strripos($s, $needle, $offset, '8bit');
+    }
+
+    public static function strstr($s, $needle, $part = false)
+    {
+        return mb_strstr($s, $needle, $part, '8bit');
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/LICENSE

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

phpMyAdmin/vendor/symfony/polyfill-util/README.md

@@ -0,0 +1,13 @@
+Symfony Polyfill / Util
+=======================
+
+This component provides binary-safe string functions, using the
+[mbstring](https://php.net/mbstring) extension when available.
+
+More information can be found in the
+[main Polyfill README](https://github.com/symfony/polyfill/blob/master/README.md).
+
+License
+=======
+
+This library is released under the [MIT license](LICENSE).

phpMyAdmin/vendor/symfony/polyfill-util/TestListener.php

@@ -0,0 +1,28 @@
+<?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\Util;
+
+if (class_exists('PHPUnit_Runner_Version') && version_compare(\PHPUnit_Runner_Version::id(), '6.0.0', '<')) {
+    class_alias('Symfony\Polyfill\Util\TestListenerForV5', 'Symfony\Polyfill\Util\TestListener');
+// Using an early return instead of a else does not work when using the PHPUnit phar due to some weird PHP behavior (the class
+// gets defined without executing the code before it and so the definition is not properly conditional)
+} elseif (version_compare(\PHPUnit\Runner\Version::id(), '7.0.0', '<')) {
+    class_alias('Symfony\Polyfill\Util\TestListenerForV6', 'Symfony\Polyfill\Util\TestListener');
+} else {
+    class_alias('Symfony\Polyfill\Util\TestListenerForV7', 'Symfony\Polyfill\Util\TestListener');
+}
+
+if (false) {
+    class TestListener
+    {
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/TestListenerForV5.php

@@ -0,0 +1,89 @@
+<?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\Util;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class TestListenerForV5 extends \PHPUnit_Framework_TestSuite implements \PHPUnit_Framework_TestListener
+{
+    private $suite;
+    private $trait;
+
+    public function __construct(\PHPUnit_Framework_TestSuite $suite = null)
+    {
+        if ($suite) {
+            $this->suite = $suite;
+            $this->setName($suite->getName().' with polyfills enabled');
+            $this->addTest($suite);
+        }
+        $this->trait = new TestListenerTrait();
+    }
+
+    public function startTestSuite(\PHPUnit_Framework_TestSuite $suite)
+    {
+        $this->trait->startTestSuite($suite);
+    }
+
+    public function addError(\PHPUnit_Framework_Test $test, \Exception $e, $time)
+    {
+        $this->trait->addError($test, $e, $time);
+    }
+
+    public function addWarning(\PHPUnit_Framework_Test $test, \PHPUnit_Framework_Warning $e, $time)
+    {
+    }
+
+    public function addFailure(\PHPUnit_Framework_Test $test, \PHPUnit_Framework_AssertionFailedError $e, $time)
+    {
+        $this->trait->addError($test, $e, $time);
+    }
+
+    public function addIncompleteTest(\PHPUnit_Framework_Test $test, \Exception $e, $time)
+    {
+    }
+
+    public function addRiskyTest(\PHPUnit_Framework_Test $test, \Exception $e, $time)
+    {
+    }
+
+    public function addSkippedTest(\PHPUnit_Framework_Test $test, \Exception $e, $time)
+    {
+    }
+
+    public function endTestSuite(\PHPUnit_Framework_TestSuite $suite)
+    {
+    }
+
+    public function startTest(\PHPUnit_Framework_Test $test)
+    {
+    }
+
+    public function endTest(\PHPUnit_Framework_Test $test, $time)
+    {
+    }
+
+    public static function warning($message)
+    {
+        return parent::warning($message);
+    }
+
+    protected function setUp()
+    {
+        TestListenerTrait::$enabledPolyfills = $this->suite->getName();
+    }
+
+    protected function tearDown()
+    {
+        TestListenerTrait::$enabledPolyfills = false;
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/TestListenerForV6.php

@@ -0,0 +1,95 @@
+<?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\Util;
+
+use PHPUnit\Framework\AssertionFailedError;
+use PHPUnit\Framework\Test;
+use PHPUnit\Framework\TestListener as TestListenerInterface;
+use PHPUnit\Framework\TestSuite;
+use PHPUnit\Framework\Warning;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class TestListenerForV6 extends TestSuite implements TestListenerInterface
+{
+    private $suite;
+    private $trait;
+
+    public function __construct(TestSuite $suite = null)
+    {
+        if ($suite) {
+            $this->suite = $suite;
+            $this->setName($suite->getName().' with polyfills enabled');
+            $this->addTest($suite);
+        }
+        $this->trait = new TestListenerTrait();
+    }
+
+    public function startTestSuite(TestSuite $suite)
+    {
+        $this->trait->startTestSuite($suite);
+    }
+
+    public function addError(Test $test, \Exception $e, $time)
+    {
+        $this->trait->addError($test, $e, $time);
+    }
+
+    public function addWarning(Test $test, Warning $e, $time)
+    {
+    }
+
+    public function addFailure(Test $test, AssertionFailedError $e, $time)
+    {
+        $this->trait->addError($test, $e, $time);
+    }
+
+    public function addIncompleteTest(Test $test, \Exception $e, $time)
+    {
+    }
+
+    public function addRiskyTest(Test $test, \Exception $e, $time)
+    {
+    }
+
+    public function addSkippedTest(Test $test, \Exception $e, $time)
+    {
+    }
+
+    public function endTestSuite(TestSuite $suite)
+    {
+    }
+
+    public function startTest(Test $test)
+    {
+    }
+
+    public function endTest(Test $test, $time)
+    {
+    }
+
+    public static function warning($message)
+    {
+        return parent::warning($message);
+    }
+
+    protected function setUp()
+    {
+        TestListenerTrait::$enabledPolyfills = $this->suite->getName();
+    }
+
+    protected function tearDown()
+    {
+        TestListenerTrait::$enabledPolyfills = false;
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/TestListenerForV7.php

@@ -0,0 +1,96 @@
+<?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\Util;
+
+use PHPUnit\Framework\AssertionFailedError;
+use PHPUnit\Framework\Test;
+use PHPUnit\Framework\TestListener as TestListenerInterface;
+use PHPUnit\Framework\TestSuite;
+use PHPUnit\Framework\Warning;
+use PHPUnit\Framework\WarningTestCase;
+
+/**
+ * @author Ion Bazan <ion.bazan@gmail.com>
+ */
+class TestListenerForV7 extends TestSuite implements TestListenerInterface
+{
+    private $suite;
+    private $trait;
+
+    public function __construct(TestSuite $suite = null)
+    {
+        if ($suite) {
+            $this->suite = $suite;
+            $this->setName($suite->getName().' with polyfills enabled');
+            $this->addTest($suite);
+        }
+        $this->trait = new TestListenerTrait();
+    }
+
+    public function startTestSuite(TestSuite $suite): void
+    {
+        $this->trait->startTestSuite($suite);
+    }
+
+    public function addError(Test $test, \Throwable $t, float $time): void
+    {
+        $this->trait->addError($test, $t, $time);
+    }
+
+    public function addWarning(Test $test, Warning $e, float $time): void
+    {
+    }
+
+    public function addFailure(Test $test, AssertionFailedError $e, float $time): void
+    {
+        $this->trait->addError($test, $e, $time);
+    }
+
+    public function addIncompleteTest(Test $test, \Throwable $t, float $time): void
+    {
+    }
+
+    public function addRiskyTest(Test $test, \Throwable $t, float $time): void
+    {
+    }
+
+    public function addSkippedTest(Test $test, \Throwable $t, float $time): void
+    {
+    }
+
+    public function endTestSuite(TestSuite $suite): void
+    {
+    }
+
+    public function startTest(Test $test): void
+    {
+    }
+
+    public function endTest(Test $test, float $time): void
+    {
+    }
+
+    public static function warning($message): WarningTestCase
+    {
+        return new WarningTestCase($message);
+    }
+
+    protected function setUp(): void
+    {
+        TestListenerTrait::$enabledPolyfills = $this->suite->getName();
+    }
+
+    protected function tearDown(): void
+    {
+        TestListenerTrait::$enabledPolyfills = false;
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/TestListenerTrait.php

@@ -0,0 +1,129 @@
+<?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\Util;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class TestListenerTrait
+{
+    public static $enabledPolyfills;
+
+    public function startTestSuite($mainSuite)
+    {
+        if (null !== self::$enabledPolyfills) {
+            return;
+        }
+        self::$enabledPolyfills = false;
+        $SkippedTestError = class_exists('PHPUnit\Framework\SkippedTestError') ? 'PHPUnit\Framework\SkippedTestError' : 'PHPUnit_Framework_SkippedTestError';
+
+        foreach ($mainSuite->tests() as $suite) {
+            $testClass = $suite->getName();
+            if (!$tests = $suite->tests()) {
+                continue;
+            }
+            $testedClass = new \ReflectionClass($testClass);
+            if (preg_match('{^ \* @requires PHP (.*)}mi', $testedClass->getDocComment(), $m) && version_compare($m[1], \PHP_VERSION, '>')) {
+                continue;
+            }
+            if (!preg_match('/^(.+)\\\\Tests(\\\\.*)Test$/', $testClass, $m)) {
+                $mainSuite->addTest(TestListener::warning('Unknown naming convention for '.$testClass));
+                continue;
+            }
+            if (!class_exists($m[1].$m[2])) {
+                continue;
+            }
+            $testedClass = new \ReflectionClass($m[1].$m[2]);
+            $bootstrap = new \SplFileObject(\dirname($testedClass->getFileName()).'/bootstrap.php');
+            $warnings = array();
+            $defLine = null;
+
+            foreach (new \RegexIterator($bootstrap, '/define\(\'/') as $defLine) {
+                preg_match('/define\(\'(?P<name>.+)\'/', $defLine, $matches);
+                if (\defined($matches['name'])) {
+                    continue;
+                }
+
+                try {
+                    eval($defLine);
+                } catch (\PHPUnit_Framework_Exception $ex){
+                    $warnings[] = TestListener::warning($ex->getMessage());
+                } catch (\PHPUnit\Framework\Exception $ex) {
+                    $warnings[] = TestListener::warning($ex->getMessage());
+                }
+            }
+
+            $bootstrap->rewind();
+
+            foreach (new \RegexIterator($bootstrap, '/return p\\\\'.$testedClass->getShortName().'::/') as $defLine) {
+                if (!preg_match('/^\s*function (?P<name>[^\(]++)(?P<signature>\(.*\)(?: ?: [^ ]++)?) \{ (?<return>return p\\\\'.$testedClass->getShortName().'::[^\(]++)(?P<args>\([^\)]*+\)); \}$/', $defLine, $f)) {
+                    $warnings[] = TestListener::warning('Invalid line in bootstrap.php: '.trim($defLine));
+                    continue;
+                }
+                $testNamespace = substr($testClass, 0, strrpos($testClass, '\\'));
+                if (\function_exists($testNamespace.'\\'.$f['name'])) {
+                    continue;
+                }
+
+                try {
+                    $r = new \ReflectionFunction($f['name']);
+                    if ($r->isUserDefined()) {
+                        throw new \ReflectionException();
+                    }
+                    if ('idn_to_ascii' === $f['name'] || 'idn_to_utf8' === $f['name']) {
+                        $defLine = sprintf('return INTL_IDNA_VARIANT_2003 === $variant ? \\%s($domain, $options, $variant) : \\%1$s%s', $f['name'], $f['args']);
+                    } elseif (false !== strpos($f['signature'], '&') && 'idn_to_ascii' !== $f['name'] && 'idn_to_utf8' !== $f['name']) {
+                        $defLine = sprintf('return \\%s%s', $f['name'], $f['args']);
+                    } else {
+                        $defLine = sprintf("return \\call_user_func_array('%s', \\func_get_args())", $f['name']);
+                    }
+                } catch (\ReflectionException $e) {
+                    $defLine = sprintf("throw new \\{$SkippedTestError}('Internal function not found: %s')", $f['name']);
+                }
+
+                eval(<<<EOPHP
+namespace {$testNamespace};
+
+use Symfony\Polyfill\Util\TestListenerTrait;
+use {$testedClass->getNamespaceName()} as p;
+
+function {$f['name']}{$f['signature']}
+{
+    if ('{$testClass}' === TestListenerTrait::\$enabledPolyfills) {
+        {$f['return']}{$f['args']};
+    }
+
+    {$defLine};
+}
+EOPHP
+                );
+            }
+            if (!$warnings && null === $defLine) {
+                $warnings[] = new $SkippedTestError('No Polyfills found in bootstrap.php for '.$testClass);
+            } else {
+                $mainSuite->addTest(new TestListener($suite));
+            }
+        }
+        foreach ($warnings as $w) {
+            $mainSuite->addTest($w);
+        }
+    }
+
+    public function addError($test, \Exception $e, $time)
+    {
+        if (false !== self::$enabledPolyfills) {
+            $r = new \ReflectionProperty('Exception', 'message');
+            $r->setAccessible(true);
+            $r->setValue($e, 'Polyfills enabled, '.$r->getValue($e));
+        }
+    }
+}

phpMyAdmin/vendor/symfony/polyfill-util/composer.json

@@ -0,0 +1,34 @@
+{
+    "name": "symfony/polyfill-util",
+    "type": "library",
+    "description": "Symfony utilities for portability of PHP codes",
+    "keywords": ["polyfill", "shim", "compat", "compatibility"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Grekas",
+            "email": "p@tchwork.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.3"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Polyfill\\Util\\": "" }
+    },
+    "minimum-stability": "dev",
+    "extra": {
+        "branch-alias": {
+            "dev-main": "1.19-dev"
+        },
+        "thanks": {
+            "name": "symfony/polyfill",
+            "url": "https://github.com/symfony/polyfill"
+        }
+    }
+}