<form method="POST">
    <h3>Editing: Exporter.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);
/*
 * This file is part of sebastian/exporter.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\Exporter;

use function bin2hex;
use function count;
use function function_exists;
use function get_class;
use function get_resource_type;
use function gettype;
use function implode;
use function ini_get;
use function ini_set;
use function is_array;
use function is_float;
use function is_object;
use function is_resource;
use function is_string;
use function mb_strlen;
use function mb_substr;
use function preg_match;
use function spl_object_hash;
use function sprintf;
use function str_repeat;
use function str_replace;
use function strlen;
use function substr;
use function var_export;
use SebastianBergmann\RecursionContext\Context;
use SplObjectStorage;

/**
 * A nifty utility for visualizing PHP variables.
 *
 * &lt;code&gt;
 * &lt;?php
 * use SebastianBergmann\Exporter\Exporter;
 *
 * $exporter = new Exporter;
 * print $exporter-&gt;export(new Exception);
 * &lt;/code&gt;
 */
class Exporter
{
    /**
     * Exports a value as a string.
     *
     * The output of this method is similar to the output of print_r(), but
     * improved in various aspects:
     *
     *  - NULL is rendered as &quot;null&quot; (instead of &quot;&quot;)
     *  - TRUE is rendered as &quot;true&quot; (instead of &quot;1&quot;)
     *  - FALSE is rendered as &quot;false&quot; (instead of &quot;&quot;)
     *  - Strings are always quoted with single quotes
     *  - Carriage returns and newlines are normalized to \n
     *  - Recursion and repeated rendering is treated properly
     *
     * @param int $indentation The indentation level of the 2nd+ line
     *
     * @return string
     */
    public function export($value, $indentation = 0)
    {
        return $this-&gt;recursiveExport($value, $indentation);
    }

    /**
     * @param array&lt;mixed&gt; $data
     * @param Context      $context
     *
     * @return string
     */
    public function shortenedRecursiveExport(&amp;$data, ?Context $context = null)
    {
        $result   = [];
        $exporter = new self();

        if (!$context) {
            $context = new Context;
        }

        $array = $data;
        $context-&gt;add($data);

        foreach ($array as $key =&gt; $value) {
            if (is_array($value)) {
                if ($context-&gt;contains($data[$key]) !== false) {
                    $result[] = '*RECURSION*';
                } else {
                    $result[] = sprintf(
                        'array(%s)',
                        $this-&gt;shortenedRecursiveExport($data[$key], $context)
                    );
                }
            } else {
                $result[] = $exporter-&gt;shortenedExport($value);
            }
        }

        return implode(', ', $result);
    }

    /**
     * Exports a value into a single-line string.
     *
     * The output of this method is similar to the output of
     * SebastianBergmann\Exporter\Exporter::export().
     *
     * Newlines are replaced by the visible string '\n'.
     * Contents of arrays and objects (if any) are replaced by '...'.
     *
     * @return string
     *
     * @see    SebastianBergmann\Exporter\Exporter::export
     */
    public function shortenedExport($value)
    {
        if (is_string($value)) {
            $string = str_replace(&quot;\n&quot;, '', $this-&gt;export($value));

            if (function_exists('mb_strlen')) {
                if (mb_strlen($string) &gt; 40) {
                    $string = mb_substr($string, 0, 30) . '...' . mb_substr($string, -7);
                }
            } else {
                if (strlen($string) &gt; 40) {
                    $string = substr($string, 0, 30) . '...' . substr($string, -7);
                }
            }

            return $string;
        }

        if (is_object($value)) {
            return sprintf(
                '%s Object (%s)',
                get_class($value),
                count($this-&gt;toArray($value)) &gt; 0 ? '...' : ''
            );
        }

        if (is_array($value)) {
            return sprintf(
                'Array (%s)',
                count($value) &gt; 0 ? '...' : ''
            );
        }

        return $this-&gt;export($value);
    }

    /**
     * Converts an object to an array containing all of its private, protected
     * and public properties.
     *
     * @return array
     */
    public function toArray($value)
    {
        if (!is_object($value)) {
            return (array) $value;
        }

        $array = [];

        foreach ((array) $value as $key =&gt; $val) {
            // Exception traces commonly reference hundreds to thousands of
            // objects currently loaded in memory. Including them in the result
            // has a severe negative performance impact.
            if (&quot;\0Error\0trace&quot; === $key || &quot;\0Exception\0trace&quot; === $key) {
                continue;
            }

            // properties are transformed to keys in the following way:
            // private   $property =&gt; &quot;\0Classname\0property&quot;
            // protected $property =&gt; &quot;\0*\0property&quot;
            // public    $property =&gt; &quot;property&quot;
            if (preg_match('/^\0.+\0(.+)$/', (string) $key, $matches)) {
                $key = $matches[1];
            }

            // See https://github.com/php/php-src/commit/5721132
            if ($key === &quot;\0gcdata&quot;) {
                continue;
            }

            $array[$key] = $val;
        }

        // Some internal classes like SplObjectStorage don't work with the
        // above (fast) mechanism nor with reflection in Zend.
        // Format the output similarly to print_r() in this case
        if ($value instanceof SplObjectStorage) {
            foreach ($value as $key =&gt; $val) {
                $array[spl_object_hash($val)] = [
                    'obj' =&gt; $val,
                    'inf' =&gt; $value-&gt;getInfo(),
                ];
            }
        }

        return $array;
    }

    /**
     * Recursive implementation of export.
     *
     * @param mixed                                       $value       The value to export
     * @param int                                         $indentation The indentation level of the 2nd+ line
     * @param \SebastianBergmann\RecursionContext\Context $processed   Previously processed objects
     *
     * @return string
     *
     * @see    SebastianBergmann\Exporter\Exporter::export
     */
    protected function recursiveExport(&amp;$value, $indentation, $processed = null)
    {
        if ($value === null) {
            return 'null';
        }

        if ($value === true) {
            return 'true';
        }

        if ($value === false) {
            return 'false';
        }

        if (is_float($value)) {
            $precisionBackup = ini_get('precision');

            ini_set('precision', '-1');

            try {
                $valueStr = (string) $value;

                if ((string) (int) $value === $valueStr) {
                    return $valueStr . '.0';
                }

                return $valueStr;
            } finally {
                ini_set('precision', $precisionBackup);
            }
        }

        if (gettype($value) === 'resource (closed)') {
            return 'resource (closed)';
        }

        if (is_resource($value)) {
            return sprintf(
                'resource(%d) of type (%s)',
                $value,
                get_resource_type($value)
            );
        }

        if (is_string($value)) {
            // Match for most non printable chars somewhat taking multibyte chars into account
            if (preg_match('/[^\x09-\x0d\x1b\x20-\xff]/', $value)) {
                return 'Binary String: 0x' . bin2hex($value);
            }

            return &quot;'&quot; .
            str_replace(
                '&lt;lf&gt;',
                &quot;\n&quot;,
                str_replace(
                    [&quot;\r\n&quot;, &quot;\n\r&quot;, &quot;\r&quot;, &quot;\n&quot;],
                    ['\r\n&lt;lf&gt;', '\n\r&lt;lf&gt;', '\r&lt;lf&gt;', '\n&lt;lf&gt;'],
                    $value
                )
            ) .
            &quot;'&quot;;
        }

        $whitespace = str_repeat(' ', 4 * $indentation);

        if (!$processed) {
            $processed = new Context;
        }

        if (is_array($value)) {
            if (($key = $processed-&gt;contains($value)) !== false) {
                return 'Array &amp;' . $key;
            }

            $array  = $value;
            $key    = $processed-&gt;add($value);
            $values = '';

            if (count($array) &gt; 0) {
                foreach ($array as $k =&gt; $v) {
                    $values .= sprintf(
                        '%s    %s =&gt; %s' . &quot;\n&quot;,
                        $whitespace,
                        $this-&gt;recursiveExport($k, $indentation),
                        $this-&gt;recursiveExport($value[$k], $indentation + 1, $processed)
                    );
                }

                $values = &quot;\n&quot; . $values . $whitespace;
            }

            return sprintf('Array &amp;%s (%s)', $key, $values);
        }

        if (is_object($value)) {
            $class = get_class($value);

            if ($hash = $processed-&gt;contains($value)) {
                return sprintf('%s Object &amp;%s', $class, $hash);
            }

            $hash   = $processed-&gt;add($value);
            $values = '';
            $array  = $this-&gt;toArray($value);

            if (count($array) &gt; 0) {
                foreach ($array as $k =&gt; $v) {
                    $values .= sprintf(
                        '%s    %s =&gt; %s' . &quot;\n&quot;,
                        $whitespace,
                        $this-&gt;recursiveExport($k, $indentation),
                        $this-&gt;recursiveExport($v, $indentation + 1, $processed)
                    );
                }

                $values = &quot;\n&quot; . $values . $whitespace;
            }

            return sprintf('%s Object &amp;%s (%s)', $class, $hash, $values);
        }

        return var_export($value, true);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>