VERSION 0.2 doctrine ORM et entités

8 files changed, 1181 insertions, 0 deletions

diff --git a/vendor/symfony/var-exporter/Internal/Exporter.php b/vendor/symfony/var-exporter/Internal/Exporter.php
new file mode 100644
index 0000000..9f4f593
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/Exporter.php
@@ -0,0 +1,418 @@
+<?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\VarExporter\Internal;
+
+use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class Exporter
+{
+    /**
+     * Prepares an array of values for VarExporter.
+     *
+     * For performance this method is public and has no type-hints.
+     *
+     * @param array             &$values
+     * @param \SplObjectStorage $objectsPool
+     * @param array             &$refsPool
+     * @param int               &$objectsCount
+     * @param bool              &$valuesAreStatic
+     *
+     * @return array
+     *
+     * @throws NotInstantiableTypeException When a value cannot be serialized
+     */
+    public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount, &$valuesAreStatic)
+    {
+        $refs = $values;
+        foreach ($values as $k => $value) {
+            if (\is_resource($value)) {
+                throw new NotInstantiableTypeException(get_resource_type($value).' resource');
+            }
+            $refs[$k] = $objectsPool;
+
+            if ($isRef = !$valueIsStatic = $values[$k] !== $objectsPool) {
+                $values[$k] = &$value; // Break hard references to make $values completely
+                unset($value);         // independent from the original structure
+                $refs[$k] = $value = $values[$k];
+                if ($value instanceof Reference && 0 > $value->id) {
+                    $valuesAreStatic = false;
+                    ++$value->count;
+                    continue;
+                }
+                $refsPool[] = [&$refs[$k], $value, &$value];
+                $refs[$k] = $values[$k] = new Reference(-\count($refsPool), $value);
+            }
+
+            if (\is_array($value)) {
+                if ($value) {
+                    $value = self::prepare($value, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
+                }
+                goto handle_value;
+            } elseif (!\is_object($value) || $value instanceof \UnitEnum) {
+                goto handle_value;
+            }
+
+            $valueIsStatic = false;
+            if (isset($objectsPool[$value])) {
+                ++$objectsCount;
+                $value = new Reference($objectsPool[$value][0]);
+                goto handle_value;
+            }
+
+            $class = $value::class;
+            $reflector = Registry::$reflectors[$class] ??= Registry::getClassReflector($class);
+            $properties = [];
+
+            if ($reflector->hasMethod('__serialize')) {
+                if (!$reflector->getMethod('__serialize')->isPublic()) {
+                    throw new \Error(sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));
+                }
+
+                if (!\is_array($serializeProperties = $value->__serialize())) {
+                    throw new \TypeError($class.'::__serialize() must return an array');
+                }
+
+                if ($reflector->hasMethod('__unserialize')) {
+                    $properties = $serializeProperties;
+                } else {
+                    foreach ($serializeProperties as $n => $v) {
+                        $c = $reflector->hasProperty($n) && ($p = $reflector->getProperty($n))->isReadOnly() ? $p->class : 'stdClass';
+                        $properties[$c][$n] = $v;
+                    }
+                }
+
+                goto prepare_value;
+            }
+
+            $sleep = null;
+            $proto = Registry::$prototypes[$class];
+
+            if (($value instanceof \ArrayIterator || $value instanceof \ArrayObject) && null !== $proto) {
+                // ArrayIterator and ArrayObject need special care because their "flags"
+                // option changes the behavior of the (array) casting operator.
+                [$arrayValue, $properties] = self::getArrayObjectProperties($value, $proto);
+
+                // populates Registry::$prototypes[$class] with a new instance
+                Registry::getClassReflector($class, Registry::$instantiableWithoutConstructor[$class], Registry::$cloneable[$class]);
+            } elseif ($value instanceof \SplObjectStorage && Registry::$cloneable[$class] && null !== $proto) {
+                // By implementing Serializable, SplObjectStorage breaks
+                // internal references; let's deal with it on our own.
+                foreach (clone $value as $v) {
+                    $properties[] = $v;
+                    $properties[] = $value[$v];
+                }
+                $properties = ['SplObjectStorage' => ["\0" => $properties]];
+                $arrayValue = (array) $value;
+            } elseif ($value instanceof \Serializable
+                || $value instanceof \__PHP_Incomplete_Class
+            ) {
+                ++$objectsCount;
+                $objectsPool[$value] = [$id = \count($objectsPool), serialize($value), [], 0];
+                $value = new Reference($id);
+                goto handle_value;
+            } else {
+                if (method_exists($class, '__sleep')) {
+                    if (!\is_array($sleep = $value->__sleep())) {
+                        trigger_error('serialize(): __sleep should return an array only containing the names of instance-variables to serialize', \E_USER_NOTICE);
+                        $value = null;
+                        goto handle_value;
+                    }
+                    $sleep = array_flip($sleep);
+                }
+
+                $arrayValue = (array) $value;
+            }
+
+            $proto = (array) $proto;
+
+            foreach ($arrayValue as $name => $v) {
+                $i = 0;
+                $n = (string) $name;
+                if ('' === $n || "\0" !== $n[0]) {
+                    $c = $reflector->hasProperty($n) && ($p = $reflector->getProperty($n))->isReadOnly() ? $p->class : 'stdClass';
+                } elseif ('*' === $n[1]) {
+                    $n = substr($n, 3);
+                    $c = $reflector->getProperty($n)->class;
+                    if ('Error' === $c) {
+                        $c = 'TypeError';
+                    } elseif ('Exception' === $c) {
+                        $c = 'ErrorException';
+                    }
+                } else {
+                    $i = strpos($n, "\0", 2);
+                    $c = substr($n, 1, $i - 1);
+                    $n = substr($n, 1 + $i);
+                }
+                if (null !== $sleep) {
+                    if (!isset($sleep[$name]) && (!isset($sleep[$n]) || ($i && $c !== $class))) {
+                        unset($arrayValue[$name]);
+                        continue;
+                    }
+                    unset($sleep[$name], $sleep[$n]);
+                }
+                if (!\array_key_exists($name, $proto) || $proto[$name] !== $v || "\x00Error\x00trace" === $name || "\x00Exception\x00trace" === $name) {
+                    $properties[$c][$n] = $v;
+                }
+            }
+            if ($sleep) {
+                foreach ($sleep as $n => $v) {
+                    trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE);
+                }
+            }
+            if (method_exists($class, '__unserialize')) {
+                $properties = $arrayValue;
+            }
+
+            prepare_value:
+            $objectsPool[$value] = [$id = \count($objectsPool)];
+            $properties = self::prepare($properties, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
+            ++$objectsCount;
+            $objectsPool[$value] = [$id, $class, $properties, method_exists($class, '__unserialize') ? -$objectsCount : (method_exists($class, '__wakeup') ? $objectsCount : 0)];
+
+            $value = new Reference($id);
+
+            handle_value:
+            if ($isRef) {
+                unset($value); // Break the hard reference created above
+            } elseif (!$valueIsStatic) {
+                $values[$k] = $value;
+            }
+            $valuesAreStatic = $valueIsStatic && $valuesAreStatic;
+        }
+
+        return $values;
+    }
+
+    public static function export($value, $indent = '')
+    {
+        switch (true) {
+            case \is_int($value) || \is_float($value): return var_export($value, true);
+            case [] === $value: return '[]';
+            case false === $value: return 'false';
+            case true === $value: return 'true';
+            case null === $value: return 'null';
+            case '' === $value: return "''";
+            case $value instanceof \UnitEnum: return '\\'.ltrim(var_export($value, true), '\\');
+        }
+
+        if ($value instanceof Reference) {
+            if (0 <= $value->id) {
+                return '$o['.$value->id.']';
+            }
+            if (!$value->count) {
+                return self::export($value->value, $indent);
+            }
+            $value = -$value->id;
+
+            return '&$r['.$value.']';
+        }
+        $subIndent = $indent.'    ';
+
+        if (\is_string($value)) {
+            $code = sprintf("'%s'", addcslashes($value, "'\\"));
+
+            $code = preg_replace_callback("/((?:[\\0\\r\\n]|\u{202A}|\u{202B}|\u{202D}|\u{202E}|\u{2066}|\u{2067}|\u{2068}|\u{202C}|\u{2069})++)(.)/", function ($m) use ($subIndent) {
+                $m[1] = sprintf('\'."%s".\'', str_replace(
+                    ["\0", "\r", "\n", "\u{202A}", "\u{202B}", "\u{202D}", "\u{202E}", "\u{2066}", "\u{2067}", "\u{2068}", "\u{202C}", "\u{2069}", '\n\\'],
+                    ['\0', '\r', '\n', '\u{202A}', '\u{202B}', '\u{202D}', '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{202C}', '\u{2069}', '\n"'."\n".$subIndent.'."\\'],
+                    $m[1]
+                ));
+
+                if ("'" === $m[2]) {
+                    return substr($m[1], 0, -2);
+                }
+
+                if (str_ends_with($m[1], 'n".\'')) {
+                    return substr_replace($m[1], "\n".$subIndent.".'".$m[2], -2);
+                }
+
+                return $m[1].$m[2];
+            }, $code, -1, $count);
+
+            if ($count && str_starts_with($code, "''.")) {
+                $code = substr($code, 3);
+            }
+
+            return $code;
+        }
+
+        if (\is_array($value)) {
+            $j = -1;
+            $code = '';
+            foreach ($value as $k => $v) {
+                $code .= $subIndent;
+                if (!\is_int($k) || 1 !== $k - $j) {
+                    $code .= self::export($k, $subIndent).' => ';
+                }
+                if (\is_int($k) && $k > $j) {
+                    $j = $k;
+                }
+                $code .= self::export($v, $subIndent).",\n";
+            }
+
+            return "[\n".$code.$indent.']';
+        }
+
+        if ($value instanceof Values) {
+            $code = $subIndent."\$r = [],\n";
+            foreach ($value->values as $k => $v) {
+                $code .= $subIndent.'$r['.$k.'] = '.self::export($v, $subIndent).",\n";
+            }
+
+            return "[\n".$code.$indent.']';
+        }
+
+        if ($value instanceof Registry) {
+            return self::exportRegistry($value, $indent, $subIndent);
+        }
+
+        if ($value instanceof Hydrator) {
+            return self::exportHydrator($value, $indent, $subIndent);
+        }
+
+        throw new \UnexpectedValueException(sprintf('Cannot export value of type "%s".', get_debug_type($value)));
+    }
+
+    private static function exportRegistry(Registry $value, string $indent, string $subIndent): string
+    {
+        $code = '';
+        $serializables = [];
+        $seen = [];
+        $prototypesAccess = 0;
+        $factoriesAccess = 0;
+        $r = '\\'.Registry::class;
+        $j = -1;
+
+        foreach ($value->classes as $k => $class) {
+            if (':' === ($class[1] ?? null)) {
+                $serializables[$k] = $class;
+                continue;
+            }
+            if (!Registry::$instantiableWithoutConstructor[$class]) {
+                if (is_subclass_of($class, 'Serializable') && !method_exists($class, '__unserialize')) {
+                    $serializables[$k] = 'C:'.\strlen($class).':"'.$class.'":0:{}';
+                } else {
+                    $serializables[$k] = 'O:'.\strlen($class).':"'.$class.'":0:{}';
+                }
+                if (is_subclass_of($class, 'Throwable')) {
+                    $eol = is_subclass_of($class, 'Error') ? "\0Error\0" : "\0Exception\0";
+                    $serializables[$k] = substr_replace($serializables[$k], '1:{s:'.(5 + \strlen($eol)).':"'.$eol.'trace";a:0:{}}', -4);
+                }
+                continue;
+            }
+            $code .= $subIndent.(1 !== $k - $j ? $k.' => ' : '');
+            $j = $k;
+            $eol = ",\n";
+            $c = '['.self::export($class).']';
+
+            if ($seen[$class] ?? false) {
+                if (Registry::$cloneable[$class]) {
+                    ++$prototypesAccess;
+                    $code .= 'clone $p'.$c;
+                } else {
+                    ++$factoriesAccess;
+                    $code .= '$f'.$c.'()';
+                }
+            } else {
+                $seen[$class] = true;
+                if (Registry::$cloneable[$class]) {
+                    $code .= 'clone ('.($prototypesAccess++ ? '$p' : '($p = &'.$r.'::$prototypes)').$c.' ?? '.$r.'::p';
+                } else {
+                    $code .= '('.($factoriesAccess++ ? '$f' : '($f = &'.$r.'::$factories)').$c.' ?? '.$r.'::f';
+                    $eol = '()'.$eol;
+                }
+                $code .= '('.substr($c, 1, -1).'))';
+            }
+            $code .= $eol;
+        }
+
+        if (1 === $prototypesAccess) {
+            $code = str_replace('($p = &'.$r.'::$prototypes)', $r.'::$prototypes', $code);
+        }
+        if (1 === $factoriesAccess) {
+            $code = str_replace('($f = &'.$r.'::$factories)', $r.'::$factories', $code);
+        }
+        if ('' !== $code) {
+            $code = "\n".$code.$indent;
+        }
+
+        if ($serializables) {
+            $code = $r.'::unserialize(['.$code.'], '.self::export($serializables, $indent).')';
+        } else {
+            $code = '['.$code.']';
+        }
+
+        return '$o = '.$code;
+    }
+
+    private static function exportHydrator(Hydrator $value, string $indent, string $subIndent): string
+    {
+        $code = '';
+        foreach ($value->properties as $class => $properties) {
+            $code .= $subIndent.'    '.self::export($class).' => '.self::export($properties, $subIndent.'    ').",\n";
+        }
+
+        $code = [
+            self::export($value->registry, $subIndent),
+            self::export($value->values, $subIndent),
+            '' !== $code ? "[\n".$code.$subIndent.']' : '[]',
+            self::export($value->value, $subIndent),
+            self::export($value->wakeups, $subIndent),
+        ];
+
+        return '\\'.$value::class."::hydrate(\n".$subIndent.implode(",\n".$subIndent, $code)."\n".$indent.')';
+    }
+
+    /**
+     * @param \ArrayIterator|\ArrayObject $value
+     * @param \ArrayIterator|\ArrayObject $proto
+     */
+    private static function getArrayObjectProperties($value, $proto): array
+    {
+        $reflector = $value instanceof \ArrayIterator ? 'ArrayIterator' : 'ArrayObject';
+        $reflector = Registry::$reflectors[$reflector] ??= Registry::getClassReflector($reflector);
+
+        $properties = [
+            $arrayValue = (array) $value,
+            $reflector->getMethod('getFlags')->invoke($value),
+            $value instanceof \ArrayObject ? $reflector->getMethod('getIteratorClass')->invoke($value) : 'ArrayIterator',
+        ];
+
+        $reflector = $reflector->getMethod('setFlags');
+        $reflector->invoke($proto, \ArrayObject::STD_PROP_LIST);
+
+        if ($properties[1] & \ArrayObject::STD_PROP_LIST) {
+            $reflector->invoke($value, 0);
+            $properties[0] = (array) $value;
+        } else {
+            $reflector->invoke($value, \ArrayObject::STD_PROP_LIST);
+            $arrayValue = (array) $value;
+        }
+        $reflector->invoke($value, $properties[1]);
+
+        if ([[], 0, 'ArrayIterator'] === $properties) {
+            $properties = [];
+        } else {
+            if ('ArrayIterator' === $properties[2]) {
+                unset($properties[2]);
+            }
+            $properties = [$reflector->class => ["\0" => $properties]];
+        }
+
+        return [$arrayValue, $properties];
+    }
+}
diff --git a/vendor/symfony/var-exporter/Internal/Hydrator.php b/vendor/symfony/var-exporter/Internal/Hydrator.php
new file mode 100644
index 0000000..65fdcd1
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/Hydrator.php
@@ -0,0 +1,299 @@
+<?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\VarExporter\Internal;
+
+use Symfony\Component\VarExporter\Exception\ClassNotFoundException;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class Hydrator
+{
+    public static array $hydrators = [];
+    public static array $simpleHydrators = [];
+    public static array $propertyScopes = [];
+
+    public function __construct(
+        public readonly Registry $registry,
+        public readonly ?Values $values,
+        public readonly array $properties,
+        public readonly mixed $value,
+        public readonly array $wakeups,
+    ) {
+    }
+
+    public static function hydrate($objects, $values, $properties, $value, $wakeups)
+    {
+        foreach ($properties as $class => $vars) {
+            (self::$hydrators[$class] ??= self::getHydrator($class))($vars, $objects);
+        }
+        foreach ($wakeups as $k => $v) {
+            if (\is_array($v)) {
+                $objects[-$k]->__unserialize($v);
+            } else {
+                $objects[$v]->__wakeup();
+            }
+        }
+
+        return $value;
+    }
+
+    public static function getHydrator($class)
+    {
+        $baseHydrator = self::$hydrators['stdClass'] ??= static function ($properties, $objects) {
+            foreach ($properties as $name => $values) {
+                foreach ($values as $i => $v) {
+                    $objects[$i]->$name = $v;
+                }
+            }
+        };
+
+        switch ($class) {
+            case 'stdClass':
+                return $baseHydrator;
+
+            case 'ErrorException':
+                return $baseHydrator->bindTo(null, new class() extends \ErrorException {
+                });
+
+            case 'TypeError':
+                return $baseHydrator->bindTo(null, new class() extends \Error {
+                });
+
+            case 'SplObjectStorage':
+                return static function ($properties, $objects) {
+                    foreach ($properties as $name => $values) {
+                        if ("\0" === $name) {
+                            foreach ($values as $i => $v) {
+                                for ($j = 0; $j < \count($v); ++$j) {
+                                    $objects[$i]->attach($v[$j], $v[++$j]);
+                                }
+                            }
+                            continue;
+                        }
+                        foreach ($values as $i => $v) {
+                            $objects[$i]->$name = $v;
+                        }
+                    }
+                };
+        }
+
+        if (!class_exists($class) && !interface_exists($class, false) && !trait_exists($class, false)) {
+            throw new ClassNotFoundException($class);
+        }
+        $classReflector = new \ReflectionClass($class);
+
+        switch ($class) {
+            case 'ArrayIterator':
+            case 'ArrayObject':
+                $constructor = $classReflector->getConstructor()->invokeArgs(...);
+
+                return static function ($properties, $objects) use ($constructor) {
+                    foreach ($properties as $name => $values) {
+                        if ("\0" !== $name) {
+                            foreach ($values as $i => $v) {
+                                $objects[$i]->$name = $v;
+                            }
+                        }
+                    }
+                    foreach ($properties["\0"] ?? [] as $i => $v) {
+                        $constructor($objects[$i], $v);
+                    }
+                };
+        }
+
+        if (!$classReflector->isInternal()) {
+            return $baseHydrator->bindTo(null, $class);
+        }
+
+        if ($classReflector->name !== $class) {
+            return self::$hydrators[$classReflector->name] ??= self::getHydrator($classReflector->name);
+        }
+
+        $propertySetters = [];
+        foreach ($classReflector->getProperties() as $propertyReflector) {
+            if (!$propertyReflector->isStatic()) {
+                $propertySetters[$propertyReflector->name] = $propertyReflector->setValue(...);
+            }
+        }
+
+        if (!$propertySetters) {
+            return $baseHydrator;
+        }
+
+        return static function ($properties, $objects) use ($propertySetters) {
+            foreach ($properties as $name => $values) {
+                if ($setValue = $propertySetters[$name] ?? null) {
+                    foreach ($values as $i => $v) {
+                        $setValue($objects[$i], $v);
+                    }
+                    continue;
+                }
+                foreach ($values as $i => $v) {
+                    $objects[$i]->$name = $v;
+                }
+            }
+        };
+    }
+
+    public static function getSimpleHydrator($class)
+    {
+        $baseHydrator = self::$simpleHydrators['stdClass'] ??= (function ($properties, $object) {
+            $readonly = (array) $this;
+
+            foreach ($properties as $name => &$value) {
+                $object->$name = $value;
+
+                if (!($readonly[$name] ?? false)) {
+                    $object->$name = &$value;
+                }
+            }
+        })->bindTo(new \stdClass());
+
+        switch ($class) {
+            case 'stdClass':
+                return $baseHydrator;
+
+            case 'ErrorException':
+                return $baseHydrator->bindTo(new \stdClass(), new class() extends \ErrorException {
+                });
+
+            case 'TypeError':
+                return $baseHydrator->bindTo(new \stdClass(), new class() extends \Error {
+                });
+
+            case 'SplObjectStorage':
+                return static function ($properties, $object) {
+                    foreach ($properties as $name => &$value) {
+                        if ("\0" !== $name) {
+                            $object->$name = $value;
+                            $object->$name = &$value;
+                            continue;
+                        }
+                        for ($i = 0; $i < \count($value); ++$i) {
+                            $object->attach($value[$i], $value[++$i]);
+                        }
+                    }
+                };
+        }
+
+        if (!class_exists($class) && !interface_exists($class, false) && !trait_exists($class, false)) {
+            throw new ClassNotFoundException($class);
+        }
+        $classReflector = new \ReflectionClass($class);
+
+        switch ($class) {
+            case 'ArrayIterator':
+            case 'ArrayObject':
+                $constructor = $classReflector->getConstructor()->invokeArgs(...);
+
+                return static function ($properties, $object) use ($constructor) {
+                    foreach ($properties as $name => &$value) {
+                        if ("\0" === $name) {
+                            $constructor($object, $value);
+                        } else {
+                            $object->$name = $value;
+                            $object->$name = &$value;
+                        }
+                    }
+                };
+        }
+
+        if (!$classReflector->isInternal()) {
+            $readonly = new \stdClass();
+            foreach ($classReflector->getProperties(\ReflectionProperty::IS_READONLY) as $propertyReflector) {
+                if ($class === $propertyReflector->class) {
+                    $readonly->{$propertyReflector->name} = true;
+                }
+            }
+
+            return $baseHydrator->bindTo($readonly, $class);
+        }
+
+        if ($classReflector->name !== $class) {
+            return self::$simpleHydrators[$classReflector->name] ??= self::getSimpleHydrator($classReflector->name);
+        }
+
+        $propertySetters = [];
+        foreach ($classReflector->getProperties() as $propertyReflector) {
+            if (!$propertyReflector->isStatic()) {
+                $propertySetters[$propertyReflector->name] = $propertyReflector->setValue(...);
+            }
+        }
+
+        if (!$propertySetters) {
+            return $baseHydrator;
+        }
+
+        return static function ($properties, $object) use ($propertySetters) {
+            foreach ($properties as $name => &$value) {
+                if ($setValue = $propertySetters[$name] ?? null) {
+                    $setValue($object, $value);
+                } else {
+                    $object->$name = $value;
+                    $object->$name = &$value;
+                }
+            }
+        };
+    }
+
+    public static function getPropertyScopes($class): array
+    {
+        $propertyScopes = [];
+        $r = new \ReflectionClass($class);
+
+        foreach ($r->getProperties() as $property) {
+            $flags = $property->getModifiers();
+
+            if (\ReflectionProperty::IS_STATIC & $flags) {
+                continue;
+            }
+            $name = $property->name;
+
+            if (\ReflectionProperty::IS_PRIVATE & $flags) {
+                $readonlyScope = null;
+                if ($flags & \ReflectionProperty::IS_READONLY) {
+                    $readonlyScope = $class;
+                }
+                $propertyScopes["\0$class\0$name"] = $propertyScopes[$name] = [$class, $name, $readonlyScope, $property];
+
+                continue;
+            }
+            $readonlyScope = null;
+            if ($flags & \ReflectionProperty::IS_READONLY) {
+                $readonlyScope = $property->class;
+            }
+            $propertyScopes[$name] = [$class, $name, $readonlyScope, $property];
+
+            if (\ReflectionProperty::IS_PROTECTED & $flags) {
+                $propertyScopes["\0*\0$name"] = $propertyScopes[$name];
+            }
+        }
+
+        while ($r = $r->getParentClass()) {
+            $class = $r->name;
+
+            foreach ($r->getProperties(\ReflectionProperty::IS_PRIVATE) as $property) {
+                if (!$property->isStatic()) {
+                    $name = $property->name;
+                    $readonlyScope = $property->isReadOnly() ? $class : null;
+                    $propertyScopes["\0$class\0$name"] = [$class, $name, $readonlyScope, $property];
+                    $propertyScopes[$name] ??= [$class, $name, $readonlyScope, $property];
+                }
+            }
+        }
+
+        return $propertyScopes;
+    }
+}
diff --git a/vendor/symfony/var-exporter/Internal/LazyObjectRegistry.php b/vendor/symfony/var-exporter/Internal/LazyObjectRegistry.php
new file mode 100644
index 0000000..f6450ce
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/LazyObjectRegistry.php
@@ -0,0 +1,138 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\VarExporter\Internal;
+
+/**
+ * Stores the state of lazy objects and caches related reflection information.
+ *
+ * As a micro-optimization, this class uses no type declarations.
+ *
+ * @internal
+ */
+class LazyObjectRegistry
+{
+    /**
+     * @var array<class-string, \ReflectionClass>
+     */
+    public static array $classReflectors = [];
+
+    /**
+     * @var array<class-string, array<string, mixed>>
+     */
+    public static array $defaultProperties = [];
+
+    /**
+     * @var array<class-string, list<\Closure>>
+     */
+    public static array $classResetters = [];
+
+    /**
+     * @var array<class-string, array{get: \Closure, set: \Closure, isset: \Closure, unset: \Closure}>
+     */
+    public static array $classAccessors = [];
+
+    /**
+     * @var array<class-string, array{set: bool, isset: bool, unset: bool, clone: bool, serialize: bool, unserialize: bool, sleep: bool, wakeup: bool, destruct: bool, get: int}>
+     */
+    public static array $parentMethods = [];
+
+    public static ?\Closure $noInitializerState = null;
+
+    public static function getClassResetters($class)
+    {
+        $classProperties = [];
+
+        if ((self::$classReflectors[$class] ??= new \ReflectionClass($class))->isInternal()) {
+            $propertyScopes = [];
+        } else {
+            $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
+        }
+
+        foreach ($propertyScopes as $key => [$scope, $name, $readonlyScope]) {
+            $propertyScopes[$k = "\0$scope\0$name"] ?? $propertyScopes[$k = "\0*\0$name"] ?? $k = $name;
+
+            if ($k === $key && "\0$class\0lazyObjectState" !== $k) {
+                $classProperties[$readonlyScope ?? $scope][$name] = $key;
+            }
+        }
+
+        $resetters = [];
+        foreach ($classProperties as $scope => $properties) {
+            $resetters[] = \Closure::bind(static function ($instance, $skippedProperties) use ($properties) {
+                foreach ($properties as $name => $key) {
+                    if (!\array_key_exists($key, $skippedProperties)) {
+                        unset($instance->$name);
+                    }
+                }
+            }, null, $scope);
+        }
+
+        return $resetters;
+    }
+
+    public static function getClassAccessors($class)
+    {
+        return \Closure::bind(static fn () => [
+            'get' => static function &($instance, $name, $readonly) {
+                if (!$readonly) {
+                    return $instance->$name;
+                }
+                $value = $instance->$name;
+
+                return $value;
+            },
+            'set' => static function ($instance, $name, $value) {
+                $instance->$name = $value;
+            },
+            'isset' => static fn ($instance, $name) => isset($instance->$name),
+            'unset' => static function ($instance, $name) {
+                unset($instance->$name);
+            },
+        ], null, \Closure::class === $class ? null : $class)();
+    }
+
+    public static function getParentMethods($class)
+    {
+        $parent = get_parent_class($class);
+        $methods = [];
+
+        foreach (['set', 'isset', 'unset', 'clone', 'serialize', 'unserialize', 'sleep', 'wakeup', 'destruct', 'get'] as $method) {
+            if (!$parent || !method_exists($parent, '__'.$method)) {
+                $methods[$method] = false;
+            } else {
+                $m = new \ReflectionMethod($parent, '__'.$method);
+                $methods[$method] = !$m->isAbstract() && !$m->isPrivate();
+            }
+        }
+
+        $methods['get'] = $methods['get'] ? ($m->returnsReference() ? 2 : 1) : 0;
+
+        return $methods;
+    }
+
+    public static function getScope($propertyScopes, $class, $property, $readonlyScope = null)
+    {
+        if (null === $readonlyScope && !isset($propertyScopes[$k = "\0$class\0$property"]) && !isset($propertyScopes[$k = "\0*\0$property"])) {
+            return null;
+        }
+        $frame = debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT | \DEBUG_BACKTRACE_IGNORE_ARGS, 3)[2];
+
+        if (\ReflectionProperty::class === $scope = $frame['class'] ?? \Closure::class) {
+            $scope = $frame['object']->class;
+        }
+        if (null === $readonlyScope && '*' === $k[1] && ($class === $scope || (is_subclass_of($class, $scope) && !isset($propertyScopes["\0$scope\0$property"])))) {
+            return null;
+        }
+
+        return $scope;
+    }
+}
diff --git a/vendor/symfony/var-exporter/Internal/LazyObjectState.php b/vendor/symfony/var-exporter/Internal/LazyObjectState.php
new file mode 100644
index 0000000..5fc398e
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/LazyObjectState.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\VarExporter\Internal;
+
+use Symfony\Component\VarExporter\Hydrator as PublicHydrator;
+
+/**
+ * Keeps the state of lazy objects.
+ *
+ * As a micro-optimization, this class uses no type declarations.
+ *
+ * @internal
+ */
+class LazyObjectState
+{
+    public const STATUS_UNINITIALIZED_FULL = 1;
+    public const STATUS_UNINITIALIZED_PARTIAL = 2;
+    public const STATUS_INITIALIZED_FULL = 3;
+    public const STATUS_INITIALIZED_PARTIAL = 4;
+
+    /**
+     * @var self::STATUS_*
+     */
+    public int $status = self::STATUS_UNINITIALIZED_FULL;
+
+    public object $realInstance;
+
+    /**
+     * @param array<string, true> $skippedProperties
+     */
+    public function __construct(
+        public readonly \Closure $initializer,
+        public readonly array $skippedProperties = [],
+    ) {
+    }
+
+    public function initialize($instance, $propertyName, $propertyScope)
+    {
+        if (self::STATUS_UNINITIALIZED_FULL !== $this->status) {
+            return $this->status;
+        }
+
+        $this->status = self::STATUS_INITIALIZED_PARTIAL;
+
+        try {
+            if ($defaultProperties = array_diff_key(LazyObjectRegistry::$defaultProperties[$instance::class], $this->skippedProperties)) {
+                PublicHydrator::hydrate($instance, $defaultProperties);
+            }
+
+            ($this->initializer)($instance);
+        } catch (\Throwable $e) {
+            $this->status = self::STATUS_UNINITIALIZED_FULL;
+            $this->reset($instance);
+
+            throw $e;
+        }
+
+        return $this->status = self::STATUS_INITIALIZED_FULL;
+    }
+
+    public function reset($instance): void
+    {
+        $class = $instance::class;
+        $propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
+        $skippedProperties = $this->skippedProperties;
+        $properties = (array) $instance;
+
+        foreach ($propertyScopes as $key => [$scope, $name, $readonlyScope]) {
+            $propertyScopes[$k = "\0$scope\0$name"] ?? $propertyScopes[$k = "\0*\0$name"] ?? $k = $name;
+
+            if ($k === $key && (null !== $readonlyScope || !\array_key_exists($k, $properties))) {
+                $skippedProperties[$k] = true;
+            }
+        }
+
+        foreach (LazyObjectRegistry::$classResetters[$class] as $reset) {
+            $reset($instance, $skippedProperties);
+        }
+
+        foreach ((array) $instance as $name => $value) {
+            if ("\0" !== ($name[0] ?? '') && !\array_key_exists($name, $skippedProperties)) {
+                unset($instance->$name);
+            }
+        }
+
+        $this->status = self::STATUS_UNINITIALIZED_FULL;
+    }
+}
diff --git a/vendor/symfony/var-exporter/Internal/LazyObjectTrait.php b/vendor/symfony/var-exporter/Internal/LazyObjectTrait.php
new file mode 100644
index 0000000..4a6f232
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/LazyObjectTrait.php
@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\VarExporter\Internal;
+
+use Symfony\Component\Serializer\Attribute\Ignore;
+
+if (\PHP_VERSION_ID >= 80300) {
+    /**
+     * @internal
+     */
+    trait LazyObjectTrait
+    {
+        #[Ignore]
+        private readonly LazyObjectState $lazyObjectState;
+    }
+} else {
+    /**
+     * @internal
+     */
+    trait LazyObjectTrait
+    {
+        #[Ignore]
+        private LazyObjectState $lazyObjectState;
+    }
+}
diff --git a/vendor/symfony/var-exporter/Internal/Reference.php b/vendor/symfony/var-exporter/Internal/Reference.php
new file mode 100644
index 0000000..2c7bd7b
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/Reference.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\VarExporter\Internal;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class Reference
+{
+    public int $count = 0;
+
+    public function __construct(
+        public readonly int $id,
+        public readonly mixed $value = null,
+    ) {
+    }
+}
diff --git a/vendor/symfony/var-exporter/Internal/Registry.php b/vendor/symfony/var-exporter/Internal/Registry.php
new file mode 100644
index 0000000..9c41684
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/Registry.php
@@ -0,0 +1,142 @@
+<?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\VarExporter\Internal;
+
+use Symfony\Component\VarExporter\Exception\ClassNotFoundException;
+use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class Registry
+{
+    public static array $reflectors = [];
+    public static array $prototypes = [];
+    public static array $factories = [];
+    public static array $cloneable = [];
+    public static array $instantiableWithoutConstructor = [];
+
+    public function __construct(
+        public readonly array $classes,
+    ) {
+    }
+
+    public static function unserialize($objects, $serializables)
+    {
+        $unserializeCallback = ini_set('unserialize_callback_func', __CLASS__.'::getClassReflector');
+
+        try {
+            foreach ($serializables as $k => $v) {
+                $objects[$k] = unserialize($v);
+            }
+        } finally {
+            ini_set('unserialize_callback_func', $unserializeCallback);
+        }
+
+        return $objects;
+    }
+
+    public static function p($class)
+    {
+        self::getClassReflector($class, true, true);
+
+        return self::$prototypes[$class];
+    }
+
+    public static function f($class)
+    {
+        $reflector = self::$reflectors[$class] ??= self::getClassReflector($class, true, false);
+
+        return self::$factories[$class] = [$reflector, 'newInstanceWithoutConstructor'](...);
+    }
+
+    public static function getClassReflector($class, $instantiableWithoutConstructor = false, $cloneable = null)
+    {
+        if (!($isClass = class_exists($class)) && !interface_exists($class, false) && !trait_exists($class, false)) {
+            throw new ClassNotFoundException($class);
+        }
+        $reflector = new \ReflectionClass($class);
+
+        if ($instantiableWithoutConstructor) {
+            $proto = $reflector->newInstanceWithoutConstructor();
+        } elseif (!$isClass || $reflector->isAbstract()) {
+            throw new NotInstantiableTypeException($class);
+        } elseif ($reflector->name !== $class) {
+            $reflector = self::$reflectors[$name = $reflector->name] ??= self::getClassReflector($name, false, $cloneable);
+            self::$cloneable[$class] = self::$cloneable[$name];
+            self::$instantiableWithoutConstructor[$class] = self::$instantiableWithoutConstructor[$name];
+            self::$prototypes[$class] = self::$prototypes[$name];
+
+            return $reflector;
+        } else {
+            try {
+                $proto = $reflector->newInstanceWithoutConstructor();
+                $instantiableWithoutConstructor = true;
+            } catch (\ReflectionException) {
+                $proto = $reflector->implementsInterface('Serializable') && !method_exists($class, '__unserialize') ? 'C:' : 'O:';
+                if ('C:' === $proto && !$reflector->getMethod('unserialize')->isInternal()) {
+                    $proto = null;
+                } else {
+                    try {
+                        $proto = @unserialize($proto.\strlen($class).':"'.$class.'":0:{}');
+                    } catch (\Exception $e) {
+                        if (__FILE__ !== $e->getFile()) {
+                            throw $e;
+                        }
+                        throw new NotInstantiableTypeException($class, $e);
+                    }
+                    if (false === $proto) {
+                        throw new NotInstantiableTypeException($class);
+                    }
+                }
+            }
+            if (null !== $proto && !$proto instanceof \Throwable && !$proto instanceof \Serializable && !method_exists($class, '__sleep') && !method_exists($class, '__serialize')) {
+                try {
+                    serialize($proto);
+                } catch (\Exception $e) {
+                    throw new NotInstantiableTypeException($class, $e);
+                }
+            }
+        }
+
+        if (null === $cloneable) {
+            if (($proto instanceof \Reflector || $proto instanceof \ReflectionGenerator || $proto instanceof \ReflectionType || $proto instanceof \IteratorIterator || $proto instanceof \RecursiveIteratorIterator) && (!$proto instanceof \Serializable && !method_exists($proto, '__wakeup') && !method_exists($class, '__unserialize'))) {
+                throw new NotInstantiableTypeException($class);
+            }
+
+            $cloneable = $reflector->isCloneable() && !$reflector->hasMethod('__clone');
+        }
+
+        self::$cloneable[$class] = $cloneable;
+        self::$instantiableWithoutConstructor[$class] = $instantiableWithoutConstructor;
+        self::$prototypes[$class] = $proto;
+
+        if ($proto instanceof \Throwable) {
+            static $setTrace;
+
+            if (null === $setTrace) {
+                $setTrace = [
+                    new \ReflectionProperty(\Error::class, 'trace'),
+                    new \ReflectionProperty(\Exception::class, 'trace'),
+                ];
+                $setTrace[0] = $setTrace[0]->setValue(...);
+                $setTrace[1] = $setTrace[1]->setValue(...);
+            }
+
+            $setTrace[$proto instanceof \Exception]($proto, []);
+        }
+
+        return $reflector;
+    }
+}
diff --git a/vendor/symfony/var-exporter/Internal/Values.php b/vendor/symfony/var-exporter/Internal/Values.php
new file mode 100644
index 0000000..4f20a82
--- /dev/null
+++ b/vendor/symfony/var-exporter/Internal/Values.php
@@ -0,0 +1,25 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\VarExporter\Internal;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+class Values
+{
+    public function __construct(
+        public readonly array $values,
+    ) {
+    }
+}