phpmyadmin working

40 files changed, 4032 insertions, 0 deletions

diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/ClosureLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/ClosureLoader.php
new file mode 100644
index 0000000..939dd7c
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/ClosureLoader.php
@@ -0,0 +1,48 @@
+<?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\DependencyInjection\Loader;
+
+use Symfony\Component\Config\Loader\Loader;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * ClosureLoader loads service definitions from a PHP closure.
+ *
+ * The Closure has access to the container as its first argument.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class ClosureLoader extends Loader
+{
+    private $container;
+
+    public function __construct(ContainerBuilder $container)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function load($resource, $type = null)
+    {
+        $resource($this->container);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        return $resource instanceof \Closure;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AbstractConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AbstractConfigurator.php
new file mode 100644
index 0000000..c29ca7f
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AbstractConfigurator.php
@@ -0,0 +1,87 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Argument\ArgumentInterface;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Parameter;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\ExpressionLanguage\Expression;
+
+abstract class AbstractConfigurator
+{
+    const FACTORY = 'unknown';
+
+    /** @internal */
+    protected $definition;
+
+    public function __call($method, $args)
+    {
+        if (method_exists($this, 'set'.$method)) {
+            return $this->{'set'.$method}(...$args);
+        }
+
+        throw new \BadMethodCallException(sprintf('Call to undefined method %s::%s()', \get_class($this), $method));
+    }
+
+    /**
+     * Checks that a value is valid, optionally replacing Definition and Reference configurators by their configure value.
+     *
+     * @param mixed $value
+     * @param bool  $allowServices whether Definition and Reference are allowed; by default, only scalars and arrays are
+     *
+     * @return mixed the value, optionally cast to a Definition/Reference
+     */
+    public static function processValue($value, $allowServices = false)
+    {
+        if (\is_array($value)) {
+            foreach ($value as $k => $v) {
+                $value[$k] = static::processValue($v, $allowServices);
+            }
+
+            return $value;
+        }
+
+        if ($value instanceof ReferenceConfigurator) {
+            return new Reference($value->id, $value->invalidBehavior);
+        }
+
+        if ($value instanceof InlineServiceConfigurator) {
+            $def = $value->definition;
+            $value->definition = null;
+
+            return $def;
+        }
+
+        if ($value instanceof self) {
+            throw new InvalidArgumentException(sprintf('"%s()" can be used only at the root of service configuration files.', $value::FACTORY));
+        }
+
+        switch (true) {
+            case null === $value:
+            case is_scalar($value):
+                return $value;
+
+            case $value instanceof ArgumentInterface:
+            case $value instanceof Definition:
+            case $value instanceof Expression:
+            case $value instanceof Parameter:
+            case $value instanceof Reference:
+                if ($allowServices) {
+                    return $value;
+                }
+        }
+
+        throw new InvalidArgumentException(sprintf('Cannot use values of type "%s" in service configuration files.', \is_object($value) ? \get_class($value) : \gettype($value)));
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AbstractServiceConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AbstractServiceConfigurator.php
new file mode 100644
index 0000000..9d3305e
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AbstractServiceConfigurator.php
@@ -0,0 +1,93 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
+
+abstract class AbstractServiceConfigurator extends AbstractConfigurator
+{
+    protected $parent;
+    protected $id;
+    private $defaultTags = [];
+
+    public function __construct(ServicesConfigurator $parent, Definition $definition, string $id = null, array $defaultTags = [])
+    {
+        $this->parent = $parent;
+        $this->definition = $definition;
+        $this->id = $id;
+        $this->defaultTags = $defaultTags;
+    }
+
+    public function __destruct()
+    {
+        // default tags should be added last
+        foreach ($this->defaultTags as $name => $attributes) {
+            foreach ($attributes as $attributes) {
+                $this->definition->addTag($name, $attributes);
+            }
+        }
+        $this->defaultTags = [];
+    }
+
+    /**
+     * Registers a service.
+     */
+    final public function set(string $id, string $class = null): ServiceConfigurator
+    {
+        $this->__destruct();
+
+        return $this->parent->set($id, $class);
+    }
+
+    /**
+     * Creates an alias.
+     */
+    final public function alias(string $id, string $referencedId): AliasConfigurator
+    {
+        $this->__destruct();
+
+        return $this->parent->alias($id, $referencedId);
+    }
+
+    /**
+     * Registers a PSR-4 namespace using a glob pattern.
+     */
+    final public function load(string $namespace, string $resource): PrototypeConfigurator
+    {
+        $this->__destruct();
+
+        return $this->parent->load($namespace, $resource);
+    }
+
+    /**
+     * Gets an already defined service definition.
+     *
+     * @throws ServiceNotFoundException if the service definition does not exist
+     */
+    final public function get(string $id): ServiceConfigurator
+    {
+        $this->__destruct();
+
+        return $this->parent->get($id);
+    }
+
+    /**
+     * Registers a service.
+     */
+    final public function __invoke(string $id, string $class = null): ServiceConfigurator
+    {
+        $this->__destruct();
+
+        return $this->parent->set($id, $class);
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AliasConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AliasConfigurator.php
new file mode 100644
index 0000000..cb00f58
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/AliasConfigurator.php
@@ -0,0 +1,30 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Alias;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class AliasConfigurator extends AbstractServiceConfigurator
+{
+    const FACTORY = 'alias';
+
+    use Traits\PublicTrait;
+
+    public function __construct(ServicesConfigurator $parent, Alias $alias)
+    {
+        $this->parent = $parent;
+        $this->definition = $alias;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ContainerConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ContainerConfigurator.php
new file mode 100644
index 0000000..712d8c9
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ContainerConfigurator.php
@@ -0,0 +1,144 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
+use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
+use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
+use Symfony\Component\ExpressionLanguage\Expression;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ContainerConfigurator extends AbstractConfigurator
+{
+    const FACTORY = 'container';
+
+    private $container;
+    private $loader;
+    private $instanceof;
+    private $path;
+    private $file;
+    private $anonymousCount = 0;
+
+    public function __construct(ContainerBuilder $container, PhpFileLoader $loader, array &$instanceof, string $path, string $file)
+    {
+        $this->container = $container;
+        $this->loader = $loader;
+        $this->instanceof = &$instanceof;
+        $this->path = $path;
+        $this->file = $file;
+    }
+
+    final public function extension(string $namespace, array $config)
+    {
+        if (!$this->container->hasExtension($namespace)) {
+            $extensions = array_filter(array_map(function (ExtensionInterface $ext) { return $ext->getAlias(); }, $this->container->getExtensions()));
+            throw new InvalidArgumentException(sprintf('There is no extension able to load the configuration for "%s" (in %s). Looked for namespace "%s", found %s', $namespace, $this->file, $namespace, $extensions ? sprintf('"%s"', implode('", "', $extensions)) : 'none'));
+        }
+
+        $this->container->loadFromExtension($namespace, static::processValue($config));
+    }
+
+    final public function import(string $resource, string $type = null, $ignoreErrors = false)
+    {
+        $this->loader->setCurrentDir(\dirname($this->path));
+        $this->loader->import($resource, $type, $ignoreErrors, $this->file);
+    }
+
+    final public function parameters(): ParametersConfigurator
+    {
+        return new ParametersConfigurator($this->container);
+    }
+
+    final public function services(): ServicesConfigurator
+    {
+        return new ServicesConfigurator($this->container, $this->loader, $this->instanceof, $this->path, $this->anonymousCount);
+    }
+}
+
+/**
+ * Creates a service reference.
+ */
+function ref(string $id): ReferenceConfigurator
+{
+    return new ReferenceConfigurator($id);
+}
+
+/**
+ * Creates an inline service.
+ */
+function inline(string $class = null): InlineServiceConfigurator
+{
+    return new InlineServiceConfigurator(new Definition($class));
+}
+
+/**
+ * Creates a service locator.
+ *
+ * @param ReferenceConfigurator[] $values
+ */
+function service_locator(array $values): ServiceLocatorArgument
+{
+    return new ServiceLocatorArgument(AbstractConfigurator::processValue($values, true));
+}
+
+/**
+ * Creates a lazy iterator.
+ *
+ * @param ReferenceConfigurator[] $values
+ */
+function iterator(array $values): IteratorArgument
+{
+    return new IteratorArgument(AbstractConfigurator::processValue($values, true));
+}
+
+/**
+ * Creates a lazy iterator by tag name.
+ *
+ * @deprecated since Symfony 4.4, to be removed in 5.0, use "tagged_iterator" instead.
+ */
+function tagged(string $tag, string $indexAttribute = null, string $defaultIndexMethod = null): TaggedIteratorArgument
+{
+    @trigger_error(__NAMESPACE__.'\tagged() is deprecated since Symfony 4.4 and will be removed in 5.0, use '.__NAMESPACE__.'\tagged_iterator() instead.', E_USER_DEPRECATED);
+
+    return new TaggedIteratorArgument($tag, $indexAttribute, $defaultIndexMethod);
+}
+
+/**
+ * Creates a lazy iterator by tag name.
+ */
+function tagged_iterator(string $tag, string $indexAttribute = null, string $defaultIndexMethod = null, string $defaultPriorityMethod = null): TaggedIteratorArgument
+{
+    return new TaggedIteratorArgument($tag, $indexAttribute, $defaultIndexMethod, false, $defaultPriorityMethod);
+}
+
+/**
+ * Creates a service locator by tag name.
+ */
+function tagged_locator(string $tag, string $indexAttribute = null, string $defaultIndexMethod = null): ServiceLocatorArgument
+{
+    return new ServiceLocatorArgument(new TaggedIteratorArgument($tag, $indexAttribute, $defaultIndexMethod, true));
+}
+
+/**
+ * Creates an expression.
+ */
+function expr(string $expression): Expression
+{
+    return new Expression($expression);
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/DefaultsConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/DefaultsConfigurator.php
new file mode 100644
index 0000000..cd9088f
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/DefaultsConfigurator.php
@@ -0,0 +1,69 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class DefaultsConfigurator extends AbstractServiceConfigurator
+{
+    const FACTORY = 'defaults';
+
+    use Traits\AutoconfigureTrait;
+    use Traits\AutowireTrait;
+    use Traits\BindTrait;
+    use Traits\PublicTrait;
+
+    private $path;
+
+    public function __construct(ServicesConfigurator $parent, Definition $definition, string $path = null)
+    {
+        parent::__construct($parent, $definition, null, []);
+
+        $this->path = $path;
+    }
+
+    /**
+     * Adds a tag for this definition.
+     *
+     * @return $this
+     *
+     * @throws InvalidArgumentException when an invalid tag name or attribute is provided
+     */
+    final public function tag(string $name, array $attributes = []): self
+    {
+        if ('' === $name) {
+            throw new InvalidArgumentException('The tag name in "_defaults" must be a non-empty string.');
+        }
+
+        foreach ($attributes as $attribute => $value) {
+            if (null !== $value && !is_scalar($value)) {
+                throw new InvalidArgumentException(sprintf('Tag "%s", attribute "%s" in "_defaults" must be of a scalar-type.', $name, $attribute));
+            }
+        }
+
+        $this->definition->addTag($name, $attributes);
+
+        return $this;
+    }
+
+    /**
+     * Defines an instanceof-conditional to be applied to following service definitions.
+     */
+    final public function instanceof(string $fqcn): InstanceofConfigurator
+    {
+        return $this->parent->instanceof($fqcn);
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/InlineServiceConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/InlineServiceConfigurator.php
new file mode 100644
index 0000000..362b374
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/InlineServiceConfigurator.php
@@ -0,0 +1,36 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Definition;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class InlineServiceConfigurator extends AbstractConfigurator
+{
+    const FACTORY = 'inline';
+
+    use Traits\ArgumentTrait;
+    use Traits\AutowireTrait;
+    use Traits\BindTrait;
+    use Traits\FactoryTrait;
+    use Traits\FileTrait;
+    use Traits\LazyTrait;
+    use Traits\ParentTrait;
+    use Traits\TagTrait;
+
+    public function __construct(Definition $definition)
+    {
+        $this->definition = $definition;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/InstanceofConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/InstanceofConfigurator.php
new file mode 100644
index 0000000..f75e176
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/InstanceofConfigurator.php
@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Definition;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class InstanceofConfigurator extends AbstractServiceConfigurator
+{
+    const FACTORY = 'instanceof';
+
+    use Traits\AutowireTrait;
+    use Traits\CallTrait;
+    use Traits\ConfiguratorTrait;
+    use Traits\LazyTrait;
+    use Traits\PropertyTrait;
+    use Traits\PublicTrait;
+    use Traits\ShareTrait;
+    use Traits\TagTrait;
+    use Traits\BindTrait;
+
+    private $path;
+
+    public function __construct(ServicesConfigurator $parent, Definition $definition, string $id, string $path = null)
+    {
+        parent::__construct($parent, $definition, $id, []);
+
+        $this->path = $path;
+    }
+
+    /**
+     * Defines an instanceof-conditional to be applied to following service definitions.
+     */
+    final public function instanceof(string $fqcn): self
+    {
+        return $this->parent->instanceof($fqcn);
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ParametersConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ParametersConfigurator.php
new file mode 100644
index 0000000..a88d28e
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ParametersConfigurator.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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ParametersConfigurator extends AbstractConfigurator
+{
+    const FACTORY = 'parameters';
+
+    private $container;
+
+    public function __construct(ContainerBuilder $container)
+    {
+        $this->container = $container;
+    }
+
+    /**
+     * Creates a parameter.
+     *
+     * @return $this
+     */
+    final public function set(string $name, $value): self
+    {
+        $this->container->setParameter($name, static::processValue($value, true));
+
+        return $this;
+    }
+
+    /**
+     * Creates a parameter.
+     *
+     * @return $this
+     */
+    final public function __invoke(string $name, $value): self
+    {
+        return $this->set($name, $value);
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/PrototypeConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/PrototypeConfigurator.php
new file mode 100644
index 0000000..3cd56e0
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/PrototypeConfigurator.php
@@ -0,0 +1,84 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class PrototypeConfigurator extends AbstractServiceConfigurator
+{
+    const FACTORY = 'load';
+
+    use Traits\AbstractTrait;
+    use Traits\ArgumentTrait;
+    use Traits\AutoconfigureTrait;
+    use Traits\AutowireTrait;
+    use Traits\BindTrait;
+    use Traits\CallTrait;
+    use Traits\ConfiguratorTrait;
+    use Traits\DeprecateTrait;
+    use Traits\FactoryTrait;
+    use Traits\LazyTrait;
+    use Traits\ParentTrait;
+    use Traits\PropertyTrait;
+    use Traits\PublicTrait;
+    use Traits\ShareTrait;
+    use Traits\TagTrait;
+
+    private $loader;
+    private $resource;
+    private $excludes;
+    private $allowParent;
+
+    public function __construct(ServicesConfigurator $parent, PhpFileLoader $loader, Definition $defaults, string $namespace, string $resource, bool $allowParent)
+    {
+        $definition = new Definition();
+        $definition->setPublic($defaults->isPublic());
+        $definition->setAutowired($defaults->isAutowired());
+        $definition->setAutoconfigured($defaults->isAutoconfigured());
+        $definition->setBindings($defaults->getBindings());
+        $definition->setChanges([]);
+
+        $this->loader = $loader;
+        $this->resource = $resource;
+        $this->allowParent = $allowParent;
+
+        parent::__construct($parent, $definition, $namespace, $defaults->getTags());
+    }
+
+    public function __destruct()
+    {
+        parent::__destruct();
+
+        if ($this->loader) {
+            $this->loader->registerClasses($this->definition, $this->id, $this->resource, $this->excludes);
+        }
+        $this->loader = null;
+    }
+
+    /**
+     * Excludes files from registration using glob patterns.
+     *
+     * @param string[]|string $excludes
+     *
+     * @return $this
+     */
+    final public function exclude($excludes): self
+    {
+        $this->excludes = (array) $excludes;
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ReferenceConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ReferenceConfigurator.php
new file mode 100644
index 0000000..fa04253
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ReferenceConfigurator.php
@@ -0,0 +1,69 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ReferenceConfigurator extends AbstractConfigurator
+{
+    /** @internal */
+    protected $id;
+
+    /** @internal */
+    protected $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+
+    public function __construct(string $id)
+    {
+        $this->id = $id;
+    }
+
+    /**
+     * @return $this
+     */
+    final public function ignoreOnInvalid(): self
+    {
+        $this->invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    final public function nullOnInvalid(): self
+    {
+        $this->invalidBehavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    final public function ignoreOnUninitialized(): self
+    {
+        $this->invalidBehavior = ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE;
+
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->id;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ServiceConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ServiceConfigurator.php
new file mode 100644
index 0000000..f1a6af7
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ServiceConfigurator.php
@@ -0,0 +1,72 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ServiceConfigurator extends AbstractServiceConfigurator
+{
+    const FACTORY = 'services';
+
+    use Traits\AbstractTrait;
+    use Traits\ArgumentTrait;
+    use Traits\AutoconfigureTrait;
+    use Traits\AutowireTrait;
+    use Traits\BindTrait;
+    use Traits\CallTrait;
+    use Traits\ClassTrait;
+    use Traits\ConfiguratorTrait;
+    use Traits\DecorateTrait;
+    use Traits\DeprecateTrait;
+    use Traits\FactoryTrait;
+    use Traits\FileTrait;
+    use Traits\LazyTrait;
+    use Traits\ParentTrait;
+    use Traits\PropertyTrait;
+    use Traits\PublicTrait;
+    use Traits\ShareTrait;
+    use Traits\SyntheticTrait;
+    use Traits\TagTrait;
+
+    private $container;
+    private $instanceof;
+    private $allowParent;
+    private $path;
+
+    public function __construct(ContainerBuilder $container, array $instanceof, bool $allowParent, ServicesConfigurator $parent, Definition $definition, $id, array $defaultTags, string $path = null)
+    {
+        $this->container = $container;
+        $this->instanceof = $instanceof;
+        $this->allowParent = $allowParent;
+        $this->path = $path;
+
+        parent::__construct($parent, $definition, $id, $defaultTags);
+    }
+
+    public function __destruct()
+    {
+        parent::__destruct();
+
+        $this->container->removeBindings($this->id);
+
+        if (!$this->definition instanceof ChildDefinition) {
+            $this->container->setDefinition($this->id, $this->definition->setInstanceofConditionals($this->instanceof));
+        } else {
+            $this->container->setDefinition($this->id, $this->definition);
+        }
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ServicesConfigurator.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ServicesConfigurator.php
new file mode 100644
index 0000000..f0fdde8
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/ServicesConfigurator.php
@@ -0,0 +1,147 @@
+<?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\DependencyInjection\Loader\Configurator;
+
+use Symfony\Component\DependencyInjection\Alias;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException;
+use Symfony\Component\DependencyInjection\Loader\PhpFileLoader;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class ServicesConfigurator extends AbstractConfigurator
+{
+    const FACTORY = 'services';
+
+    private $defaults;
+    private $container;
+    private $loader;
+    private $instanceof;
+    private $path;
+    private $anonymousHash;
+    private $anonymousCount;
+
+    public function __construct(ContainerBuilder $container, PhpFileLoader $loader, array &$instanceof, string $path = null, int &$anonymousCount = 0)
+    {
+        $this->defaults = new Definition();
+        $this->container = $container;
+        $this->loader = $loader;
+        $this->instanceof = &$instanceof;
+        $this->path = $path;
+        $this->anonymousHash = ContainerBuilder::hash($path ?: mt_rand());
+        $this->anonymousCount = &$anonymousCount;
+        $instanceof = [];
+    }
+
+    /**
+     * Defines a set of defaults for following service definitions.
+     */
+    final public function defaults(): DefaultsConfigurator
+    {
+        return new DefaultsConfigurator($this, $this->defaults = new Definition(), $this->path);
+    }
+
+    /**
+     * Defines an instanceof-conditional to be applied to following service definitions.
+     */
+    final public function instanceof(string $fqcn): InstanceofConfigurator
+    {
+        $this->instanceof[$fqcn] = $definition = new ChildDefinition('');
+
+        return new InstanceofConfigurator($this, $definition, $fqcn, $this->path);
+    }
+
+    /**
+     * Registers a service.
+     *
+     * @param string|null $id    The service id, or null to create an anonymous service
+     * @param string|null $class The class of the service, or null when $id is also the class name
+     */
+    final public function set(?string $id, string $class = null): ServiceConfigurator
+    {
+        $defaults = $this->defaults;
+        $allowParent = !$defaults->getChanges() && empty($this->instanceof);
+
+        $definition = new Definition();
+
+        if (null === $id) {
+            if (!$class) {
+                throw new \LogicException('Anonymous services must have a class name.');
+            }
+
+            $id = sprintf('.%d_%s', ++$this->anonymousCount, preg_replace('/^.*\\\\/', '', $class).'~'.$this->anonymousHash);
+            $definition->setPublic(false);
+        } else {
+            $definition->setPublic($defaults->isPublic());
+        }
+
+        $definition->setAutowired($defaults->isAutowired());
+        $definition->setAutoconfigured($defaults->isAutoconfigured());
+        $definition->setBindings($defaults->getBindings());
+        $definition->setChanges([]);
+
+        $configurator = new ServiceConfigurator($this->container, $this->instanceof, $allowParent, $this, $definition, $id, $defaults->getTags(), $this->path);
+
+        return null !== $class ? $configurator->class($class) : $configurator;
+    }
+
+    /**
+     * Creates an alias.
+     */
+    final public function alias(string $id, string $referencedId): AliasConfigurator
+    {
+        $ref = static::processValue($referencedId, true);
+        $alias = new Alias((string) $ref, $this->defaults->isPublic());
+        $this->container->setAlias($id, $alias);
+
+        return new AliasConfigurator($this, $alias);
+    }
+
+    /**
+     * Registers a PSR-4 namespace using a glob pattern.
+     */
+    final public function load(string $namespace, string $resource): PrototypeConfigurator
+    {
+        $allowParent = !$this->defaults->getChanges() && empty($this->instanceof);
+
+        return new PrototypeConfigurator($this, $this->loader, $this->defaults, $namespace, $resource, $allowParent);
+    }
+
+    /**
+     * Gets an already defined service definition.
+     *
+     * @throws ServiceNotFoundException if the service definition does not exist
+     */
+    final public function get(string $id): ServiceConfigurator
+    {
+        $allowParent = !$this->defaults->getChanges() && empty($this->instanceof);
+        $definition = $this->container->getDefinition($id);
+
+        return new ServiceConfigurator($this->container, $definition->getInstanceofConditionals(), $allowParent, $this, $definition, $id, []);
+    }
+
+    /**
+     * Registers a service.
+     */
+    final public function __invoke(string $id, string $class = null): ServiceConfigurator
+    {
+        return $this->set($id, $class);
+    }
+
+    public function __destruct()
+    {
+        $this->loader->registerAliasesForSinglyImplementedInterfaces();
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AbstractTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AbstractTrait.php
new file mode 100644
index 0000000..82ba21d
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AbstractTrait.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\Component\DependencyInjection\Loader\Configurator\Traits;
+
+trait AbstractTrait
+{
+    /**
+     * Whether this definition is abstract, that means it merely serves as a
+     * template for other definitions.
+     *
+     * @return $this
+     */
+    final public function abstract(bool $abstract = true): self
+    {
+        $this->definition->setAbstract($abstract);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ArgumentTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ArgumentTrait.php
new file mode 100644
index 0000000..5c9a475
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ArgumentTrait.php
@@ -0,0 +1,42 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+trait ArgumentTrait
+{
+    /**
+     * Sets the arguments to pass to the service constructor/factory method.
+     *
+     * @return $this
+     */
+    final public function args(array $arguments): self
+    {
+        $this->definition->setArguments(static::processValue($arguments, true));
+
+        return $this;
+    }
+
+    /**
+     * Sets one argument to pass to the service constructor/factory method.
+     *
+     * @param string|int $key
+     * @param mixed      $value
+     *
+     * @return $this
+     */
+    final public function arg($key, $value): self
+    {
+        $this->definition->setArgument($key, static::processValue($value, true));
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AutoconfigureTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AutoconfigureTrait.php
new file mode 100644
index 0000000..836f458
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AutoconfigureTrait.php
@@ -0,0 +1,35 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+trait AutoconfigureTrait
+{
+    /**
+     * Sets whether or not instanceof conditionals should be prepended with a global set.
+     *
+     * @return $this
+     *
+     * @throws InvalidArgumentException when a parent is already set
+     */
+    final public function autoconfigure(bool $autoconfigured = true): self
+    {
+        if ($autoconfigured && $this->definition instanceof ChildDefinition) {
+            throw new InvalidArgumentException(sprintf('The service "%s" cannot have a "parent" and also have "autoconfigure". Try disabling autoconfiguration for the service.', $this->id));
+        }
+        $this->definition->setAutoconfigured($autoconfigured);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AutowireTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AutowireTrait.php
new file mode 100644
index 0000000..2837a02
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/AutowireTrait.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\DependencyInjection\Loader\Configurator\Traits;
+
+trait AutowireTrait
+{
+    /**
+     * Enables/disables autowiring.
+     *
+     * @return $this
+     */
+    final public function autowire(bool $autowired = true): self
+    {
+        $this->definition->setAutowired($autowired);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/BindTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/BindTrait.php
new file mode 100644
index 0000000..1328494
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/BindTrait.php
@@ -0,0 +1,47 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\Argument\BoundArgument;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Loader\Configurator\DefaultsConfigurator;
+use Symfony\Component\DependencyInjection\Loader\Configurator\InstanceofConfigurator;
+use Symfony\Component\DependencyInjection\Reference;
+
+trait BindTrait
+{
+    /**
+     * Sets bindings.
+     *
+     * Bindings map $named or FQCN arguments to values that should be
+     * injected in the matching parameters (of the constructor, of methods
+     * called and of controller actions).
+     *
+     * @param string $nameOrFqcn A parameter name with its "$" prefix, or a FQCN
+     * @param mixed  $valueOrRef The value or reference to bind
+     *
+     * @return $this
+     */
+    final public function bind(string $nameOrFqcn, $valueOrRef): self
+    {
+        $valueOrRef = static::processValue($valueOrRef, true);
+        if (!preg_match('/^(?:(?:array|bool|float|int|string)[ \t]*+)?\$/', $nameOrFqcn) && !$valueOrRef instanceof Reference) {
+            throw new InvalidArgumentException(sprintf('Invalid binding for service "%s": named arguments must start with a "$", and FQCN must map to references. Neither applies to binding "%s".', $this->id, $nameOrFqcn));
+        }
+        $bindings = $this->definition->getBindings();
+        $type = $this instanceof DefaultsConfigurator ? BoundArgument::DEFAULTS_BINDING : ($this instanceof InstanceofConfigurator ? BoundArgument::INSTANCEOF_BINDING : BoundArgument::SERVICE_BINDING);
+        $bindings[$nameOrFqcn] = new BoundArgument($valueOrRef, true, $type, $this->path ?? null);
+        $this->definition->setBindings($bindings);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/CallTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/CallTrait.php
new file mode 100644
index 0000000..28f92d2
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/CallTrait.php
@@ -0,0 +1,35 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+trait CallTrait
+{
+    /**
+     * Adds a method to call after service initialization.
+     *
+     * @param string $method       The method name to call
+     * @param array  $arguments    An array of arguments to pass to the method call
+     * @param bool   $returnsClone Whether the call returns the service instance or not
+     *
+     * @return $this
+     *
+     * @throws InvalidArgumentException on empty $method param
+     */
+    final public function call(string $method, array $arguments = [], bool $returnsClone = false): self
+    {
+        $this->definition->addMethodCall($method, static::processValue($arguments, true), $returnsClone);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ClassTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ClassTrait.php
new file mode 100644
index 0000000..20da791
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ClassTrait.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\DependencyInjection\Loader\Configurator\Traits;
+
+trait ClassTrait
+{
+    /**
+     * Sets the service class.
+     *
+     * @return $this
+     */
+    final public function class(?string $class): self
+    {
+        $this->definition->setClass($class);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ConfiguratorTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ConfiguratorTrait.php
new file mode 100644
index 0000000..25d363c
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ConfiguratorTrait.php
@@ -0,0 +1,29 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+trait ConfiguratorTrait
+{
+    /**
+     * Sets a configurator to call after the service is fully initialized.
+     *
+     * @param string|array $configurator A PHP callable reference
+     *
+     * @return $this
+     */
+    final public function configurator($configurator): self
+    {
+        $this->definition->setConfigurator(static::processValue($configurator, true));
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/DecorateTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/DecorateTrait.php
new file mode 100644
index 0000000..222cf75
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/DecorateTrait.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\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+trait DecorateTrait
+{
+    /**
+     * Sets the service that this service is decorating.
+     *
+     * @param string|null $id              The decorated service id, use null to remove decoration
+     * @param string|null $renamedId       The new decorated service id
+     * @param int         $priority        The priority of decoration
+     * @param int         $invalidBehavior The behavior to adopt when decorated is invalid
+     *
+     * @return $this
+     *
+     * @throws InvalidArgumentException in case the decorated service id and the new decorated service id are equals
+     */
+    final public function decorate(?string $id, string $renamedId = null, int $priority = 0, int $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE): self
+    {
+        $this->definition->setDecoratedService($id, $renamedId, $priority, $invalidBehavior);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/DeprecateTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/DeprecateTrait.php
new file mode 100644
index 0000000..b2d5b0e
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/DeprecateTrait.php
@@ -0,0 +1,33 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+trait DeprecateTrait
+{
+    /**
+     * Whether this definition is deprecated, that means it should not be called anymore.
+     *
+     * @param string $template Template message to use if the definition is deprecated
+     *
+     * @return $this
+     *
+     * @throws InvalidArgumentException when the message template is invalid
+     */
+    final public function deprecate(string $template = null): self
+    {
+        $this->definition->setDeprecated(true, $template);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/FactoryTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/FactoryTrait.php
new file mode 100644
index 0000000..3834d72
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/FactoryTrait.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\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+trait FactoryTrait
+{
+    /**
+     * Sets a factory.
+     *
+     * @param string|array $factory A PHP callable reference
+     *
+     * @return $this
+     */
+    final public function factory($factory): self
+    {
+        if (\is_string($factory) && 1 === substr_count($factory, ':')) {
+            $factoryParts = explode(':', $factory);
+
+            throw new InvalidArgumentException(sprintf('Invalid factory "%s": the "service:method" notation is not available when using PHP-based DI configuration. Use "[ref(\'%s\'), \'%s\']" instead.', $factory, $factoryParts[0], $factoryParts[1]));
+        }
+
+        $this->definition->setFactory(static::processValue($factory, true));
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/FileTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/FileTrait.php
new file mode 100644
index 0000000..5f42aef
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/FileTrait.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\DependencyInjection\Loader\Configurator\Traits;
+
+trait FileTrait
+{
+    /**
+     * Sets a file to require before creating the service.
+     *
+     * @return $this
+     */
+    final public function file(string $file): self
+    {
+        $this->definition->setFile($file);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/LazyTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/LazyTrait.php
new file mode 100644
index 0000000..2829def
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/LazyTrait.php
@@ -0,0 +1,32 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+trait LazyTrait
+{
+    /**
+     * Sets the lazy flag of this service.
+     *
+     * @param bool|string $lazy A FQCN to derivate the lazy proxy from or `true` to make it extend from the definition's class
+     *
+     * @return $this
+     */
+    final public function lazy($lazy = true): self
+    {
+        $this->definition->setLazy((bool) $lazy);
+        if (\is_string($lazy)) {
+            $this->definition->addTag('proxy', ['interface' => $lazy]);
+        }
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ParentTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ParentTrait.php
new file mode 100644
index 0000000..7488a38
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ParentTrait.php
@@ -0,0 +1,50 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+trait ParentTrait
+{
+    /**
+     * Sets the Definition to inherit from.
+     *
+     * @return $this
+     *
+     * @throws InvalidArgumentException when parent cannot be set
+     */
+    final public function parent(string $parent): self
+    {
+        if (!$this->allowParent) {
+            throw new InvalidArgumentException(sprintf('A parent cannot be defined when either "_instanceof" or "_defaults" are also defined for service prototype "%s".', $this->id));
+        }
+
+        if ($this->definition instanceof ChildDefinition) {
+            $this->definition->setParent($parent);
+        } elseif ($this->definition->isAutoconfigured()) {
+            throw new InvalidArgumentException(sprintf('The service "%s" cannot have a "parent" and also have "autoconfigure". Try disabling autoconfiguration for the service.', $this->id));
+        } elseif ($this->definition->getBindings()) {
+            throw new InvalidArgumentException(sprintf('The service "%s" cannot have a "parent" and also "bind" arguments.', $this->id));
+        } else {
+            // cast Definition to ChildDefinition
+            $definition = serialize($this->definition);
+            $definition = substr_replace($definition, '53', 2, 2);
+            $definition = substr_replace($definition, 'Child', 44, 0);
+            $definition = unserialize($definition);
+
+            $this->definition = $definition->setParent($parent);
+        }
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/PropertyTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/PropertyTrait.php
new file mode 100644
index 0000000..10fdcfb
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/PropertyTrait.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\DependencyInjection\Loader\Configurator\Traits;
+
+trait PropertyTrait
+{
+    /**
+     * Sets a specific property.
+     *
+     * @return $this
+     */
+    final public function property(string $name, $value): self
+    {
+        $this->definition->setProperty($name, static::processValue($value, true));
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/PublicTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/PublicTrait.php
new file mode 100644
index 0000000..f15756c
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/PublicTrait.php
@@ -0,0 +1,35 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+trait PublicTrait
+{
+    /**
+     * @return $this
+     */
+    final public function public(): self
+    {
+        $this->definition->setPublic(true);
+
+        return $this;
+    }
+
+    /**
+     * @return $this
+     */
+    final public function private(): self
+    {
+        $this->definition->setPublic(false);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ShareTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ShareTrait.php
new file mode 100644
index 0000000..16fde0f
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/ShareTrait.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\DependencyInjection\Loader\Configurator\Traits;
+
+trait ShareTrait
+{
+    /**
+     * Sets if the service must be shared or not.
+     *
+     * @return $this
+     */
+    final public function share(bool $shared = true): self
+    {
+        $this->definition->setShared($shared);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/SyntheticTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/SyntheticTrait.php
new file mode 100644
index 0000000..cb08b11
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/SyntheticTrait.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\Component\DependencyInjection\Loader\Configurator\Traits;
+
+trait SyntheticTrait
+{
+    /**
+     * Sets whether this definition is synthetic, that is not constructed by the
+     * container, but dynamically injected.
+     *
+     * @return $this
+     */
+    final public function synthetic(bool $synthetic = true): self
+    {
+        $this->definition->setSynthetic($synthetic);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/TagTrait.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/TagTrait.php
new file mode 100644
index 0000000..f4d5f00
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/Configurator/Traits/TagTrait.php
@@ -0,0 +1,39 @@
+<?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\DependencyInjection\Loader\Configurator\Traits;
+
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+trait TagTrait
+{
+    /**
+     * Adds a tag for this definition.
+     *
+     * @return $this
+     */
+    final public function tag(string $name, array $attributes = []): self
+    {
+        if ('' === $name) {
+            throw new InvalidArgumentException(sprintf('The tag name for service "%s" must be a non-empty string.', $this->id));
+        }
+
+        foreach ($attributes as $attribute => $value) {
+            if (!is_scalar($value) && null !== $value) {
+                throw new InvalidArgumentException(sprintf('A tag attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s".', $this->id, $name, $attribute));
+            }
+        }
+
+        $this->definition->addTag($name, $attributes);
+
+        return $this;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/DirectoryLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/DirectoryLoader.php
new file mode 100644
index 0000000..a57cac3
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/DirectoryLoader.php
@@ -0,0 +1,54 @@
+<?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\DependencyInjection\Loader;
+
+/**
+ * DirectoryLoader is a recursive loader to go through directories.
+ *
+ * @author Sebastien Lavoie <seb@wemakecustom.com>
+ */
+class DirectoryLoader extends FileLoader
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function load($file, $type = null)
+    {
+        $file = rtrim($file, '/');
+        $path = $this->locator->locate($file);
+        $this->container->fileExists($path, false);
+
+        foreach (scandir($path) as $dir) {
+            if ('.' !== $dir[0]) {
+                if (is_dir($path.'/'.$dir)) {
+                    $dir .= '/'; // append / to allow recursion
+                }
+
+                $this->setCurrentDir($path);
+
+                $this->import($dir, null, false, $path);
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        if ('directory' === $type) {
+            return true;
+        }
+
+        return null === $type && \is_string($resource) && '/' === substr($resource, -1);
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/FileLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/FileLoader.php
new file mode 100644
index 0000000..d6f6fae
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/FileLoader.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\Component\DependencyInjection\Loader;
+
+use Symfony\Component\Config\Exception\FileLocatorFileNotFoundException;
+use Symfony\Component\Config\Exception\LoaderLoadException;
+use Symfony\Component\Config\FileLocatorInterface;
+use Symfony\Component\Config\Loader\FileLoader as BaseFileLoader;
+use Symfony\Component\Config\Loader\Loader;
+use Symfony\Component\Config\Resource\GlobResource;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+/**
+ * FileLoader is the abstract class used by all built-in loaders that are file based.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+abstract class FileLoader extends BaseFileLoader
+{
+    public const ANONYMOUS_ID_REGEXP = '/^\.\d+_[^~]*+~[._a-zA-Z\d]{7}$/';
+
+    protected $container;
+    protected $isLoadingInstanceof = false;
+    protected $instanceof = [];
+    protected $interfaces = [];
+    protected $singlyImplemented = [];
+    protected $autoRegisterAliasesForSinglyImplementedInterfaces = true;
+
+    public function __construct(ContainerBuilder $container, FileLocatorInterface $locator)
+    {
+        $this->container = $container;
+
+        parent::__construct($locator);
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @param bool|string          $ignoreErrors Whether errors should be ignored; pass "not_found" to ignore only when the loaded resource is not found
+     * @param string|string[]|null $exclude      Glob patterns to exclude from the import
+     */
+    public function import($resource, $type = null, $ignoreErrors = false, $sourceResource = null/*, $exclude = null*/)
+    {
+        $args = \func_get_args();
+
+        if ($ignoreNotFound = 'not_found' === $ignoreErrors) {
+            $args[2] = false;
+        } elseif (!\is_bool($ignoreErrors)) {
+            @trigger_error(sprintf('Invalid argument $ignoreErrors provided to %s::import(): boolean or "not_found" expected, %s given.', \get_class($this), \gettype($ignoreErrors)), E_USER_DEPRECATED);
+            $args[2] = (bool) $ignoreErrors;
+        }
+
+        try {
+            parent::import(...$args);
+        } catch (LoaderLoadException $e) {
+            if (!$ignoreNotFound || !($prev = $e->getPrevious()) instanceof FileLocatorFileNotFoundException) {
+                throw $e;
+            }
+
+            foreach ($prev->getTrace() as $frame) {
+                if ('import' === ($frame['function'] ?? null) && is_a($frame['class'] ?? '', Loader::class, true)) {
+                    break;
+                }
+            }
+
+            if (__FILE__ !== $frame['file']) {
+                throw $e;
+            }
+        }
+    }
+
+    /**
+     * Registers a set of classes as services using PSR-4 for discovery.
+     *
+     * @param Definition           $prototype A definition to use as template
+     * @param string               $namespace The namespace prefix of classes in the scanned directory
+     * @param string               $resource  The directory to look for classes, glob-patterns allowed
+     * @param string|string[]|null $exclude   A globbed path of files to exclude or an array of globbed paths of files to exclude
+     */
+    public function registerClasses(Definition $prototype, $namespace, $resource, $exclude = null)
+    {
+        if ('\\' !== substr($namespace, -1)) {
+            throw new InvalidArgumentException(sprintf('Namespace prefix must end with a "\\": %s.', $namespace));
+        }
+        if (!preg_match('/^(?:[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+\\\\)++$/', $namespace)) {
+            throw new InvalidArgumentException(sprintf('Namespace is not a valid PSR-4 prefix: %s.', $namespace));
+        }
+
+        $classes = $this->findClasses($namespace, $resource, (array) $exclude);
+        // prepare for deep cloning
+        $serializedPrototype = serialize($prototype);
+
+        foreach ($classes as $class => $errorMessage) {
+            if (interface_exists($class, false)) {
+                $this->interfaces[] = $class;
+            } else {
+                $this->setDefinition($class, $definition = unserialize($serializedPrototype));
+                if (null !== $errorMessage) {
+                    $definition->addError($errorMessage);
+
+                    continue;
+                }
+                foreach (class_implements($class, false) as $interface) {
+                    $this->singlyImplemented[$interface] = ($this->singlyImplemented[$interface] ?? $class) !== $class ? false : $class;
+                }
+            }
+        }
+
+        if ($this->autoRegisterAliasesForSinglyImplementedInterfaces) {
+            $this->registerAliasesForSinglyImplementedInterfaces();
+        }
+    }
+
+    public function registerAliasesForSinglyImplementedInterfaces()
+    {
+        foreach ($this->interfaces as $interface) {
+            if (!empty($this->singlyImplemented[$interface]) && !$this->container->has($interface)) {
+                $this->container->setAlias($interface, $this->singlyImplemented[$interface])->setPublic(false);
+            }
+        }
+
+        $this->interfaces = $this->singlyImplemented = [];
+    }
+
+    /**
+     * Registers a definition in the container with its instanceof-conditionals.
+     *
+     * @param string $id
+     */
+    protected function setDefinition($id, Definition $definition)
+    {
+        $this->container->removeBindings($id);
+
+        if ($this->isLoadingInstanceof) {
+            if (!$definition instanceof ChildDefinition) {
+                throw new InvalidArgumentException(sprintf('Invalid type definition "%s": ChildDefinition expected, "%s" given.', $id, \get_class($definition)));
+            }
+            $this->instanceof[$id] = $definition;
+        } else {
+            $this->container->setDefinition($id, $definition instanceof ChildDefinition ? $definition : $definition->setInstanceofConditionals($this->instanceof));
+        }
+    }
+
+    private function findClasses(string $namespace, string $pattern, array $excludePatterns): array
+    {
+        $parameterBag = $this->container->getParameterBag();
+
+        $excludePaths = [];
+        $excludePrefix = null;
+        $excludePatterns = $parameterBag->unescapeValue($parameterBag->resolveValue($excludePatterns));
+        foreach ($excludePatterns as $excludePattern) {
+            foreach ($this->glob($excludePattern, true, $resource, false, true) as $path => $info) {
+                if (null === $excludePrefix) {
+                    $excludePrefix = $resource->getPrefix();
+                }
+
+                // normalize Windows slashes
+                $excludePaths[str_replace('\\', '/', $path)] = true;
+            }
+        }
+
+        $pattern = $parameterBag->unescapeValue($parameterBag->resolveValue($pattern));
+        $classes = [];
+        $extRegexp = '/\\.php$/';
+        $prefixLen = null;
+        foreach ($this->glob($pattern, true, $resource, false, false, $excludePaths) as $path => $info) {
+            if (null === $prefixLen) {
+                $prefixLen = \strlen($resource->getPrefix());
+
+                if ($excludePrefix && 0 !== strpos($excludePrefix, $resource->getPrefix())) {
+                    throw new InvalidArgumentException(sprintf('Invalid "exclude" pattern when importing classes for "%s": make sure your "exclude" pattern (%s) is a subset of the "resource" pattern (%s)', $namespace, $excludePattern, $pattern));
+                }
+            }
+
+            if (isset($excludePaths[str_replace('\\', '/', $path)])) {
+                continue;
+            }
+
+            if (!preg_match($extRegexp, $path, $m) || !$info->isReadable()) {
+                continue;
+            }
+            $class = $namespace.ltrim(str_replace('/', '\\', substr($path, $prefixLen, -\strlen($m[0]))), '\\');
+
+            if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+(?:\\\\[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+)*+$/', $class)) {
+                continue;
+            }
+
+            try {
+                $r = $this->container->getReflectionClass($class);
+            } catch (\ReflectionException $e) {
+                $classes[$class] = $e->getMessage();
+                continue;
+            }
+            // check to make sure the expected class exists
+            if (!$r) {
+                throw new InvalidArgumentException(sprintf('Expected to find class "%s" in file "%s" while importing services from resource "%s", but it was not found! Check the namespace prefix used with the resource.', $class, $path, $pattern));
+            }
+
+            if ($r->isInstantiable() || $r->isInterface()) {
+                $classes[$class] = null;
+            }
+        }
+
+        // track only for new & removed files
+        if ($resource instanceof GlobResource) {
+            $this->container->addResource($resource);
+        } else {
+            foreach ($resource as $path) {
+                $this->container->fileExists($path, false);
+            }
+        }
+
+        return $classes;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/GlobFileLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/GlobFileLoader.php
new file mode 100644
index 0000000..4b25610
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/GlobFileLoader.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\DependencyInjection\Loader;
+
+/**
+ * GlobFileLoader loads files from a glob pattern.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class GlobFileLoader extends FileLoader
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function load($resource, $type = null)
+    {
+        foreach ($this->glob($resource, false, $globResource) as $path => $info) {
+            $this->import($path);
+        }
+
+        $this->container->addResource($globResource);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        return 'glob' === $type;
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/IniFileLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/IniFileLoader.php
new file mode 100644
index 0000000..40137b1
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/IniFileLoader.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\DependencyInjection\Loader;
+
+use Symfony\Component\Config\Util\XmlUtils;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+
+/**
+ * IniFileLoader loads parameters from INI files.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class IniFileLoader extends FileLoader
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function load($resource, $type = null)
+    {
+        $path = $this->locator->locate($resource);
+
+        $this->container->fileExists($path);
+
+        // first pass to catch parsing errors
+        $result = parse_ini_file($path, true);
+        if (false === $result || [] === $result) {
+            throw new InvalidArgumentException(sprintf('The "%s" file is not valid.', $resource));
+        }
+
+        // real raw parsing
+        $result = parse_ini_file($path, true, INI_SCANNER_RAW);
+
+        if (isset($result['parameters']) && \is_array($result['parameters'])) {
+            foreach ($result['parameters'] as $key => $value) {
+                $this->container->setParameter($key, $this->phpize($value));
+            }
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        if (!\is_string($resource)) {
+            return false;
+        }
+
+        if (null === $type && 'ini' === pathinfo($resource, PATHINFO_EXTENSION)) {
+            return true;
+        }
+
+        return 'ini' === $type;
+    }
+
+    /**
+     * Note that the following features are not supported:
+     *  * strings with escaped quotes are not supported "foo\"bar";
+     *  * string concatenation ("foo" "bar").
+     *
+     * @return mixed
+     */
+    private function phpize(string $value)
+    {
+        // trim on the right as comments removal keep whitespaces
+        if ($value !== $v = rtrim($value)) {
+            $value = '""' === substr_replace($v, '', 1, -1) ? substr($v, 1, -1) : $v;
+        }
+        $lowercaseValue = strtolower($value);
+
+        switch (true) {
+            case \defined($value):
+                return \constant($value);
+            case 'yes' === $lowercaseValue || 'on' === $lowercaseValue:
+                return true;
+            case 'no' === $lowercaseValue || 'off' === $lowercaseValue || 'none' === $lowercaseValue:
+                return false;
+            case isset($value[1]) && (
+                ("'" === $value[0] && "'" === $value[\strlen($value) - 1]) ||
+                ('"' === $value[0] && '"' === $value[\strlen($value) - 1])
+            ):
+                // quoted string
+                return substr($value, 1, -1);
+            default:
+                return XmlUtils::phpize($value);
+        }
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/PhpFileLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/PhpFileLoader.php
new file mode 100644
index 0000000..f1477ec
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/PhpFileLoader.php
@@ -0,0 +1,80 @@
+<?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\DependencyInjection\Loader;
+
+use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+/**
+ * PhpFileLoader loads service definitions from a PHP file.
+ *
+ * The PHP file is required and the $container variable can be
+ * used within the file to change the container.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class PhpFileLoader extends FileLoader
+{
+    protected $autoRegisterAliasesForSinglyImplementedInterfaces = false;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function load($resource, $type = null)
+    {
+        // the container and loader variables are exposed to the included file below
+        $container = $this->container;
+        $loader = $this;
+
+        $path = $this->locator->locate($resource);
+        $this->setCurrentDir(\dirname($path));
+        $this->container->fileExists($path);
+
+        // the closure forbids access to the private scope in the included file
+        $load = \Closure::bind(function ($path) use ($container, $loader, $resource, $type) {
+            return include $path;
+        }, $this, ProtectedPhpFileLoader::class);
+
+        try {
+            $callback = $load($path);
+
+            if (\is_object($callback) && \is_callable($callback)) {
+                $callback(new ContainerConfigurator($this->container, $this, $this->instanceof, $path, $resource), $this->container, $this);
+            }
+        } finally {
+            $this->instanceof = [];
+            $this->registerAliasesForSinglyImplementedInterfaces();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        if (!\is_string($resource)) {
+            return false;
+        }
+
+        if (null === $type && 'php' === pathinfo($resource, PATHINFO_EXTENSION)) {
+            return true;
+        }
+
+        return 'php' === $type;
+    }
+}
+
+/**
+ * @internal
+ */
+final class ProtectedPhpFileLoader extends PhpFileLoader
+{
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/XmlFileLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/XmlFileLoader.php
new file mode 100644
index 0000000..41a9f0a
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/XmlFileLoader.php
@@ -0,0 +1,728 @@
+<?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\DependencyInjection\Loader;
+
+use Symfony\Component\Config\Util\XmlUtils;
+use Symfony\Component\DependencyInjection\Alias;
+use Symfony\Component\DependencyInjection\Argument\BoundArgument;
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
+use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\ExpressionLanguage\Expression;
+
+/**
+ * XmlFileLoader loads XML files service definitions.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class XmlFileLoader extends FileLoader
+{
+    const NS = 'http://symfony.com/schema/dic/services';
+
+    protected $autoRegisterAliasesForSinglyImplementedInterfaces = false;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function load($resource, $type = null)
+    {
+        $path = $this->locator->locate($resource);
+
+        $xml = $this->parseFileToDOM($path);
+
+        $this->container->fileExists($path);
+
+        $defaults = $this->getServiceDefaults($xml, $path);
+
+        // anonymous services
+        $this->processAnonymousServices($xml, $path);
+
+        // imports
+        $this->parseImports($xml, $path);
+
+        // parameters
+        $this->parseParameters($xml, $path);
+
+        // extensions
+        $this->loadFromExtensions($xml);
+
+        // services
+        try {
+            $this->parseDefinitions($xml, $path, $defaults);
+        } finally {
+            $this->instanceof = [];
+            $this->registerAliasesForSinglyImplementedInterfaces();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        if (!\is_string($resource)) {
+            return false;
+        }
+
+        if (null === $type && 'xml' === pathinfo($resource, PATHINFO_EXTENSION)) {
+            return true;
+        }
+
+        return 'xml' === $type;
+    }
+
+    private function parseParameters(\DOMDocument $xml, string $file)
+    {
+        if ($parameters = $this->getChildren($xml->documentElement, 'parameters')) {
+            $this->container->getParameterBag()->add($this->getArgumentsAsPhp($parameters[0], 'parameter', $file));
+        }
+    }
+
+    private function parseImports(\DOMDocument $xml, string $file)
+    {
+        $xpath = new \DOMXPath($xml);
+        $xpath->registerNamespace('container', self::NS);
+
+        if (false === $imports = $xpath->query('//container:imports/container:import')) {
+            return;
+        }
+
+        $defaultDirectory = \dirname($file);
+        foreach ($imports as $import) {
+            $this->setCurrentDir($defaultDirectory);
+            $this->import($import->getAttribute('resource'), XmlUtils::phpize($import->getAttribute('type')) ?: null, XmlUtils::phpize($import->getAttribute('ignore-errors')) ?: false, $file);
+        }
+    }
+
+    private function parseDefinitions(\DOMDocument $xml, string $file, array $defaults)
+    {
+        $xpath = new \DOMXPath($xml);
+        $xpath->registerNamespace('container', self::NS);
+
+        if (false === $services = $xpath->query('//container:services/container:service|//container:services/container:prototype')) {
+            return;
+        }
+        $this->setCurrentDir(\dirname($file));
+
+        $this->instanceof = [];
+        $this->isLoadingInstanceof = true;
+        $instanceof = $xpath->query('//container:services/container:instanceof');
+        foreach ($instanceof as $service) {
+            $this->setDefinition((string) $service->getAttribute('id'), $this->parseDefinition($service, $file, []));
+        }
+
+        $this->isLoadingInstanceof = false;
+        foreach ($services as $service) {
+            if (null !== $definition = $this->parseDefinition($service, $file, $defaults)) {
+                if ('prototype' === $service->tagName) {
+                    $excludes = array_column($this->getChildren($service, 'exclude'), 'nodeValue');
+                    if ($service->hasAttribute('exclude')) {
+                        if (\count($excludes) > 0) {
+                            throw new InvalidArgumentException('You cannot use both the attribute "exclude" and <exclude> tags at the same time.');
+                        }
+                        $excludes = [$service->getAttribute('exclude')];
+                    }
+                    $this->registerClasses($definition, (string) $service->getAttribute('namespace'), (string) $service->getAttribute('resource'), $excludes);
+                } else {
+                    $this->setDefinition((string) $service->getAttribute('id'), $definition);
+                }
+            }
+        }
+    }
+
+    /**
+     * Get service defaults.
+     */
+    private function getServiceDefaults(\DOMDocument $xml, string $file): array
+    {
+        $xpath = new \DOMXPath($xml);
+        $xpath->registerNamespace('container', self::NS);
+
+        if (null === $defaultsNode = $xpath->query('//container:services/container:defaults')->item(0)) {
+            return [];
+        }
+
+        $bindings = [];
+        foreach ($this->getArgumentsAsPhp($defaultsNode, 'bind', $file) as $argument => $value) {
+            $bindings[$argument] = new BoundArgument($value, true, BoundArgument::DEFAULTS_BINDING, $file);
+        }
+
+        $defaults = [
+            'tags' => $this->getChildren($defaultsNode, 'tag'),
+            'bind' => $bindings,
+        ];
+
+        foreach ($defaults['tags'] as $tag) {
+            if ('' === $tag->getAttribute('name')) {
+                throw new InvalidArgumentException(sprintf('The tag name for tag "<defaults>" in %s must be a non-empty string.', $file));
+            }
+        }
+
+        if ($defaultsNode->hasAttribute('autowire')) {
+            $defaults['autowire'] = XmlUtils::phpize($defaultsNode->getAttribute('autowire'));
+        }
+        if ($defaultsNode->hasAttribute('public')) {
+            $defaults['public'] = XmlUtils::phpize($defaultsNode->getAttribute('public'));
+        }
+        if ($defaultsNode->hasAttribute('autoconfigure')) {
+            $defaults['autoconfigure'] = XmlUtils::phpize($defaultsNode->getAttribute('autoconfigure'));
+        }
+
+        return $defaults;
+    }
+
+    /**
+     * Parses an individual Definition.
+     */
+    private function parseDefinition(\DOMElement $service, string $file, array $defaults): ?Definition
+    {
+        if ($alias = $service->getAttribute('alias')) {
+            $this->validateAlias($service, $file);
+
+            $this->container->setAlias((string) $service->getAttribute('id'), $alias = new Alias($alias));
+            if ($publicAttr = $service->getAttribute('public')) {
+                $alias->setPublic(XmlUtils::phpize($publicAttr));
+            } elseif (isset($defaults['public'])) {
+                $alias->setPublic($defaults['public']);
+            }
+
+            if ($deprecated = $this->getChildren($service, 'deprecated')) {
+                $alias->setDeprecated(true, $deprecated[0]->nodeValue ?: null);
+            }
+
+            return null;
+        }
+
+        if ($this->isLoadingInstanceof) {
+            $definition = new ChildDefinition('');
+        } elseif ($parent = $service->getAttribute('parent')) {
+            if (!empty($this->instanceof)) {
+                throw new InvalidArgumentException(sprintf('The service "%s" cannot use the "parent" option in the same file where "instanceof" configuration is defined as using both is not supported. Move your child definitions to a separate file.', $service->getAttribute('id')));
+            }
+
+            foreach ($defaults as $k => $v) {
+                if ('tags' === $k) {
+                    // since tags are never inherited from parents, there is no confusion
+                    // thus we can safely add them as defaults to ChildDefinition
+                    continue;
+                }
+                if ('bind' === $k) {
+                    if ($defaults['bind']) {
+                        throw new InvalidArgumentException(sprintf('Bound values on service "%s" cannot be inherited from "defaults" when a "parent" is set. Move your child definitions to a separate file.', $service->getAttribute('id')));
+                    }
+
+                    continue;
+                }
+                if (!$service->hasAttribute($k)) {
+                    throw new InvalidArgumentException(sprintf('Attribute "%s" on service "%s" cannot be inherited from "defaults" when a "parent" is set. Move your child definitions to a separate file or define this attribute explicitly.', $k, $service->getAttribute('id')));
+                }
+            }
+
+            $definition = new ChildDefinition($parent);
+        } else {
+            $definition = new Definition();
+
+            if (isset($defaults['public'])) {
+                $definition->setPublic($defaults['public']);
+            }
+            if (isset($defaults['autowire'])) {
+                $definition->setAutowired($defaults['autowire']);
+            }
+            if (isset($defaults['autoconfigure'])) {
+                $definition->setAutoconfigured($defaults['autoconfigure']);
+            }
+
+            $definition->setChanges([]);
+        }
+
+        foreach (['class', 'public', 'shared', 'synthetic', 'abstract'] as $key) {
+            if ($value = $service->getAttribute($key)) {
+                $method = 'set'.$key;
+                $definition->$method($value = XmlUtils::phpize($value));
+            }
+        }
+
+        if ($value = $service->getAttribute('lazy')) {
+            $definition->setLazy((bool) $value = XmlUtils::phpize($value));
+            if (\is_string($value)) {
+                $definition->addTag('proxy', ['interface' => $value]);
+            }
+        }
+
+        if ($value = $service->getAttribute('autowire')) {
+            $definition->setAutowired(XmlUtils::phpize($value));
+        }
+
+        if ($value = $service->getAttribute('autoconfigure')) {
+            if (!$definition instanceof ChildDefinition) {
+                $definition->setAutoconfigured(XmlUtils::phpize($value));
+            } elseif ($value = XmlUtils::phpize($value)) {
+                throw new InvalidArgumentException(sprintf('The service "%s" cannot have a "parent" and also have "autoconfigure". Try setting autoconfigure="false" for the service.', $service->getAttribute('id')));
+            }
+        }
+
+        if ($files = $this->getChildren($service, 'file')) {
+            $definition->setFile($files[0]->nodeValue);
+        }
+
+        if ($deprecated = $this->getChildren($service, 'deprecated')) {
+            $definition->setDeprecated(true, $deprecated[0]->nodeValue ?: null);
+        }
+
+        $definition->setArguments($this->getArgumentsAsPhp($service, 'argument', $file, $definition instanceof ChildDefinition));
+        $definition->setProperties($this->getArgumentsAsPhp($service, 'property', $file));
+
+        if ($factories = $this->getChildren($service, 'factory')) {
+            $factory = $factories[0];
+            if ($function = $factory->getAttribute('function')) {
+                $definition->setFactory($function);
+            } else {
+                if ($childService = $factory->getAttribute('service')) {
+                    $class = new Reference($childService, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE);
+                } else {
+                    $class = $factory->hasAttribute('class') ? $factory->getAttribute('class') : null;
+                }
+
+                $definition->setFactory([$class, $factory->getAttribute('method') ?: '__invoke']);
+            }
+        }
+
+        if ($configurators = $this->getChildren($service, 'configurator')) {
+            $configurator = $configurators[0];
+            if ($function = $configurator->getAttribute('function')) {
+                $definition->setConfigurator($function);
+            } else {
+                if ($childService = $configurator->getAttribute('service')) {
+                    $class = new Reference($childService, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE);
+                } else {
+                    $class = $configurator->getAttribute('class');
+                }
+
+                $definition->setConfigurator([$class, $configurator->getAttribute('method') ?: '__invoke']);
+            }
+        }
+
+        foreach ($this->getChildren($service, 'call') as $call) {
+            $definition->addMethodCall($call->getAttribute('method'), $this->getArgumentsAsPhp($call, 'argument', $file), XmlUtils::phpize($call->getAttribute('returns-clone')));
+        }
+
+        $tags = $this->getChildren($service, 'tag');
+
+        if (!empty($defaults['tags'])) {
+            $tags = array_merge($tags, $defaults['tags']);
+        }
+
+        foreach ($tags as $tag) {
+            $parameters = [];
+            foreach ($tag->attributes as $name => $node) {
+                if ('name' === $name) {
+                    continue;
+                }
+
+                if (false !== strpos($name, '-') && false === strpos($name, '_') && !\array_key_exists($normalizedName = str_replace('-', '_', $name), $parameters)) {
+                    $parameters[$normalizedName] = XmlUtils::phpize($node->nodeValue);
+                }
+                // keep not normalized key
+                $parameters[$name] = XmlUtils::phpize($node->nodeValue);
+            }
+
+            if ('' === $tag->getAttribute('name')) {
+                throw new InvalidArgumentException(sprintf('The tag name for service "%s" in %s must be a non-empty string.', (string) $service->getAttribute('id'), $file));
+            }
+
+            $definition->addTag($tag->getAttribute('name'), $parameters);
+        }
+
+        $bindings = $this->getArgumentsAsPhp($service, 'bind', $file);
+        $bindingType = $this->isLoadingInstanceof ? BoundArgument::INSTANCEOF_BINDING : BoundArgument::SERVICE_BINDING;
+        foreach ($bindings as $argument => $value) {
+            $bindings[$argument] = new BoundArgument($value, true, $bindingType, $file);
+        }
+
+        if (isset($defaults['bind'])) {
+            // deep clone, to avoid multiple process of the same instance in the passes
+            $bindings = array_merge(unserialize(serialize($defaults['bind'])), $bindings);
+        }
+        if ($bindings) {
+            $definition->setBindings($bindings);
+        }
+
+        if ($decorates = $service->getAttribute('decorates')) {
+            $decorationOnInvalid = $service->getAttribute('decoration-on-invalid') ?: 'exception';
+            if ('exception' === $decorationOnInvalid) {
+                $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+            } elseif ('ignore' === $decorationOnInvalid) {
+                $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
+            } elseif ('null' === $decorationOnInvalid) {
+                $invalidBehavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
+            } else {
+                throw new InvalidArgumentException(sprintf('Invalid value "%s" for attribute "decoration-on-invalid" on service "%s". Did you mean "exception", "ignore" or "null" in "%s"?', $decorationOnInvalid, (string) $service->getAttribute('id'), $file));
+            }
+
+            $renameId = $service->hasAttribute('decoration-inner-name') ? $service->getAttribute('decoration-inner-name') : null;
+            $priority = $service->hasAttribute('decoration-priority') ? $service->getAttribute('decoration-priority') : 0;
+
+            $definition->setDecoratedService($decorates, $renameId, $priority, $invalidBehavior);
+        }
+
+        return $definition;
+    }
+
+    /**
+     * Parses a XML file to a \DOMDocument.
+     *
+     * @throws InvalidArgumentException When loading of XML file returns error
+     */
+    private function parseFileToDOM(string $file): \DOMDocument
+    {
+        try {
+            $dom = XmlUtils::loadFile($file, [$this, 'validateSchema']);
+        } catch (\InvalidArgumentException $e) {
+            throw new InvalidArgumentException(sprintf('Unable to parse file "%s": %s', $file, $e->getMessage()), $e->getCode(), $e);
+        }
+
+        $this->validateExtensions($dom, $file);
+
+        return $dom;
+    }
+
+    /**
+     * Processes anonymous services.
+     */
+    private function processAnonymousServices(\DOMDocument $xml, string $file)
+    {
+        $definitions = [];
+        $count = 0;
+        $suffix = '~'.ContainerBuilder::hash($file);
+
+        $xpath = new \DOMXPath($xml);
+        $xpath->registerNamespace('container', self::NS);
+
+        // anonymous services as arguments/properties
+        if (false !== $nodes = $xpath->query('//container:argument[@type="service"][not(@id)]|//container:property[@type="service"][not(@id)]|//container:bind[not(@id)]|//container:factory[not(@service)]|//container:configurator[not(@service)]')) {
+            foreach ($nodes as $node) {
+                if ($services = $this->getChildren($node, 'service')) {
+                    // give it a unique name
+                    $id = sprintf('.%d_%s', ++$count, preg_replace('/^.*\\\\/', '', $services[0]->getAttribute('class')).$suffix);
+                    $node->setAttribute('id', $id);
+                    $node->setAttribute('service', $id);
+
+                    $definitions[$id] = [$services[0], $file];
+                    $services[0]->setAttribute('id', $id);
+
+                    // anonymous services are always private
+                    // we could not use the constant false here, because of XML parsing
+                    $services[0]->setAttribute('public', 'false');
+                }
+            }
+        }
+
+        // anonymous services "in the wild"
+        if (false !== $nodes = $xpath->query('//container:services/container:service[not(@id)]')) {
+            foreach ($nodes as $node) {
+                throw new InvalidArgumentException(sprintf('Top-level services must have "id" attribute, none found in %s at line %d.', $file, $node->getLineNo()));
+            }
+        }
+
+        // resolve definitions
+        uksort($definitions, 'strnatcmp');
+        foreach (array_reverse($definitions) as $id => list($domElement, $file)) {
+            if (null !== $definition = $this->parseDefinition($domElement, $file, [])) {
+                $this->setDefinition($id, $definition);
+            }
+        }
+    }
+
+    private function getArgumentsAsPhp(\DOMElement $node, string $name, string $file, bool $isChildDefinition = false): array
+    {
+        $arguments = [];
+        foreach ($this->getChildren($node, $name) as $arg) {
+            if ($arg->hasAttribute('name')) {
+                $arg->setAttribute('key', $arg->getAttribute('name'));
+            }
+
+            // this is used by ChildDefinition to overwrite a specific
+            // argument of the parent definition
+            if ($arg->hasAttribute('index')) {
+                $key = ($isChildDefinition ? 'index_' : '').$arg->getAttribute('index');
+            } elseif (!$arg->hasAttribute('key')) {
+                // Append an empty argument, then fetch its key to overwrite it later
+                $arguments[] = null;
+                $keys = array_keys($arguments);
+                $key = array_pop($keys);
+            } else {
+                $key = $arg->getAttribute('key');
+            }
+
+            $onInvalid = $arg->getAttribute('on-invalid');
+            $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+            if ('ignore' == $onInvalid) {
+                $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
+            } elseif ('ignore_uninitialized' == $onInvalid) {
+                $invalidBehavior = ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE;
+            } elseif ('null' == $onInvalid) {
+                $invalidBehavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
+            }
+
+            switch ($arg->getAttribute('type')) {
+                case 'service':
+                    if ('' === $arg->getAttribute('id')) {
+                        throw new InvalidArgumentException(sprintf('Tag "<%s>" with type="service" has no or empty "id" attribute in "%s".', $name, $file));
+                    }
+
+                    $arguments[$key] = new Reference($arg->getAttribute('id'), $invalidBehavior);
+                    break;
+                case 'expression':
+                    if (!class_exists(Expression::class)) {
+                        throw new \LogicException(sprintf('The type="expression" attribute cannot be used without the ExpressionLanguage component. Try running "composer require symfony/expression-language".'));
+                    }
+
+                    $arguments[$key] = new Expression($arg->nodeValue);
+                    break;
+                case 'collection':
+                    $arguments[$key] = $this->getArgumentsAsPhp($arg, $name, $file);
+                    break;
+                case 'iterator':
+                    $arg = $this->getArgumentsAsPhp($arg, $name, $file);
+                    try {
+                        $arguments[$key] = new IteratorArgument($arg);
+                    } catch (InvalidArgumentException $e) {
+                        throw new InvalidArgumentException(sprintf('Tag "<%s>" with type="iterator" only accepts collections of type="service" references in "%s".', $name, $file));
+                    }
+                    break;
+                case 'service_locator':
+                    $arg = $this->getArgumentsAsPhp($arg, $name, $file);
+                    try {
+                        $arguments[$key] = new ServiceLocatorArgument($arg);
+                    } catch (InvalidArgumentException $e) {
+                        throw new InvalidArgumentException(sprintf('Tag "<%s>" with type="service_locator" only accepts maps of type="service" references in "%s".', $name, $file));
+                    }
+                    break;
+                case 'tagged':
+                case 'tagged_iterator':
+                case 'tagged_locator':
+                    $type = $arg->getAttribute('type');
+                    $forLocator = 'tagged_locator' === $type;
+
+                    if (!$arg->getAttribute('tag')) {
+                        throw new InvalidArgumentException(sprintf('Tag "<%s>" with type="%s" has no or empty "tag" attribute in "%s".', $name, $type, $file));
+                    }
+
+                    $arguments[$key] = new TaggedIteratorArgument($arg->getAttribute('tag'), $arg->getAttribute('index-by') ?: null, $arg->getAttribute('default-index-method') ?: null, $forLocator, $arg->getAttribute('default-priority-method') ?: null);
+
+                    if ($forLocator) {
+                        $arguments[$key] = new ServiceLocatorArgument($arguments[$key]);
+                    }
+                    break;
+                case 'binary':
+                    if (false === $value = base64_decode($arg->nodeValue)) {
+                        throw new InvalidArgumentException(sprintf('Tag "<%s>" with type="binary" is not a valid base64 encoded string.', $name));
+                    }
+                    $arguments[$key] = $value;
+                    break;
+                case 'string':
+                    $arguments[$key] = $arg->nodeValue;
+                    break;
+                case 'constant':
+                    $arguments[$key] = \constant(trim($arg->nodeValue));
+                    break;
+                default:
+                    $arguments[$key] = XmlUtils::phpize($arg->nodeValue);
+            }
+        }
+
+        return $arguments;
+    }
+
+    /**
+     * Get child elements by name.
+     *
+     * @return \DOMElement[]
+     */
+    private function getChildren(\DOMNode $node, string $name): array
+    {
+        $children = [];
+        foreach ($node->childNodes as $child) {
+            if ($child instanceof \DOMElement && $child->localName === $name && self::NS === $child->namespaceURI) {
+                $children[] = $child;
+            }
+        }
+
+        return $children;
+    }
+
+    /**
+     * Validates a documents XML schema.
+     *
+     * @return bool
+     *
+     * @throws RuntimeException When extension references a non-existent XSD file
+     */
+    public function validateSchema(\DOMDocument $dom)
+    {
+        $schemaLocations = ['http://symfony.com/schema/dic/services' => str_replace('\\', '/', __DIR__.'/schema/dic/services/services-1.0.xsd')];
+
+        if ($element = $dom->documentElement->getAttributeNS('http://www.w3.org/2001/XMLSchema-instance', 'schemaLocation')) {
+            $items = preg_split('/\s+/', $element);
+            for ($i = 0, $nb = \count($items); $i < $nb; $i += 2) {
+                if (!$this->container->hasExtension($items[$i])) {
+                    continue;
+                }
+
+                if (($extension = $this->container->getExtension($items[$i])) && false !== $extension->getXsdValidationBasePath()) {
+                    $ns = $extension->getNamespace();
+                    $path = str_replace([$ns, str_replace('http://', 'https://', $ns)], str_replace('\\', '/', $extension->getXsdValidationBasePath()).'/', $items[$i + 1]);
+
+                    if (!is_file($path)) {
+                        throw new RuntimeException(sprintf('Extension "%s" references a non-existent XSD file "%s"', \get_class($extension), $path));
+                    }
+
+                    $schemaLocations[$items[$i]] = $path;
+                }
+            }
+        }
+
+        $tmpfiles = [];
+        $imports = '';
+        foreach ($schemaLocations as $namespace => $location) {
+            $parts = explode('/', $location);
+            $locationstart = 'file:///';
+            if (0 === stripos($location, 'phar://')) {
+                $tmpfile = tempnam(sys_get_temp_dir(), 'symfony');
+                if ($tmpfile) {
+                    copy($location, $tmpfile);
+                    $tmpfiles[] = $tmpfile;
+                    $parts = explode('/', str_replace('\\', '/', $tmpfile));
+                } else {
+                    array_shift($parts);
+                    $locationstart = 'phar:///';
+                }
+            }
+            $drive = '\\' === \DIRECTORY_SEPARATOR ? array_shift($parts).'/' : '';
+            $location = $locationstart.$drive.implode('/', array_map('rawurlencode', $parts));
+
+            $imports .= sprintf('  <xsd:import namespace="%s" schemaLocation="%s" />'."\n", $namespace, $location);
+        }
+
+        $source = <<<EOF
+<?xml version="1.0" encoding="utf-8" ?>
+<xsd:schema xmlns="http://symfony.com/schema"
+    xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    targetNamespace="http://symfony.com/schema"
+    elementFormDefault="qualified">
+
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>
+$imports
+</xsd:schema>
+EOF
+        ;
+
+        $disableEntities = libxml_disable_entity_loader(false);
+        $valid = @$dom->schemaValidateSource($source);
+        libxml_disable_entity_loader($disableEntities);
+
+        foreach ($tmpfiles as $tmpfile) {
+            @unlink($tmpfile);
+        }
+
+        return $valid;
+    }
+
+    private function validateAlias(\DOMElement $alias, string $file)
+    {
+        foreach ($alias->attributes as $name => $node) {
+            if (!\in_array($name, ['alias', 'id', 'public'])) {
+                throw new InvalidArgumentException(sprintf('Invalid attribute "%s" defined for alias "%s" in "%s".', $name, $alias->getAttribute('id'), $file));
+            }
+        }
+
+        foreach ($alias->childNodes as $child) {
+            if (!$child instanceof \DOMElement || self::NS !== $child->namespaceURI) {
+                continue;
+            }
+            if (!\in_array($child->localName, ['deprecated'], true)) {
+                throw new InvalidArgumentException(sprintf('Invalid child element "%s" defined for alias "%s" in "%s".', $child->localName, $alias->getAttribute('id'), $file));
+            }
+        }
+    }
+
+    /**
+     * Validates an extension.
+     *
+     * @throws InvalidArgumentException When no extension is found corresponding to a tag
+     */
+    private function validateExtensions(\DOMDocument $dom, string $file)
+    {
+        foreach ($dom->documentElement->childNodes as $node) {
+            if (!$node instanceof \DOMElement || 'http://symfony.com/schema/dic/services' === $node->namespaceURI) {
+                continue;
+            }
+
+            // can it be handled by an extension?
+            if (!$this->container->hasExtension($node->namespaceURI)) {
+                $extensionNamespaces = array_filter(array_map(function (ExtensionInterface $ext) { return $ext->getNamespace(); }, $this->container->getExtensions()));
+                throw new InvalidArgumentException(sprintf('There is no extension able to load the configuration for "%s" (in %s). Looked for namespace "%s", found %s', $node->tagName, $file, $node->namespaceURI, $extensionNamespaces ? sprintf('"%s"', implode('", "', $extensionNamespaces)) : 'none'));
+            }
+        }
+    }
+
+    /**
+     * Loads from an extension.
+     */
+    private function loadFromExtensions(\DOMDocument $xml)
+    {
+        foreach ($xml->documentElement->childNodes as $node) {
+            if (!$node instanceof \DOMElement || self::NS === $node->namespaceURI) {
+                continue;
+            }
+
+            $values = static::convertDomElementToArray($node);
+            if (!\is_array($values)) {
+                $values = [];
+            }
+
+            $this->container->loadFromExtension($node->namespaceURI, $values);
+        }
+    }
+
+    /**
+     * Converts a \DOMElement object to a PHP array.
+     *
+     * The following rules applies during the conversion:
+     *
+     *  * Each tag is converted to a key value or an array
+     *    if there is more than one "value"
+     *
+     *  * The content of a tag is set under a "value" key (<foo>bar</foo>)
+     *    if the tag also has some nested tags
+     *
+     *  * The attributes are converted to keys (<foo foo="bar"/>)
+     *
+     *  * The nested-tags are converted to keys (<foo><foo>bar</foo></foo>)
+     *
+     * @param \DOMElement $element A \DOMElement instance
+     *
+     * @return mixed
+     */
+    public static function convertDomElementToArray(\DOMElement $element)
+    {
+        return XmlUtils::convertDomElementToArray($element);
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/YamlFileLoader.php b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/YamlFileLoader.php
new file mode 100644
index 0000000..ee8c140
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/YamlFileLoader.php
@@ -0,0 +1,880 @@
+<?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\DependencyInjection\Loader;
+
+use Symfony\Component\DependencyInjection\Alias;
+use Symfony\Component\DependencyInjection\Argument\ArgumentInterface;
+use Symfony\Component\DependencyInjection\Argument\BoundArgument;
+use Symfony\Component\DependencyInjection\Argument\IteratorArgument;
+use Symfony\Component\DependencyInjection\Argument\ServiceLocatorArgument;
+use Symfony\Component\DependencyInjection\Argument\TaggedIteratorArgument;
+use Symfony\Component\DependencyInjection\ChildDefinition;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\ExpressionLanguage\Expression;
+use Symfony\Component\Yaml\Exception\ParseException;
+use Symfony\Component\Yaml\Parser as YamlParser;
+use Symfony\Component\Yaml\Tag\TaggedValue;
+use Symfony\Component\Yaml\Yaml;
+
+/**
+ * YamlFileLoader loads YAML files service definitions.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ */
+class YamlFileLoader extends FileLoader
+{
+    private static $serviceKeywords = [
+        'alias' => 'alias',
+        'parent' => 'parent',
+        'class' => 'class',
+        'shared' => 'shared',
+        'synthetic' => 'synthetic',
+        'lazy' => 'lazy',
+        'public' => 'public',
+        'abstract' => 'abstract',
+        'deprecated' => 'deprecated',
+        'factory' => 'factory',
+        'file' => 'file',
+        'arguments' => 'arguments',
+        'properties' => 'properties',
+        'configurator' => 'configurator',
+        'calls' => 'calls',
+        'tags' => 'tags',
+        'decorates' => 'decorates',
+        'decoration_inner_name' => 'decoration_inner_name',
+        'decoration_priority' => 'decoration_priority',
+        'decoration_on_invalid' => 'decoration_on_invalid',
+        'autowire' => 'autowire',
+        'autoconfigure' => 'autoconfigure',
+        'bind' => 'bind',
+    ];
+
+    private static $prototypeKeywords = [
+        'resource' => 'resource',
+        'namespace' => 'namespace',
+        'exclude' => 'exclude',
+        'parent' => 'parent',
+        'shared' => 'shared',
+        'lazy' => 'lazy',
+        'public' => 'public',
+        'abstract' => 'abstract',
+        'deprecated' => 'deprecated',
+        'factory' => 'factory',
+        'arguments' => 'arguments',
+        'properties' => 'properties',
+        'configurator' => 'configurator',
+        'calls' => 'calls',
+        'tags' => 'tags',
+        'autowire' => 'autowire',
+        'autoconfigure' => 'autoconfigure',
+        'bind' => 'bind',
+    ];
+
+    private static $instanceofKeywords = [
+        'shared' => 'shared',
+        'lazy' => 'lazy',
+        'public' => 'public',
+        'properties' => 'properties',
+        'configurator' => 'configurator',
+        'calls' => 'calls',
+        'tags' => 'tags',
+        'autowire' => 'autowire',
+        'bind' => 'bind',
+    ];
+
+    private static $defaultsKeywords = [
+        'public' => 'public',
+        'tags' => 'tags',
+        'autowire' => 'autowire',
+        'autoconfigure' => 'autoconfigure',
+        'bind' => 'bind',
+    ];
+
+    private $yamlParser;
+
+    private $anonymousServicesCount;
+    private $anonymousServicesSuffix;
+
+    protected $autoRegisterAliasesForSinglyImplementedInterfaces = false;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function load($resource, $type = null)
+    {
+        $path = $this->locator->locate($resource);
+
+        $content = $this->loadFile($path);
+
+        $this->container->fileExists($path);
+
+        // empty file
+        if (null === $content) {
+            return;
+        }
+
+        // imports
+        $this->parseImports($content, $path);
+
+        // parameters
+        if (isset($content['parameters'])) {
+            if (!\is_array($content['parameters'])) {
+                throw new InvalidArgumentException(sprintf('The "parameters" key should contain an array in %s. Check your YAML syntax.', $path));
+            }
+
+            foreach ($content['parameters'] as $key => $value) {
+                $this->container->setParameter($key, $this->resolveServices($value, $path, true));
+            }
+        }
+
+        // extensions
+        $this->loadFromExtensions($content);
+
+        // services
+        $this->anonymousServicesCount = 0;
+        $this->anonymousServicesSuffix = '~'.ContainerBuilder::hash($path);
+        $this->setCurrentDir(\dirname($path));
+        try {
+            $this->parseDefinitions($content, $path);
+        } finally {
+            $this->instanceof = [];
+            $this->registerAliasesForSinglyImplementedInterfaces();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports($resource, $type = null)
+    {
+        if (!\is_string($resource)) {
+            return false;
+        }
+
+        if (null === $type && \in_array(pathinfo($resource, PATHINFO_EXTENSION), ['yaml', 'yml'], true)) {
+            return true;
+        }
+
+        return \in_array($type, ['yaml', 'yml'], true);
+    }
+
+    private function parseImports(array $content, string $file)
+    {
+        if (!isset($content['imports'])) {
+            return;
+        }
+
+        if (!\is_array($content['imports'])) {
+            throw new InvalidArgumentException(sprintf('The "imports" key should contain an array in %s. Check your YAML syntax.', $file));
+        }
+
+        $defaultDirectory = \dirname($file);
+        foreach ($content['imports'] as $import) {
+            if (!\is_array($import)) {
+                $import = ['resource' => $import];
+            }
+            if (!isset($import['resource'])) {
+                throw new InvalidArgumentException(sprintf('An import should provide a resource in %s. Check your YAML syntax.', $file));
+            }
+
+            $this->setCurrentDir($defaultDirectory);
+            $this->import($import['resource'], $import['type'] ?? null, $import['ignore_errors'] ?? false, $file);
+        }
+    }
+
+    private function parseDefinitions(array $content, string $file)
+    {
+        if (!isset($content['services'])) {
+            return;
+        }
+
+        if (!\is_array($content['services'])) {
+            throw new InvalidArgumentException(sprintf('The "services" key should contain an array in %s. Check your YAML syntax.', $file));
+        }
+
+        if (\array_key_exists('_instanceof', $content['services'])) {
+            $instanceof = $content['services']['_instanceof'];
+            unset($content['services']['_instanceof']);
+
+            if (!\is_array($instanceof)) {
+                throw new InvalidArgumentException(sprintf('Service "_instanceof" key must be an array, "%s" given in "%s".', \gettype($instanceof), $file));
+            }
+            $this->instanceof = [];
+            $this->isLoadingInstanceof = true;
+            foreach ($instanceof as $id => $service) {
+                if (!$service || !\is_array($service)) {
+                    throw new InvalidArgumentException(sprintf('Type definition "%s" must be a non-empty array within "_instanceof" in %s. Check your YAML syntax.', $id, $file));
+                }
+                if (\is_string($service) && 0 === strpos($service, '@')) {
+                    throw new InvalidArgumentException(sprintf('Type definition "%s" cannot be an alias within "_instanceof" in %s. Check your YAML syntax.', $id, $file));
+                }
+                $this->parseDefinition($id, $service, $file, []);
+            }
+        }
+
+        $this->isLoadingInstanceof = false;
+        $defaults = $this->parseDefaults($content, $file);
+        foreach ($content['services'] as $id => $service) {
+            $this->parseDefinition($id, $service, $file, $defaults);
+        }
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    private function parseDefaults(array &$content, string $file): array
+    {
+        if (!\array_key_exists('_defaults', $content['services'])) {
+            return [];
+        }
+        $defaults = $content['services']['_defaults'];
+        unset($content['services']['_defaults']);
+
+        if (!\is_array($defaults)) {
+            throw new InvalidArgumentException(sprintf('Service "_defaults" key must be an array, "%s" given in "%s".', \gettype($defaults), $file));
+        }
+
+        foreach ($defaults as $key => $default) {
+            if (!isset(self::$defaultsKeywords[$key])) {
+                throw new InvalidArgumentException(sprintf('The configuration key "%s" cannot be used to define a default value in "%s". Allowed keys are "%s".', $key, $file, implode('", "', self::$defaultsKeywords)));
+            }
+        }
+
+        if (isset($defaults['tags'])) {
+            if (!\is_array($tags = $defaults['tags'])) {
+                throw new InvalidArgumentException(sprintf('Parameter "tags" in "_defaults" must be an array in %s. Check your YAML syntax.', $file));
+            }
+
+            foreach ($tags as $tag) {
+                if (!\is_array($tag)) {
+                    $tag = ['name' => $tag];
+                }
+
+                if (!isset($tag['name'])) {
+                    throw new InvalidArgumentException(sprintf('A "tags" entry in "_defaults" is missing a "name" key in %s.', $file));
+                }
+                $name = $tag['name'];
+                unset($tag['name']);
+
+                if (!\is_string($name) || '' === $name) {
+                    throw new InvalidArgumentException(sprintf('The tag name in "_defaults" must be a non-empty string in %s.', $file));
+                }
+
+                foreach ($tag as $attribute => $value) {
+                    if (!is_scalar($value) && null !== $value) {
+                        throw new InvalidArgumentException(sprintf('Tag "%s", attribute "%s" in "_defaults" must be of a scalar-type in %s. Check your YAML syntax.', $name, $attribute, $file));
+                    }
+                }
+            }
+        }
+
+        if (isset($defaults['bind'])) {
+            if (!\is_array($defaults['bind'])) {
+                throw new InvalidArgumentException(sprintf('Parameter "bind" in "_defaults" must be an array in %s. Check your YAML syntax.', $file));
+            }
+
+            foreach ($this->resolveServices($defaults['bind'], $file) as $argument => $value) {
+                $defaults['bind'][$argument] = new BoundArgument($value, true, BoundArgument::DEFAULTS_BINDING, $file);
+            }
+        }
+
+        return $defaults;
+    }
+
+    private function isUsingShortSyntax(array $service): bool
+    {
+        foreach ($service as $key => $value) {
+            if (\is_string($key) && ('' === $key || '$' !== $key[0])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Parses a definition.
+     *
+     * @param array|string $service
+     *
+     * @throws InvalidArgumentException When tags are invalid
+     */
+    private function parseDefinition(string $id, $service, string $file, array $defaults)
+    {
+        if (preg_match('/^_[a-zA-Z0-9_]*$/', $id)) {
+            throw new InvalidArgumentException(sprintf('Service names that start with an underscore are reserved. Rename the "%s" service or define it in XML instead.', $id));
+        }
+
+        if (\is_string($service) && 0 === strpos($service, '@')) {
+            $this->container->setAlias($id, $alias = new Alias(substr($service, 1)));
+            if (isset($defaults['public'])) {
+                $alias->setPublic($defaults['public']);
+            }
+
+            return;
+        }
+
+        if (\is_array($service) && $this->isUsingShortSyntax($service)) {
+            $service = ['arguments' => $service];
+        }
+
+        if (null === $service) {
+            $service = [];
+        }
+
+        if (!\is_array($service)) {
+            throw new InvalidArgumentException(sprintf('A service definition must be an array or a string starting with "@" but %s found for service "%s" in %s. Check your YAML syntax.', \gettype($service), $id, $file));
+        }
+
+        $this->checkDefinition($id, $service, $file);
+
+        if (isset($service['alias'])) {
+            $this->container->setAlias($id, $alias = new Alias($service['alias']));
+            if (\array_key_exists('public', $service)) {
+                $alias->setPublic($service['public']);
+            } elseif (isset($defaults['public'])) {
+                $alias->setPublic($defaults['public']);
+            }
+
+            foreach ($service as $key => $value) {
+                if (!\in_array($key, ['alias', 'public', 'deprecated'])) {
+                    throw new InvalidArgumentException(sprintf('The configuration key "%s" is unsupported for the service "%s" which is defined as an alias in "%s". Allowed configuration keys for service aliases are "alias", "public" and "deprecated".', $key, $id, $file));
+                }
+
+                if ('deprecated' === $key) {
+                    $alias->setDeprecated(true, $value);
+                }
+            }
+
+            return;
+        }
+
+        if ($this->isLoadingInstanceof) {
+            $definition = new ChildDefinition('');
+        } elseif (isset($service['parent'])) {
+            if (!empty($this->instanceof)) {
+                throw new InvalidArgumentException(sprintf('The service "%s" cannot use the "parent" option in the same file where "_instanceof" configuration is defined as using both is not supported. Move your child definitions to a separate file.', $id));
+            }
+
+            foreach ($defaults as $k => $v) {
+                if ('tags' === $k) {
+                    // since tags are never inherited from parents, there is no confusion
+                    // thus we can safely add them as defaults to ChildDefinition
+                    continue;
+                }
+                if ('bind' === $k) {
+                    throw new InvalidArgumentException(sprintf('Attribute "bind" on service "%s" cannot be inherited from "_defaults" when a "parent" is set. Move your child definitions to a separate file.', $id));
+                }
+                if (!isset($service[$k])) {
+                    throw new InvalidArgumentException(sprintf('Attribute "%s" on service "%s" cannot be inherited from "_defaults" when a "parent" is set. Move your child definitions to a separate file or define this attribute explicitly.', $k, $id));
+                }
+            }
+
+            if ('' !== $service['parent'] && '@' === $service['parent'][0]) {
+                throw new InvalidArgumentException(sprintf('The value of the "parent" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s").', $id, $service['parent'], substr($service['parent'], 1)));
+            }
+
+            $definition = new ChildDefinition($service['parent']);
+        } else {
+            $definition = new Definition();
+
+            if (isset($defaults['public'])) {
+                $definition->setPublic($defaults['public']);
+            }
+            if (isset($defaults['autowire'])) {
+                $definition->setAutowired($defaults['autowire']);
+            }
+            if (isset($defaults['autoconfigure'])) {
+                $definition->setAutoconfigured($defaults['autoconfigure']);
+            }
+
+            $definition->setChanges([]);
+        }
+
+        if (isset($service['class'])) {
+            $definition->setClass($service['class']);
+        }
+
+        if (isset($service['shared'])) {
+            $definition->setShared($service['shared']);
+        }
+
+        if (isset($service['synthetic'])) {
+            $definition->setSynthetic($service['synthetic']);
+        }
+
+        if (isset($service['lazy'])) {
+            $definition->setLazy((bool) $service['lazy']);
+            if (\is_string($service['lazy'])) {
+                $definition->addTag('proxy', ['interface' => $service['lazy']]);
+            }
+        }
+
+        if (isset($service['public'])) {
+            $definition->setPublic($service['public']);
+        }
+
+        if (isset($service['abstract'])) {
+            $definition->setAbstract($service['abstract']);
+        }
+
+        if (\array_key_exists('deprecated', $service)) {
+            $definition->setDeprecated(true, $service['deprecated']);
+        }
+
+        if (isset($service['factory'])) {
+            $definition->setFactory($this->parseCallable($service['factory'], 'factory', $id, $file));
+        }
+
+        if (isset($service['file'])) {
+            $definition->setFile($service['file']);
+        }
+
+        if (isset($service['arguments'])) {
+            $definition->setArguments($this->resolveServices($service['arguments'], $file));
+        }
+
+        if (isset($service['properties'])) {
+            $definition->setProperties($this->resolveServices($service['properties'], $file));
+        }
+
+        if (isset($service['configurator'])) {
+            $definition->setConfigurator($this->parseCallable($service['configurator'], 'configurator', $id, $file));
+        }
+
+        if (isset($service['calls'])) {
+            if (!\is_array($service['calls'])) {
+                throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
+            }
+
+            foreach ($service['calls'] as $k => $call) {
+                if (!\is_array($call) && (!\is_string($k) || !$call instanceof TaggedValue)) {
+                    throw new InvalidArgumentException(sprintf('Invalid method call for service "%s": expected map or array, %s given in %s.', $id, $call instanceof TaggedValue ? '!'.$call->getTag() : \gettype($call), $file));
+                }
+
+                if (\is_string($k)) {
+                    throw new InvalidArgumentException(sprintf('Invalid method call for service "%s", did you forgot a leading dash before "%s: ..." in %s?', $id, $k, $file));
+                }
+
+                if (isset($call['method'])) {
+                    $method = $call['method'];
+                    $args = $call['arguments'] ?? [];
+                    $returnsClone = $call['returns_clone'] ?? false;
+                } else {
+                    if (1 === \count($call) && \is_string(key($call))) {
+                        $method = key($call);
+                        $args = $call[$method];
+
+                        if ($args instanceof TaggedValue) {
+                            if ('returns_clone' !== $args->getTag()) {
+                                throw new InvalidArgumentException(sprintf('Unsupported tag "!%s", did you mean "!returns_clone" for service "%s" in %s?', $args->getTag(), $id, $file));
+                            }
+
+                            $returnsClone = true;
+                            $args = $args->getValue();
+                        } else {
+                            $returnsClone = false;
+                        }
+                    } elseif (empty($call[0])) {
+                        throw new InvalidArgumentException(sprintf('Invalid call for service "%s": the method must be defined as the first index of an array or as the only key of a map in %s.', $id, $file));
+                    } else {
+                        $method = $call[0];
+                        $args = $call[1] ?? [];
+                        $returnsClone = $call[2] ?? false;
+                    }
+                }
+
+                if (!\is_array($args)) {
+                    throw new InvalidArgumentException(sprintf('The second parameter for function call "%s" must be an array of its arguments for service "%s" in %s. Check your YAML syntax.', $method, $id, $file));
+                }
+
+                $args = $this->resolveServices($args, $file);
+                $definition->addMethodCall($method, $args, $returnsClone);
+            }
+        }
+
+        $tags = isset($service['tags']) ? $service['tags'] : [];
+        if (!\is_array($tags)) {
+            throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
+        }
+
+        if (isset($defaults['tags'])) {
+            $tags = array_merge($tags, $defaults['tags']);
+        }
+
+        foreach ($tags as $tag) {
+            if (!\is_array($tag)) {
+                $tag = ['name' => $tag];
+            }
+
+            if (!isset($tag['name'])) {
+                throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file));
+            }
+            $name = $tag['name'];
+            unset($tag['name']);
+
+            if (!\is_string($name) || '' === $name) {
+                throw new InvalidArgumentException(sprintf('The tag name for service "%s" in %s must be a non-empty string.', $id, $file));
+            }
+
+            foreach ($tag as $attribute => $value) {
+                if (!is_scalar($value) && null !== $value) {
+                    throw new InvalidArgumentException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s" in %s. Check your YAML syntax.', $id, $name, $attribute, $file));
+                }
+            }
+
+            $definition->addTag($name, $tag);
+        }
+
+        if (null !== $decorates = $service['decorates'] ?? null) {
+            if ('' !== $decorates && '@' === $decorates[0]) {
+                throw new InvalidArgumentException(sprintf('The value of the "decorates" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s").', $id, $service['decorates'], substr($decorates, 1)));
+            }
+
+            $decorationOnInvalid = \array_key_exists('decoration_on_invalid', $service) ? $service['decoration_on_invalid'] : 'exception';
+            if ('exception' === $decorationOnInvalid) {
+                $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+            } elseif ('ignore' === $decorationOnInvalid) {
+                $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
+            } elseif (null === $decorationOnInvalid) {
+                $invalidBehavior = ContainerInterface::NULL_ON_INVALID_REFERENCE;
+            } elseif ('null' === $decorationOnInvalid) {
+                throw new InvalidArgumentException(sprintf('Invalid value "%s" for attribute "decoration_on_invalid" on service "%s". Did you mean null (without quotes) in "%s"?', $decorationOnInvalid, $id, $file));
+            } else {
+                throw new InvalidArgumentException(sprintf('Invalid value "%s" for attribute "decoration_on_invalid" on service "%s". Did you mean "exception", "ignore" or null in "%s"?', $decorationOnInvalid, $id, $file));
+            }
+
+            $renameId = isset($service['decoration_inner_name']) ? $service['decoration_inner_name'] : null;
+            $priority = isset($service['decoration_priority']) ? $service['decoration_priority'] : 0;
+
+            $definition->setDecoratedService($decorates, $renameId, $priority, $invalidBehavior);
+        }
+
+        if (isset($service['autowire'])) {
+            $definition->setAutowired($service['autowire']);
+        }
+
+        if (isset($defaults['bind']) || isset($service['bind'])) {
+            // deep clone, to avoid multiple process of the same instance in the passes
+            $bindings = isset($defaults['bind']) ? unserialize(serialize($defaults['bind'])) : [];
+
+            if (isset($service['bind'])) {
+                if (!\is_array($service['bind'])) {
+                    throw new InvalidArgumentException(sprintf('Parameter "bind" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
+                }
+
+                $bindings = array_merge($bindings, $this->resolveServices($service['bind'], $file));
+                $bindingType = $this->isLoadingInstanceof ? BoundArgument::INSTANCEOF_BINDING : BoundArgument::SERVICE_BINDING;
+                foreach ($bindings as $argument => $value) {
+                    if (!$value instanceof BoundArgument) {
+                        $bindings[$argument] = new BoundArgument($value, true, $bindingType, $file);
+                    }
+                }
+            }
+
+            $definition->setBindings($bindings);
+        }
+
+        if (isset($service['autoconfigure'])) {
+            if (!$definition instanceof ChildDefinition) {
+                $definition->setAutoconfigured($service['autoconfigure']);
+            } elseif ($service['autoconfigure']) {
+                throw new InvalidArgumentException(sprintf('The service "%s" cannot have a "parent" and also have "autoconfigure". Try setting "autoconfigure: false" for the service.', $id));
+            }
+        }
+
+        if (\array_key_exists('namespace', $service) && !\array_key_exists('resource', $service)) {
+            throw new InvalidArgumentException(sprintf('A "resource" attribute must be set when the "namespace" attribute is set for service "%s" in %s. Check your YAML syntax.', $id, $file));
+        }
+
+        if (\array_key_exists('resource', $service)) {
+            if (!\is_string($service['resource'])) {
+                throw new InvalidArgumentException(sprintf('A "resource" attribute must be of type string for service "%s" in %s. Check your YAML syntax.', $id, $file));
+            }
+            $exclude = isset($service['exclude']) ? $service['exclude'] : null;
+            $namespace = isset($service['namespace']) ? $service['namespace'] : $id;
+            $this->registerClasses($definition, $namespace, $service['resource'], $exclude);
+        } else {
+            $this->setDefinition($id, $definition);
+        }
+    }
+
+    /**
+     * Parses a callable.
+     *
+     * @param string|array $callable A callable reference
+     *
+     * @throws InvalidArgumentException When errors occur
+     *
+     * @return string|array|Reference A parsed callable
+     */
+    private function parseCallable($callable, string $parameter, string $id, string $file)
+    {
+        if (\is_string($callable)) {
+            if ('' !== $callable && '@' === $callable[0]) {
+                if (false === strpos($callable, ':')) {
+                    return [$this->resolveServices($callable, $file), '__invoke'];
+                }
+
+                throw new InvalidArgumentException(sprintf('The value of the "%s" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s" in "%s").', $parameter, $id, $callable, substr($callable, 1), $file));
+            }
+
+            if (false !== strpos($callable, ':') && false === strpos($callable, '::')) {
+                $parts = explode(':', $callable);
+
+                @trigger_error(sprintf('Using short %s syntax for service "%s" is deprecated since Symfony 4.4, use "[\'@%s\', \'%s\']" instead.', $parameter, $id, ...$parts), E_USER_DEPRECATED);
+
+                return [$this->resolveServices('@'.$parts[0], $file), $parts[1]];
+            }
+
+            return $callable;
+        }
+
+        if (\is_array($callable)) {
+            if (isset($callable[0]) && isset($callable[1])) {
+                return [$this->resolveServices($callable[0], $file), $callable[1]];
+            }
+
+            if ('factory' === $parameter && isset($callable[1]) && null === $callable[0]) {
+                return $callable;
+            }
+
+            throw new InvalidArgumentException(sprintf('Parameter "%s" must contain an array with two elements for service "%s" in %s. Check your YAML syntax.', $parameter, $id, $file));
+        }
+
+        throw new InvalidArgumentException(sprintf('Parameter "%s" must be a string or an array for service "%s" in %s. Check your YAML syntax.', $parameter, $id, $file));
+    }
+
+    /**
+     * Loads a YAML file.
+     *
+     * @param string $file
+     *
+     * @return array The file content
+     *
+     * @throws InvalidArgumentException when the given file is not a local file or when it does not exist
+     */
+    protected function loadFile($file)
+    {
+        if (!class_exists('Symfony\Component\Yaml\Parser')) {
+            throw new RuntimeException('Unable to load YAML config files as the Symfony Yaml Component is not installed.');
+        }
+
+        if (!stream_is_local($file)) {
+            throw new InvalidArgumentException(sprintf('This is not a local file "%s".', $file));
+        }
+
+        if (!file_exists($file)) {
+            throw new InvalidArgumentException(sprintf('The file "%s" does not exist.', $file));
+        }
+
+        if (null === $this->yamlParser) {
+            $this->yamlParser = new YamlParser();
+        }
+
+        try {
+            $configuration = $this->yamlParser->parseFile($file, Yaml::PARSE_CONSTANT | Yaml::PARSE_CUSTOM_TAGS);
+        } catch (ParseException $e) {
+            throw new InvalidArgumentException(sprintf('The file "%s" does not contain valid YAML: %s', $file, $e->getMessage()), 0, $e);
+        }
+
+        return $this->validate($configuration, $file);
+    }
+
+    /**
+     * Validates a YAML file.
+     *
+     * @throws InvalidArgumentException When service file is not valid
+     */
+    private function validate($content, string $file): ?array
+    {
+        if (null === $content) {
+            return $content;
+        }
+
+        if (!\is_array($content)) {
+            throw new InvalidArgumentException(sprintf('The service file "%s" is not valid. It should contain an array. Check your YAML syntax.', $file));
+        }
+
+        foreach ($content as $namespace => $data) {
+            if (\in_array($namespace, ['imports', 'parameters', 'services'])) {
+                continue;
+            }
+
+            if (!$this->container->hasExtension($namespace)) {
+                $extensionNamespaces = array_filter(array_map(function (ExtensionInterface $ext) { return $ext->getAlias(); }, $this->container->getExtensions()));
+                throw new InvalidArgumentException(sprintf('There is no extension able to load the configuration for "%s" (in %s). Looked for namespace "%s", found %s', $namespace, $file, $namespace, $extensionNamespaces ? sprintf('"%s"', implode('", "', $extensionNamespaces)) : 'none'));
+            }
+        }
+
+        return $content;
+    }
+
+    /**
+     * Resolves services.
+     *
+     * @return array|string|Reference|ArgumentInterface
+     */
+    private function resolveServices($value, string $file, bool $isParameter = false)
+    {
+        if ($value instanceof TaggedValue) {
+            $argument = $value->getValue();
+            if ('iterator' === $value->getTag()) {
+                if (!\is_array($argument)) {
+                    throw new InvalidArgumentException(sprintf('"!iterator" tag only accepts sequences in "%s".', $file));
+                }
+                $argument = $this->resolveServices($argument, $file, $isParameter);
+                try {
+                    return new IteratorArgument($argument);
+                } catch (InvalidArgumentException $e) {
+                    throw new InvalidArgumentException(sprintf('"!iterator" tag only accepts arrays of "@service" references in "%s".', $file));
+                }
+            }
+            if ('service_locator' === $value->getTag()) {
+                if (!\is_array($argument)) {
+                    throw new InvalidArgumentException(sprintf('"!service_locator" tag only accepts maps in "%s".', $file));
+                }
+
+                $argument = $this->resolveServices($argument, $file, $isParameter);
+
+                try {
+                    return new ServiceLocatorArgument($argument);
+                } catch (InvalidArgumentException $e) {
+                    throw new InvalidArgumentException(sprintf('"!service_locator" tag only accepts maps of "@service" references in "%s".', $file));
+                }
+            }
+            if (\in_array($value->getTag(), ['tagged', 'tagged_iterator', 'tagged_locator'], true)) {
+                $forLocator = 'tagged_locator' === $value->getTag();
+
+                if (\is_array($argument) && isset($argument['tag']) && $argument['tag']) {
+                    if ($diff = array_diff(array_keys($argument), ['tag', 'index_by', 'default_index_method', 'default_priority_method'])) {
+                        throw new InvalidArgumentException(sprintf('"!%s" tag contains unsupported key "%s"; supported ones are "tag", "index_by", "default_index_method", and "default_priority_method".', $value->getTag(), implode('"", "', $diff)));
+                    }
+
+                    $argument = new TaggedIteratorArgument($argument['tag'], $argument['index_by'] ?? null, $argument['default_index_method'] ?? null, $forLocator, $argument['default_priority_method'] ?? null);
+                } elseif (\is_string($argument) && $argument) {
+                    $argument = new TaggedIteratorArgument($argument, null, null, $forLocator);
+                } else {
+                    throw new InvalidArgumentException(sprintf('"!%s" tags only accept a non empty string or an array with a key "tag" in "%s".', $value->getTag(), $file));
+                }
+
+                if ($forLocator) {
+                    $argument = new ServiceLocatorArgument($argument);
+                }
+
+                return $argument;
+            }
+            if ('service' === $value->getTag()) {
+                if ($isParameter) {
+                    throw new InvalidArgumentException(sprintf('Using an anonymous service in a parameter is not allowed in "%s".', $file));
+                }
+
+                $isLoadingInstanceof = $this->isLoadingInstanceof;
+                $this->isLoadingInstanceof = false;
+                $instanceof = $this->instanceof;
+                $this->instanceof = [];
+
+                $id = sprintf('.%d_%s', ++$this->anonymousServicesCount, preg_replace('/^.*\\\\/', '', isset($argument['class']) ? $argument['class'] : '').$this->anonymousServicesSuffix);
+                $this->parseDefinition($id, $argument, $file, []);
+
+                if (!$this->container->hasDefinition($id)) {
+                    throw new InvalidArgumentException(sprintf('Creating an alias using the tag "!service" is not allowed in "%s".', $file));
+                }
+
+                $this->container->getDefinition($id)->setPublic(false);
+
+                $this->isLoadingInstanceof = $isLoadingInstanceof;
+                $this->instanceof = $instanceof;
+
+                return new Reference($id);
+            }
+
+            throw new InvalidArgumentException(sprintf('Unsupported tag "!%s".', $value->getTag()));
+        }
+
+        if (\is_array($value)) {
+            foreach ($value as $k => $v) {
+                $value[$k] = $this->resolveServices($v, $file, $isParameter);
+            }
+        } elseif (\is_string($value) && 0 === strpos($value, '@=')) {
+            if (!class_exists(Expression::class)) {
+                throw new \LogicException(sprintf('The "@=" expression syntax cannot be used without the ExpressionLanguage component. Try running "composer require symfony/expression-language".'));
+            }
+
+            return new Expression(substr($value, 2));
+        } elseif (\is_string($value) && 0 === strpos($value, '@')) {
+            if (0 === strpos($value, '@@')) {
+                $value = substr($value, 1);
+                $invalidBehavior = null;
+            } elseif (0 === strpos($value, '@!')) {
+                $value = substr($value, 2);
+                $invalidBehavior = ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE;
+            } elseif (0 === strpos($value, '@?')) {
+                $value = substr($value, 2);
+                $invalidBehavior = ContainerInterface::IGNORE_ON_INVALID_REFERENCE;
+            } else {
+                $value = substr($value, 1);
+                $invalidBehavior = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
+            }
+
+            if (null !== $invalidBehavior) {
+                $value = new Reference($value, $invalidBehavior);
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * Loads from Extensions.
+     */
+    private function loadFromExtensions(array $content)
+    {
+        foreach ($content as $namespace => $values) {
+            if (\in_array($namespace, ['imports', 'parameters', 'services'])) {
+                continue;
+            }
+
+            if (!\is_array($values) && null !== $values) {
+                $values = [];
+            }
+
+            $this->container->loadFromExtension($namespace, $values);
+        }
+    }
+
+    /**
+     * Checks the keywords used to define a service.
+     */
+    private function checkDefinition(string $id, array $definition, string $file)
+    {
+        if ($this->isLoadingInstanceof) {
+            $keywords = self::$instanceofKeywords;
+        } elseif (isset($definition['resource']) || isset($definition['namespace'])) {
+            $keywords = self::$prototypeKeywords;
+        } else {
+            $keywords = self::$serviceKeywords;
+        }
+
+        foreach ($definition as $key => $value) {
+            if (!isset($keywords[$key])) {
+                throw new InvalidArgumentException(sprintf('The configuration key "%s" is unsupported for definition "%s" in "%s". Allowed configuration keys are "%s".', $key, $id, $file, implode('", "', $keywords)));
+            }
+        }
+    }
+}
diff --git a/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/schema/dic/services/services-1.0.xsd b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/schema/dic/services/services-1.0.xsd
new file mode 100644
index 0000000..2f745c3
--- /dev/null
+++ b/srcs/phpmyadmin/vendor/symfony/dependency-injection/Loader/schema/dic/services/services-1.0.xsd
@@ -0,0 +1,305 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<xsd:schema xmlns="http://symfony.com/schema/dic/services"
+     xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+     targetNamespace="http://symfony.com/schema/dic/services"
+     elementFormDefault="qualified">
+
+  <xsd:annotation>
+    <xsd:documentation><![CDATA[
+      Symfony XML Services Schema, version 1.0
+      Authors: Fabien Potencier
+
+      This defines a way to describe PHP objects (services) and their
+      dependencies.
+    ]]></xsd:documentation>
+  </xsd:annotation>
+
+  <xsd:element name="container" type="container" />
+
+  <xsd:complexType name="container">
+    <xsd:annotation>
+      <xsd:documentation><![CDATA[
+        The root element of a service file.
+      ]]></xsd:documentation>
+    </xsd:annotation>
+    <xsd:sequence>
+      <xsd:group ref="foreign" />
+      <xsd:sequence minOccurs="0">
+        <xsd:element name="imports" type="imports" />
+        <xsd:group ref="foreign" />
+      </xsd:sequence>
+      <xsd:sequence minOccurs="0">
+        <xsd:element name="parameters" type="parameters" />
+        <xsd:group ref="foreign" />
+      </xsd:sequence>
+      <xsd:sequence minOccurs="0">
+        <xsd:element name="services" type="services" />
+        <xsd:group ref="foreign" />
+      </xsd:sequence>
+    </xsd:sequence>
+  </xsd:complexType>
+
+  <xsd:group name="foreign">
+    <xsd:sequence>
+      <xsd:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded" />
+    </xsd:sequence>
+  </xsd:group>
+
+  <xsd:complexType name="services">
+    <xsd:annotation>
+      <xsd:documentation><![CDATA[
+        Enclosing element for the definition of all services
+      ]]></xsd:documentation>
+    </xsd:annotation>
+    <xsd:choice maxOccurs="unbounded">
+      <xsd:element name="service" type="service" minOccurs="1" />
+      <xsd:element name="prototype" type="prototype" minOccurs="0" />
+      <xsd:element name="defaults" type="defaults" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="instanceof" type="instanceof" minOccurs="0" />
+    </xsd:choice>
+  </xsd:complexType>
+
+  <xsd:complexType name="imports">
+    <xsd:annotation>
+      <xsd:documentation><![CDATA[
+        Enclosing element for the import elements
+      ]]></xsd:documentation>
+    </xsd:annotation>
+    <xsd:choice minOccurs="1" maxOccurs="unbounded">
+      <xsd:element name="import" type="import" />
+    </xsd:choice>
+  </xsd:complexType>
+
+  <xsd:complexType name="import">
+    <xsd:annotation>
+      <xsd:documentation><![CDATA[
+        Import an external resource defining other services or parameters
+      ]]></xsd:documentation>
+    </xsd:annotation>
+    <xsd:attribute name="resource" type="xsd:string" use="required" />
+    <xsd:attribute name="ignore-errors" type="ignore_errors" />
+    <xsd:attribute name="type" type="xsd:string" />
+  </xsd:complexType>
+
+  <xsd:complexType name="callable">
+    <xsd:choice minOccurs="0" maxOccurs="1">
+      <xsd:element name="service" type="service" minOccurs="0" maxOccurs="1" />
+    </xsd:choice>
+    <xsd:attribute name="service" type="xsd:string" />
+    <xsd:attribute name="class" type="xsd:string" />
+    <xsd:attribute name="method" type="xsd:string" />
+    <xsd:attribute name="function" type="xsd:string" />
+  </xsd:complexType>
+
+  <xsd:complexType name="defaults">
+    <xsd:annotation>
+      <xsd:documentation><![CDATA[
+        Enclosing element for the service definitions' defaults for the current file
+      ]]></xsd:documentation>
+    </xsd:annotation>
+    <xsd:choice maxOccurs="unbounded">
+      <xsd:element name="tag" type="tag" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="bind" type="bind" minOccurs="0" maxOccurs="unbounded" />
+    </xsd:choice>
+    <xsd:attribute name="public" type="boolean" />
+    <xsd:attribute name="autowire" type="boolean" />
+    <xsd:attribute name="autoconfigure" type="boolean" />
+  </xsd:complexType>
+
+  <xsd:complexType name="service">
+    <xsd:choice maxOccurs="unbounded">
+      <xsd:element name="file" type="xsd:string" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="argument" type="argument" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="configurator" type="callable" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="factory" type="callable" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="deprecated" type="xsd:string" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="call" type="call" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="tag" type="tag" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="property" type="property" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="bind" type="bind" minOccurs="0" maxOccurs="unbounded" />
+    </xsd:choice>
+    <xsd:attribute name="id" type="xsd:string" />
+    <xsd:attribute name="class" type="xsd:string" />
+    <xsd:attribute name="shared" type="boolean" />
+    <xsd:attribute name="public" type="boolean" />
+    <xsd:attribute name="synthetic" type="boolean" />
+    <xsd:attribute name="lazy" type="xsd:string" />
+    <xsd:attribute name="abstract" type="boolean" />
+    <xsd:attribute name="alias" type="xsd:string" />
+    <xsd:attribute name="parent" type="xsd:string" />
+    <xsd:attribute name="decorates" type="xsd:string" />
+    <xsd:attribute name="decoration-on-invalid" type="invalid_decorated_service_sequence" />
+    <xsd:attribute name="decoration-inner-name" type="xsd:string" />
+    <xsd:attribute name="decoration-priority" type="xsd:integer" />
+    <xsd:attribute name="autowire" type="boolean" />
+    <xsd:attribute name="autoconfigure" type="boolean" />
+  </xsd:complexType>
+
+  <xsd:complexType name="instanceof">
+    <xsd:choice maxOccurs="unbounded">
+      <xsd:element name="configurator" type="callable" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="call" type="call" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="tag" type="tag" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="property" type="property" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="bind" type="bind" minOccurs="0" maxOccurs="unbounded" />
+    </xsd:choice>
+    <xsd:attribute name="id" type="xsd:string" use="required" />
+    <xsd:attribute name="shared" type="boolean" />
+    <xsd:attribute name="public" type="boolean" />
+    <xsd:attribute name="lazy" type="xsd:string" />
+    <xsd:attribute name="autowire" type="boolean" />
+    <xsd:attribute name="autoconfigure" type="boolean" />
+  </xsd:complexType>
+
+  <xsd:complexType name="prototype">
+    <xsd:choice maxOccurs="unbounded">
+      <xsd:element name="argument" type="argument" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="configurator" type="callable" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="factory" type="callable" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="deprecated" type="xsd:string" minOccurs="0" maxOccurs="1" />
+      <xsd:element name="call" type="call" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="tag" type="tag" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="property" type="property" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="bind" type="bind" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="exclude" type="xsd:string" minOccurs="0" maxOccurs="unbounded" />
+    </xsd:choice>
+    <xsd:attribute name="namespace" type="xsd:string" use="required" />
+    <xsd:attribute name="resource" type="xsd:string" use="required" />
+    <xsd:attribute name="exclude" type="xsd:string" />
+    <xsd:attribute name="shared" type="boolean" />
+    <xsd:attribute name="public" type="boolean" />
+    <xsd:attribute name="lazy" type="xsd:string" />
+    <xsd:attribute name="abstract" type="boolean" />
+    <xsd:attribute name="parent" type="xsd:string" />
+    <xsd:attribute name="autowire" type="boolean" />
+    <xsd:attribute name="autoconfigure" type="boolean" />
+  </xsd:complexType>
+
+  <xsd:complexType name="tag">
+    <xsd:attribute name="name" type="xsd:string" use="required" />
+    <xsd:anyAttribute namespace="##any" processContents="lax" />
+  </xsd:complexType>
+
+  <xsd:complexType name="parameters">
+    <xsd:choice minOccurs="1" maxOccurs="unbounded">
+      <xsd:element name="parameter" type="parameter" />
+    </xsd:choice>
+    <xsd:attribute name="type" type="parameter_type" />
+    <xsd:attribute name="key" type="xsd:string" />
+  </xsd:complexType>
+
+  <xsd:complexType name="parameter" mixed="true">
+    <xsd:choice minOccurs="0" maxOccurs="unbounded">
+      <xsd:element name="parameter" type="parameter" />
+    </xsd:choice>
+    <xsd:attribute name="type" type="parameter_type" />
+    <xsd:attribute name="id" type="xsd:string" />
+    <xsd:attribute name="key" type="xsd:string" />
+    <xsd:attribute name="on-invalid" type="invalid_sequence" />
+  </xsd:complexType>
+
+  <xsd:complexType name="property" mixed="true">
+    <xsd:choice minOccurs="0">
+      <xsd:element name="property" type="property" maxOccurs="unbounded" />
+      <xsd:element name="service" type="service" />
+    </xsd:choice>
+    <xsd:attribute name="type" type="argument_type" />
+    <xsd:attribute name="id" type="xsd:string" />
+    <xsd:attribute name="key" type="xsd:string" />
+    <xsd:attribute name="name" type="xsd:string" />
+    <xsd:attribute name="on-invalid" type="invalid_sequence" />
+    <xsd:attribute name="tag" type="xsd:string" />
+  </xsd:complexType>
+
+  <xsd:complexType name="bind" mixed="true">
+    <xsd:choice maxOccurs="unbounded">
+      <xsd:element name="bind" type="argument" minOccurs="0" maxOccurs="unbounded" />
+      <xsd:element name="service" type="service" />
+    </xsd:choice>
+    <xsd:attribute name="type" type="argument_type" />
+    <xsd:attribute name="id" type="xsd:string" />
+    <xsd:attribute name="key" type="xsd:string" use="required" />
+    <xsd:attribute name="on-invalid" type="invalid_sequence" />
+    <xsd:attribute name="method" type="xsd:string" />
+    <xsd:attribute name="tag" type="xsd:string" />
+  </xsd:complexType>
+
+  <xsd:complexType name="argument" mixed="true">
+    <xsd:choice minOccurs="0">
+      <xsd:element name="argument" type="argument" maxOccurs="unbounded" />
+      <xsd:element name="service" type="service" />
+    </xsd:choice>
+    <xsd:attribute name="type" type="argument_type" />
+    <xsd:attribute name="id" type="xsd:string" />
+    <xsd:attribute name="key" type="xsd:string" />
+    <xsd:attribute name="index" type="xsd:integer" />
+    <xsd:attribute name="on-invalid" type="invalid_sequence" />
+    <xsd:attribute name="tag" type="xsd:string" />
+    <xsd:attribute name="index-by" type="xsd:string" />
+    <xsd:attribute name="default-index-method" type="xsd:string" />
+    <xsd:attribute name="default-priority-method" type="xsd:string" />
+  </xsd:complexType>
+
+  <xsd:complexType name="call">
+    <xsd:choice minOccurs="0">
+      <xsd:element name="argument" type="argument" maxOccurs="unbounded" />
+    </xsd:choice>
+    <xsd:attribute name="method" type="xsd:string" />
+    <xsd:attribute name="returns-clone" type="boolean" />
+  </xsd:complexType>
+
+  <xsd:simpleType name="parameter_type">
+    <xsd:restriction base="xsd:string">
+      <xsd:enumeration value="collection" />
+      <xsd:enumeration value="string" />
+      <xsd:enumeration value="constant" />
+      <xsd:enumeration value="binary" />
+    </xsd:restriction>
+  </xsd:simpleType>
+
+  <xsd:simpleType name="argument_type">
+    <xsd:restriction base="xsd:string">
+      <xsd:enumeration value="collection" />
+      <xsd:enumeration value="service" />
+      <xsd:enumeration value="expression" />
+      <xsd:enumeration value="string" />
+      <xsd:enumeration value="constant" />
+      <xsd:enumeration value="iterator" />
+      <xsd:enumeration value="service_locator" />
+      <!-- "tagged" is an alias of "tagged_iterator", using "tagged_iterator" is preferred. -->
+      <xsd:enumeration value="tagged" />
+      <xsd:enumeration value="tagged_iterator" />
+      <xsd:enumeration value="tagged_locator" />
+    </xsd:restriction>
+  </xsd:simpleType>
+
+  <xsd:simpleType name="ignore_errors">
+    <xsd:restriction base="xsd:string">
+      <xsd:pattern value="(true|false|not_found)" />
+    </xsd:restriction>
+  </xsd:simpleType>
+
+  <xsd:simpleType name="invalid_sequence">
+    <xsd:restriction base="xsd:string">
+      <xsd:enumeration value="null" />
+      <xsd:enumeration value="ignore" />
+      <xsd:enumeration value="exception" />
+      <xsd:enumeration value="ignore_uninitialized" />
+    </xsd:restriction>
+  </xsd:simpleType>
+
+  <xsd:simpleType name="invalid_decorated_service_sequence">
+    <xsd:restriction base="xsd:string">
+      <xsd:enumeration value="null" />
+      <xsd:enumeration value="ignore" />
+      <xsd:enumeration value="exception" />
+    </xsd:restriction>
+  </xsd:simpleType>
+
+  <xsd:simpleType name="boolean">
+    <xsd:restriction base="xsd:string">
+      <xsd:pattern value="(%.+%|true|false)" />
+    </xsd:restriction>
+  </xsd:simpleType>
+</xsd:schema>