primo commit

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/DeepCopy.php

@@ -0,0 +1,244 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy;
+
+use ArrayObject;
+use DateInterval;
+use DateTimeInterface;
+use DateTimeZone;
+use RegularLabs\Scoped\DeepCopy\Exception\CloneException;
+use RegularLabs\Scoped\DeepCopy\Filter\ChainableFilter;
+use RegularLabs\Scoped\DeepCopy\Filter\Filter;
+use RegularLabs\Scoped\DeepCopy\Matcher\Matcher;
+use RegularLabs\Scoped\DeepCopy\Reflection\ReflectionHelper;
+use RegularLabs\Scoped\DeepCopy\TypeFilter\Date\DateIntervalFilter;
+use RegularLabs\Scoped\DeepCopy\TypeFilter\Spl\ArrayObjectFilter;
+use RegularLabs\Scoped\DeepCopy\TypeFilter\Spl\SplDoublyLinkedListFilter;
+use RegularLabs\Scoped\DeepCopy\TypeFilter\TypeFilter;
+use RegularLabs\Scoped\DeepCopy\TypeMatcher\TypeMatcher;
+use ReflectionObject;
+use ReflectionProperty;
+use SplDoublyLinkedList;
+/**
+ * @final
+ */
+class DeepCopy
+{
+    /**
+     * @var object[] List of objects copied.
+     */
+    private $hashMap = [];
+    /**
+     * Filters to apply.
+     *
+     * @var array Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+     */
+    private $filters = [];
+    /**
+     * Type Filters to apply.
+     *
+     * @var array Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+     */
+    private $typeFilters = [];
+    /**
+     * @var bool
+     */
+    private $skipUncloneable = \false;
+    /**
+     * @var bool
+     */
+    private $useCloneMethod;
+    /**
+     * @param bool $useCloneMethod   If set to true, when an object implements the __clone() function, it will be used
+     *                               instead of the regular deep cloning.
+     */
+    public function __construct($useCloneMethod = \false)
+    {
+        $this->useCloneMethod = $useCloneMethod;
+        $this->addTypeFilter(new ArrayObjectFilter($this), new TypeMatcher(ArrayObject::class));
+        $this->addTypeFilter(new DateIntervalFilter(), new TypeMatcher(DateInterval::class));
+        $this->addTypeFilter(new SplDoublyLinkedListFilter($this), new TypeMatcher(SplDoublyLinkedList::class));
+    }
+    /**
+     * If enabled, will not throw an exception when coming across an uncloneable property.
+     *
+     * @param $skipUncloneable
+     *
+     * @return $this
+     */
+    public function skipUncloneable($skipUncloneable = \true)
+    {
+        $this->skipUncloneable = $skipUncloneable;
+        return $this;
+    }
+    /**
+     * Deep copies the given object.
+     *
+     * @param mixed $object
+     *
+     * @return mixed
+     */
+    public function copy($object)
+    {
+        $this->hashMap = [];
+        return $this->recursiveCopy($object);
+    }
+    public function addFilter(Filter $filter, Matcher $matcher)
+    {
+        $this->filters[] = ['matcher' => $matcher, 'filter' => $filter];
+    }
+    public function prependFilter(Filter $filter, Matcher $matcher)
+    {
+        array_unshift($this->filters, ['matcher' => $matcher, 'filter' => $filter]);
+    }
+    public function addTypeFilter(TypeFilter $filter, TypeMatcher $matcher)
+    {
+        $this->typeFilters[] = ['matcher' => $matcher, 'filter' => $filter];
+    }
+    private function recursiveCopy($var)
+    {
+        // Matches Type Filter
+        if ($filter = $this->getFirstMatchedTypeFilter($this->typeFilters, $var)) {
+            return $filter->apply($var);
+        }
+        // Resource
+        if (is_resource($var)) {
+            return $var;
+        }
+        // Array
+        if (is_array($var)) {
+            return $this->copyArray($var);
+        }
+        // Scalar
+        if (!is_object($var)) {
+            return $var;
+        }
+        // Enum
+        if (\PHP_VERSION_ID >= 80100 && enum_exists(get_class($var))) {
+            return $var;
+        }
+        // Object
+        return $this->copyObject($var);
+    }
+    /**
+     * Copy an array
+     * @param array $array
+     * @return array
+     */
+    private function copyArray(array $array)
+    {
+        foreach ($array as $key => $value) {
+            $array[$key] = $this->recursiveCopy($value);
+        }
+        return $array;
+    }
+    /**
+     * Copies an object.
+     *
+     * @param object $object
+     *
+     * @throws CloneException
+     *
+     * @return object
+     */
+    private function copyObject($object)
+    {
+        $objectHash = spl_object_hash($object);
+        if (isset($this->hashMap[$objectHash])) {
+            return $this->hashMap[$objectHash];
+        }
+        $reflectedObject = new ReflectionObject($object);
+        $isCloneable = $reflectedObject->isCloneable();
+        if (\false === $isCloneable) {
+            if ($this->skipUncloneable) {
+                $this->hashMap[$objectHash] = $object;
+                return $object;
+            }
+            throw new CloneException(sprintf('The class "%s" is not cloneable.', $reflectedObject->getName()));
+        }
+        $newObject = clone $object;
+        $this->hashMap[$objectHash] = $newObject;
+        if ($this->useCloneMethod && $reflectedObject->hasMethod('__clone')) {
+            return $newObject;
+        }
+        if ($newObject instanceof DateTimeInterface || $newObject instanceof DateTimeZone) {
+            return $newObject;
+        }
+        foreach (ReflectionHelper::getProperties($reflectedObject) as $property) {
+            $this->copyObjectProperty($newObject, $property);
+        }
+        return $newObject;
+    }
+    private function copyObjectProperty($object, ReflectionProperty $property)
+    {
+        // Ignore static properties
+        if ($property->isStatic()) {
+            return;
+        }
+        // Ignore readonly properties
+        if (method_exists($property, 'isReadOnly') && $property->isReadOnly()) {
+            return;
+        }
+        // Apply the filters
+        foreach ($this->filters as $item) {
+            /** @var Matcher $matcher */
+            $matcher = $item['matcher'];
+            /** @var Filter $filter */
+            $filter = $item['filter'];
+            if ($matcher->matches($object, $property->getName())) {
+                $filter->apply($object, $property->getName(), function ($object) {
+                    return $this->recursiveCopy($object);
+                });
+                if ($filter instanceof ChainableFilter) {
+                    continue;
+                }
+                // If a filter matches, we stop processing this property
+                return;
+            }
+        }
+        $property->setAccessible(\true);
+        // Ignore uninitialized properties (for PHP >7.4)
+        if (method_exists($property, 'isInitialized') && !$property->isInitialized($object)) {
+            return;
+        }
+        $propertyValue = $property->getValue($object);
+        // Copy the property
+        $property->setValue($object, $this->recursiveCopy($propertyValue));
+    }
+    /**
+     * Returns first filter that matches variable, `null` if no such filter found.
+     *
+     * @param array $filterRecords Associative array with 2 members: 'filter' with value of type {@see TypeFilter} and
+     *                             'matcher' with value of type {@see TypeMatcher}
+     * @param mixed $var
+     *
+     * @return TypeFilter|null
+     */
+    private function getFirstMatchedTypeFilter(array $filterRecords, $var)
+    {
+        $matched = $this->first($filterRecords, function (array $record) use ($var) {
+            /* @var TypeMatcher $matcher */
+            $matcher = $record['matcher'];
+            return $matcher->matches($var);
+        });
+        return isset($matched) ? $matched['filter'] : null;
+    }
+    /**
+     * Returns first element that matches predicate, `null` if no such element found.
+     *
+     * @param array    $elements Array of ['filter' => Filter, 'matcher' => Matcher] pairs.
+     * @param callable $predicate Predicate arguments are: element.
+     *
+     * @return array|null Associative array with 2 members: 'filter' with value of type {@see TypeFilter} and 'matcher'
+     *                    with value of type {@see TypeMatcher} or `null`.
+     */
+    private function first(array $elements, callable $predicate)
+    {
+        foreach ($elements as $element) {
+            if (call_user_func($predicate, $element)) {
+                return $element;
+            }
+        }
+        return null;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Exception/CloneException.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Exception;
+
+use UnexpectedValueException;
+class CloneException extends UnexpectedValueException
+{
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Exception/PropertyException.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Exception;
+
+use ReflectionException;
+class PropertyException extends ReflectionException
+{
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/ChainableFilter.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter;
+
+/**
+ * Defines a decorator filter that will not stop the chain of filters.
+ */
+class ChainableFilter implements Filter
+{
+    /**
+     * @var Filter
+     */
+    protected $filter;
+    public function __construct(Filter $filter)
+    {
+        $this->filter = $filter;
+    }
+    public function apply($object, $property, $objectCopier)
+    {
+        $this->filter->apply($object, $property, $objectCopier);
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineCollectionFilter.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter\Doctrine;
+
+use RegularLabs\Scoped\DeepCopy\Filter\Filter;
+use RegularLabs\Scoped\DeepCopy\Reflection\ReflectionHelper;
+/**
+ * @final
+ */
+class DoctrineCollectionFilter implements Filter
+{
+    /**
+     * Copies the object property doctrine collection.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        $reflectionProperty->setAccessible(\true);
+        $oldCollection = $reflectionProperty->getValue($object);
+        $newCollection = $oldCollection->map(function ($item) use ($objectCopier) {
+            return $objectCopier($item);
+        });
+        $reflectionProperty->setValue($object, $newCollection);
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineEmptyCollectionFilter.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter\Doctrine;
+
+use RegularLabs\Scoped\DeepCopy\Filter\Filter;
+use RegularLabs\Scoped\DeepCopy\Reflection\ReflectionHelper;
+use RegularLabs\Scoped\Doctrine\Common\Collections\ArrayCollection;
+/**
+ * @final
+ */
+class DoctrineEmptyCollectionFilter implements Filter
+{
+    /**
+     * Sets the object property to an empty doctrine collection.
+     *
+     * @param object   $object
+     * @param string   $property
+     * @param callable $objectCopier
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        $reflectionProperty->setAccessible(\true);
+        $reflectionProperty->setValue($object, new ArrayCollection());
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Doctrine/DoctrineProxyFilter.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter\Doctrine;
+
+use RegularLabs\Scoped\DeepCopy\Filter\Filter;
+/**
+ * @final
+ */
+class DoctrineProxyFilter implements Filter
+{
+    /**
+     * Triggers the magic method __load() on a Doctrine Proxy class to load the
+     * actual entity from the database.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $object->__load();
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/Filter.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter;
+
+/**
+ * Filter to apply to a property while copying an object
+ */
+interface Filter
+{
+    /**
+     * Applies the filter to the object.
+     *
+     * @param object   $object
+     * @param string   $property
+     * @param callable $objectCopier
+     */
+    public function apply($object, $property, $objectCopier);
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/KeepFilter.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter;
+
+class KeepFilter implements Filter
+{
+    /**
+     * Keeps the value of the object property.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        // Nothing to do
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/ReplaceFilter.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter;
+
+use RegularLabs\Scoped\DeepCopy\Reflection\ReflectionHelper;
+/**
+ * @final
+ */
+class ReplaceFilter implements Filter
+{
+    /**
+     * @var callable
+     */
+    protected $callback;
+    /**
+     * @param callable $callable Will be called to get the new value for each property to replace
+     */
+    public function __construct(callable $callable)
+    {
+        $this->callback = $callable;
+    }
+    /**
+     * Replaces the object property by the result of the callback called with the object property.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        $reflectionProperty->setAccessible(\true);
+        $value = call_user_func($this->callback, $reflectionProperty->getValue($object));
+        $reflectionProperty->setValue($object, $value);
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Filter/SetNullFilter.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Filter;
+
+use RegularLabs\Scoped\DeepCopy\Reflection\ReflectionHelper;
+/**
+ * @final
+ */
+class SetNullFilter implements Filter
+{
+    /**
+     * Sets the object property to null.
+     *
+     * {@inheritdoc}
+     */
+    public function apply($object, $property, $objectCopier)
+    {
+        $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        $reflectionProperty->setAccessible(\true);
+        $reflectionProperty->setValue($object, null);
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/Doctrine/DoctrineProxyMatcher.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Matcher\Doctrine;
+
+use RegularLabs\Scoped\DeepCopy\Matcher\Matcher;
+use RegularLabs\Scoped\Doctrine\Persistence\Proxy;
+/**
+ * @final
+ */
+class DoctrineProxyMatcher implements Matcher
+{
+    /**
+     * Matches a Doctrine Proxy class.
+     *
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        return $object instanceof Proxy;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/Matcher.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Matcher;
+
+interface Matcher
+{
+    /**
+     * @param object $object
+     * @param string $property
+     *
+     * @return boolean
+     */
+    public function matches($object, $property);
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyMatcher.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Matcher;
+
+/**
+ * @final
+ */
+class PropertyMatcher implements Matcher
+{
+    /**
+     * @var string
+     */
+    private $class;
+    /**
+     * @var string
+     */
+    private $property;
+    /**
+     * @param string $class    Class name
+     * @param string $property Property name
+     */
+    public function __construct($class, $property)
+    {
+        $this->class = $class;
+        $this->property = $property;
+    }
+    /**
+     * Matches a specific property of a specific class.
+     *
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        return $object instanceof $this->class && $property == $this->property;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyNameMatcher.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Matcher;
+
+/**
+ * @final
+ */
+class PropertyNameMatcher implements Matcher
+{
+    /**
+     * @var string
+     */
+    private $property;
+    /**
+     * @param string $property Property name
+     */
+    public function __construct($property)
+    {
+        $this->property = $property;
+    }
+    /**
+     * Matches a property by its name.
+     *
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        return $property == $this->property;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Matcher/PropertyTypeMatcher.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Matcher;
+
+use RegularLabs\Scoped\DeepCopy\Reflection\ReflectionHelper;
+use ReflectionException;
+/**
+ * Matches a property by its type.
+ *
+ * It is recommended to use {@see DeepCopy\TypeFilter\TypeFilter} instead, as it applies on all occurrences
+ * of given type in copied context (eg. array elements), not just on object properties.
+ *
+ * @final
+ */
+class PropertyTypeMatcher implements Matcher
+{
+    /**
+     * @var string
+     */
+    private $propertyType;
+    /**
+     * @param string $propertyType Property type
+     */
+    public function __construct($propertyType)
+    {
+        $this->propertyType = $propertyType;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function matches($object, $property)
+    {
+        try {
+            $reflectionProperty = ReflectionHelper::getProperty($object, $property);
+        } catch (ReflectionException $exception) {
+            return \false;
+        }
+        $reflectionProperty->setAccessible(\true);
+        // Uninitialized properties (for PHP >7.4)
+        if (method_exists($reflectionProperty, 'isInitialized') && !$reflectionProperty->isInitialized($object)) {
+            // null instanceof $this->propertyType
+            return \false;
+        }
+        return $reflectionProperty->getValue($object) instanceof $this->propertyType;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/Reflection/ReflectionHelper.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\Reflection;
+
+use RegularLabs\Scoped\DeepCopy\Exception\PropertyException;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionObject;
+use ReflectionProperty;
+class ReflectionHelper
+{
+    /**
+     * Retrieves all properties (including private ones), from object and all its ancestors.
+     *
+     * Standard \ReflectionClass->getProperties() does not return private properties from ancestor classes.
+     *
+     * @author muratyaman@gmail.com
+     * @see http://php.net/manual/en/reflectionclass.getproperties.php
+     *
+     * @param ReflectionClass $ref
+     *
+     * @return ReflectionProperty[]
+     */
+    public static function getProperties(ReflectionClass $ref)
+    {
+        $props = $ref->getProperties();
+        $propsArr = array();
+        foreach ($props as $prop) {
+            $propertyName = $prop->getName();
+            $propsArr[$propertyName] = $prop;
+        }
+        if ($parentClass = $ref->getParentClass()) {
+            $parentPropsArr = self::getProperties($parentClass);
+            foreach ($propsArr as $key => $property) {
+                $parentPropsArr[$key] = $property;
+            }
+            return $parentPropsArr;
+        }
+        return $propsArr;
+    }
+    /**
+     * Retrieves property by name from object and all its ancestors.
+     *
+     * @param object|string $object
+     * @param string $name
+     *
+     * @throws PropertyException
+     * @throws ReflectionException
+     *
+     * @return ReflectionProperty
+     */
+    public static function getProperty($object, $name)
+    {
+        $reflection = is_object($object) ? new ReflectionObject($object) : new ReflectionClass($object);
+        if ($reflection->hasProperty($name)) {
+            return $reflection->getProperty($name);
+        }
+        if ($parentClass = $reflection->getParentClass()) {
+            return self::getProperty($parentClass->getName(), $name);
+        }
+        throw new PropertyException(sprintf('The class "%s" doesn\'t have a property with the given name: "%s".', is_object($object) ? get_class($object) : $object, $name));
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Date/DateIntervalFilter.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeFilter\Date;
+
+use DateInterval;
+use RegularLabs\Scoped\DeepCopy\TypeFilter\TypeFilter;
+/**
+ * @final
+ *
+ * @deprecated Will be removed in 2.0. This filter will no longer be necessary in PHP 7.1+.
+ */
+class DateIntervalFilter implements TypeFilter
+{
+    /**
+     * {@inheritdoc}
+     *
+     * @param DateInterval $element
+     *
+     * @see http://news.php.net/php.bugs/205076
+     */
+    public function apply($element)
+    {
+        $copy = new DateInterval('P0D');
+        foreach ($element as $propertyName => $propertyValue) {
+            $copy->{$propertyName} = $propertyValue;
+        }
+        return $copy;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ReplaceFilter.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeFilter;
+
+/**
+ * @final
+ */
+class ReplaceFilter implements TypeFilter
+{
+    /**
+     * @var callable
+     */
+    protected $callback;
+    /**
+     * @param callable $callable Will be called to get the new value for each element to replace
+     */
+    public function __construct(callable $callable)
+    {
+        $this->callback = $callable;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function apply($element)
+    {
+        return call_user_func($this->callback, $element);
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/ShallowCopyFilter.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeFilter;
+
+/**
+ * @final
+ */
+class ShallowCopyFilter implements TypeFilter
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function apply($element)
+    {
+        return clone $element;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Spl/ArrayObjectFilter.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeFilter\Spl;
+
+use RegularLabs\Scoped\DeepCopy\DeepCopy;
+use RegularLabs\Scoped\DeepCopy\TypeFilter\TypeFilter;
+/**
+ * In PHP 7.4 the storage of an ArrayObject isn't returned as
+ * ReflectionProperty. So we deep copy its array copy.
+ */
+final class ArrayObjectFilter implements TypeFilter
+{
+    /**
+     * @var DeepCopy
+     */
+    private $copier;
+    public function __construct(DeepCopy $copier)
+    {
+        $this->copier = $copier;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function apply($arrayObject)
+    {
+        $clone = clone $arrayObject;
+        foreach ($arrayObject->getArrayCopy() as $k => $v) {
+            $clone->offsetSet($k, $this->copier->copy($v));
+        }
+        return $clone;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Spl/SplDoublyLinkedList.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeFilter\Spl;
+
+/**
+ * @deprecated Use {@see SplDoublyLinkedListFilter} instead.
+ */
+class SplDoublyLinkedList extends SplDoublyLinkedListFilter
+{
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/Spl/SplDoublyLinkedListFilter.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeFilter\Spl;
+
+use Closure;
+use RegularLabs\Scoped\DeepCopy\DeepCopy;
+use RegularLabs\Scoped\DeepCopy\TypeFilter\TypeFilter;
+use SplDoublyLinkedList;
+/**
+ * @final
+ */
+class SplDoublyLinkedListFilter implements TypeFilter
+{
+    private $copier;
+    public function __construct(DeepCopy $copier)
+    {
+        $this->copier = $copier;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function apply($element)
+    {
+        $newElement = clone $element;
+        $copy = $this->createCopyClosure();
+        return $copy($newElement);
+    }
+    private function createCopyClosure()
+    {
+        $copier = $this->copier;
+        $copy = function (SplDoublyLinkedList $list) use ($copier) {
+            // Replace each element in the list with a deep copy of itself
+            for ($i = 1; $i <= $list->count(); $i++) {
+                $copy = $copier->recursiveCopy($list->shift());
+                $list->push($copy);
+            }
+            return $list;
+        };
+        return Closure::bind($copy, null, DeepCopy::class);
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeFilter/TypeFilter.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeFilter;
+
+interface TypeFilter
+{
+    /**
+     * Applies the filter to the object.
+     *
+     * @param mixed $element
+     */
+    public function apply($element);
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/TypeMatcher/TypeMatcher.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy\TypeMatcher;
+
+class TypeMatcher
+{
+    /**
+     * @var string
+     */
+    private $type;
+    /**
+     * @param string $type
+     */
+    public function __construct($type)
+    {
+        $this->type = $type;
+    }
+    /**
+     * @param mixed $element
+     *
+     * @return boolean
+     */
+    public function matches($element)
+    {
+        return is_object($element) ? is_a($element, $this->type) : gettype($element) === $this->type;
+    }
+}

libraries/regularlabs/vendor/myclabs/deep-copy/src/DeepCopy/deep_copy.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace RegularLabs\Scoped\DeepCopy;
+
+use function function_exists;
+if (\false === function_exists('RegularLabs\Scoped\DeepCopy\deep_copy')) {
+    /**
+     * Deep copies the given value.
+     *
+     * @param mixed $value
+     * @param bool  $useCloneMethod
+     *
+     * @return mixed
+     */
+    function deep_copy($value, $useCloneMethod = \false)
+    {
+        return (new DeepCopy($useCloneMethod))->copy($value);
+    }
+}