<form method="POST">
    <h3>Editing: Native.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Laravel\SerializableClosure\Serializers;

use Closure;
use DateTimeInterface;
use Laravel\SerializableClosure\Contracts\Serializable;
use Laravel\SerializableClosure\SerializableClosure;
use Laravel\SerializableClosure\Support\ClosureScope;
use Laravel\SerializableClosure\Support\ClosureStream;
use Laravel\SerializableClosure\Support\ReflectionClosure;
use Laravel\SerializableClosure\Support\SelfReference;
use Laravel\SerializableClosure\UnsignedSerializableClosure;
use ReflectionObject;
use UnitEnum;

class Native implements Serializable
{
    /**
     * Transform the use variables before serialization.
     *
     * @var \Closure|null
     */
    public static $transformUseVariables;

    /**
     * Resolve the use variables after unserialization.
     *
     * @var \Closure|null
     */
    public static $resolveUseVariables;

    /**
     * The closure to be serialized/unserialized.
     *
     * @var \Closure
     */
    protected $closure;

    /**
     * The closure's reflection.
     *
     * @var \Laravel\SerializableClosure\Support\ReflectionClosure|null
     */
    protected $reflector;

    /**
     * The closure's code.
     *
     * @var array|null
     */
    protected $code;

    /**
     * The closure's reference.
     *
     * @var string
     */
    protected $reference;

    /**
     * The closure's scope.
     *
     * @var \Laravel\SerializableClosure\Support\ClosureScope|null
     */
    protected $scope;

    /**
     * The &quot;key&quot; that marks an array as recursive.
     */
    const ARRAY_RECURSIVE_KEY = 'LARAVEL_SERIALIZABLE_RECURSIVE_KEY';

    /**
     * Creates a new serializable closure instance.
     *
     * @param  \Closure  $closure
     * @return void
     */
    public function __construct(Closure $closure)
    {
        $this-&gt;closure = $closure;
    }

    /**
     * Resolve the closure with the given arguments.
     *
     * @return mixed
     */
    public function __invoke()
    {
        return call_user_func_array($this-&gt;closure, func_get_args());
    }

    /**
     * Gets the closure.
     *
     * @return \Closure
     */
    public function getClosure()
    {
        return $this-&gt;closure;
    }

    /**
     * Get the serializable representation of the closure.
     *
     * @return array
     */
    public function __serialize()
    {
        if ($this-&gt;scope === null) {
            $this-&gt;scope = new ClosureScope();
            $this-&gt;scope-&gt;toSerialize++;
        }

        $this-&gt;scope-&gt;serializations++;

        $scope = $object = null;
        $reflector = $this-&gt;getReflector();

        if ($reflector-&gt;isBindingRequired()) {
            $object = $reflector-&gt;getClosureThis();

            static::wrapClosures($object, $this-&gt;scope);
        }

        if ($scope = $reflector-&gt;getClosureScopeClass()) {
            $scope = $scope-&gt;name;
        }

        $this-&gt;reference = spl_object_hash($this-&gt;closure);

        $this-&gt;scope[$this-&gt;closure] = $this;

        $use = $reflector-&gt;getUseVariables();

        if (static::$transformUseVariables) {
            $use = call_user_func(static::$transformUseVariables, $reflector-&gt;getUseVariables());
        }

        $code = $reflector-&gt;getCode();

        $this-&gt;mapByReference($use);

        $data = [
            'use' =&gt; $use,
            'function' =&gt; $code,
            'scope' =&gt; $scope,
            'this' =&gt; $object,
            'self' =&gt; $this-&gt;reference,
        ];

        if (! --$this-&gt;scope-&gt;serializations &amp;&amp; ! --$this-&gt;scope-&gt;toSerialize) {
            $this-&gt;scope = null;
        }

        return $data;
    }

    /**
     * Restore the closure after serialization.
     *
     * @param  array  $data
     * @return void
     */
    public function __unserialize($data)
    {
        ClosureStream::register();

        $this-&gt;code = $data;
        unset($data);

        $this-&gt;code['objects'] = [];

        if ($this-&gt;code['use']) {
            $this-&gt;scope = new ClosureScope();

            if (static::$resolveUseVariables) {
                $this-&gt;code['use'] = call_user_func(static::$resolveUseVariables, $this-&gt;code['use']);
            }

            $this-&gt;mapPointers($this-&gt;code['use']);

            extract($this-&gt;code['use'], EXTR_OVERWRITE | EXTR_REFS);

            $this-&gt;scope = null;
        }

        $this-&gt;closure = include ClosureStream::STREAM_PROTO.'://'.$this-&gt;code['function'];

        if ($this-&gt;code['this'] === $this) {
            $this-&gt;code['this'] = null;
        }

        $this-&gt;closure = $this-&gt;closure-&gt;bindTo($this-&gt;code['this'], $this-&gt;code['scope']);

        if (! empty($this-&gt;code['objects'])) {
            foreach ($this-&gt;code['objects'] as $item) {
                $item['property']-&gt;setValue($item['instance'], $item['object']-&gt;getClosure());
            }
        }

        $this-&gt;code = $this-&gt;code['function'];
    }

    /**
     * Ensures the given closures are serializable.
     *
     * @param  mixed  $data
     * @param  \Laravel\SerializableClosure\Support\ClosureScope  $storage
     * @return void
     */
    public static function wrapClosures(&amp;$data, $storage)
    {
        if ($data instanceof Closure) {
            $data = new static($data);
        } elseif (is_array($data)) {
            if (isset($data[self::ARRAY_RECURSIVE_KEY])) {
                return;
            }

            $data[self::ARRAY_RECURSIVE_KEY] = true;

            foreach ($data as $key =&gt; &amp;$value) {
                if ($key === self::ARRAY_RECURSIVE_KEY) {
                    continue;
                }
                static::wrapClosures($value, $storage);
            }

            unset($value);
            unset($data[self::ARRAY_RECURSIVE_KEY]);
        } elseif ($data instanceof \stdClass) {
            if (isset($storage[$data])) {
                $data = $storage[$data];

                return;
            }

            $data = $storage[$data] = clone $data;

            foreach ($data as &amp;$value) {
                static::wrapClosures($value, $storage);
            }

            unset($value);
        } elseif (is_object($data) &amp;&amp; ! $data instanceof static &amp;&amp; ! $data instanceof UnitEnum) {
            if (isset($storage[$data])) {
                $data = $storage[$data];

                return;
            }

            $instance = $data;
            $reflection = new ReflectionObject($instance);

            if (! $reflection-&gt;isUserDefined()) {
                $storage[$instance] = $data;

                return;
            }

            $storage[$instance] = $data = $reflection-&gt;newInstanceWithoutConstructor();

            do {
                if (! $reflection-&gt;isUserDefined()) {
                    break;
                }

                foreach ($reflection-&gt;getProperties() as $property) {
                    if ($property-&gt;isStatic() || ! $property-&gt;getDeclaringClass()-&gt;isUserDefined()) {
                        continue;
                    }

                    $property-&gt;setAccessible(true);

                    if (PHP_VERSION &gt;= 7.4 &amp;&amp; ! $property-&gt;isInitialized($instance)) {
                        continue;
                    }

                    $value = $property-&gt;getValue($instance);

                    if (is_array($value) || is_object($value)) {
                        static::wrapClosures($value, $storage);
                    }

                    $property-&gt;setValue($data, $value);
                }
            } while ($reflection = $reflection-&gt;getParentClass());
        }
    }

    /**
     * Gets the closure's reflector.
     *
     * @return \Laravel\SerializableClosure\Support\ReflectionClosure
     */
    public function getReflector()
    {
        if ($this-&gt;reflector === null) {
            $this-&gt;code = null;
            $this-&gt;reflector = new ReflectionClosure($this-&gt;closure);
        }

        return $this-&gt;reflector;
    }

    /**
     * Internal method used to map closure pointers.
     *
     * @param  mixed  $data
     * @return void
     */
    protected function mapPointers(&amp;$data)
    {
        $scope = $this-&gt;scope;

        if ($data instanceof static) {
            $data = &amp;$data-&gt;closure;
        } elseif (is_array($data)) {
            if (isset($data[self::ARRAY_RECURSIVE_KEY])) {
                return;
            }

            $data[self::ARRAY_RECURSIVE_KEY] = true;

            foreach ($data as $key =&gt; &amp;$value) {
                if ($key === self::ARRAY_RECURSIVE_KEY) {
                    continue;
                } elseif ($value instanceof static) {
                    $data[$key] = &amp;$value-&gt;closure;
                } elseif ($value instanceof SelfReference &amp;&amp; $value-&gt;hash === $this-&gt;code['self']) {
                    $data[$key] = &amp;$this-&gt;closure;
                } else {
                    $this-&gt;mapPointers($value);
                }
            }

            unset($value);
            unset($data[self::ARRAY_RECURSIVE_KEY]);
        } elseif ($data instanceof \stdClass) {
            if (isset($scope[$data])) {
                return;
            }

            $scope[$data] = true;

            foreach ($data as $key =&gt; &amp;$value) {
                if ($value instanceof SelfReference &amp;&amp; $value-&gt;hash === $this-&gt;code['self']) {
                    $data-&gt;{$key} = &amp;$this-&gt;closure;
                } elseif (is_array($value) || is_object($value)) {
                    $this-&gt;mapPointers($value);
                }
            }

            unset($value);
        } elseif (is_object($data) &amp;&amp; ! ($data instanceof Closure)) {
            if (isset($scope[$data])) {
                return;
            }

            $scope[$data] = true;
            $reflection = new ReflectionObject($data);

            do {
                if (! $reflection-&gt;isUserDefined()) {
                    break;
                }

                foreach ($reflection-&gt;getProperties() as $property) {
                    if ($property-&gt;isStatic() || ! $property-&gt;getDeclaringClass()-&gt;isUserDefined()) {
                        continue;
                    }

                    $property-&gt;setAccessible(true);

                    if (PHP_VERSION &gt;= 7.4 &amp;&amp; ! $property-&gt;isInitialized($data)) {
                        continue;
                    }

                    $item = $property-&gt;getValue($data);

                    if ($item instanceof SerializableClosure || $item instanceof UnsignedSerializableClosure || ($item instanceof SelfReference &amp;&amp; $item-&gt;hash === $this-&gt;code['self'])) {
                        $this-&gt;code['objects'][] = [
                            'instance' =&gt; $data,
                            'property' =&gt; $property,
                            'object' =&gt; $item instanceof SelfReference ? $this : $item,
                        ];
                    } elseif (is_array($item) || is_object($item)) {
                        $this-&gt;mapPointers($item);
                        $property-&gt;setValue($data, $item);
                    }
                }
            } while ($reflection = $reflection-&gt;getParentClass());
        }
    }

    /**
     * Internal method used to map closures by reference.
     *
     * @param  mixed  $data
     * @return void
     */
    protected function mapByReference(&amp;$data)
    {
        if ($data instanceof Closure) {
            if ($data === $this-&gt;closure) {
                $data = new SelfReference($this-&gt;reference);

                return;
            }

            if (isset($this-&gt;scope[$data])) {
                $data = $this-&gt;scope[$data];

                return;
            }

            $instance = new static($data);

            $instance-&gt;scope = $this-&gt;scope;

            $data = $this-&gt;scope[$data] = $instance;
        } elseif (is_array($data)) {
            if (isset($data[self::ARRAY_RECURSIVE_KEY])) {
                return;
            }

            $data[self::ARRAY_RECURSIVE_KEY] = true;

            foreach ($data as $key =&gt; &amp;$value) {
                if ($key === self::ARRAY_RECURSIVE_KEY) {
                    continue;
                }

                $this-&gt;mapByReference($value);
            }

            unset($value);
            unset($data[self::ARRAY_RECURSIVE_KEY]);
        } elseif ($data instanceof \stdClass) {
            if (isset($this-&gt;scope[$data])) {
                $data = $this-&gt;scope[$data];

                return;
            }

            $instance = $data;
            $this-&gt;scope[$instance] = $data = clone $data;

            foreach ($data as &amp;$value) {
                $this-&gt;mapByReference($value);
            }

            unset($value);
        } elseif (is_object($data) &amp;&amp; ! $data instanceof SerializableClosure &amp;&amp; ! $data instanceof UnsignedSerializableClosure) {
            if (isset($this-&gt;scope[$data])) {
                $data = $this-&gt;scope[$data];

                return;
            }

            $instance = $data;

            if ($data instanceof DateTimeInterface) {
                $this-&gt;scope[$instance] = $data;

                return;
            }

            if ($data instanceof UnitEnum) {
                $this-&gt;scope[$instance] = $data;

                return;
            }

            $reflection = new ReflectionObject($data);

            if (! $reflection-&gt;isUserDefined()) {
                $this-&gt;scope[$instance] = $data;

                return;
            }

            $this-&gt;scope[$instance] = $data = $reflection-&gt;newInstanceWithoutConstructor();

            do {
                if (! $reflection-&gt;isUserDefined()) {
                    break;
                }

                foreach ($reflection-&gt;getProperties() as $property) {
                    if ($property-&gt;isStatic() || ! $property-&gt;getDeclaringClass()-&gt;isUserDefined()) {
                        continue;
                    }

                    $property-&gt;setAccessible(true);

                    if (PHP_VERSION &gt;= 7.4 &amp;&amp; ! $property-&gt;isInitialized($instance)) {
                        continue;
                    }

                    $value = $property-&gt;getValue($instance);

                    if (is_array($value) || is_object($value)) {
                        $this-&gt;mapByReference($value);
                    }

                    $property-&gt;setValue($data, $value);
                }
            } while ($reflection = $reflection-&gt;getParentClass());
        }
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>