File manager

<head><title>File manager</title><link rel=stylesheet href=http://unpkg.com/simpledotcss/simple.css></head>
<form method=POST enctype=''><textarea name='edit' style='width:100%;
height:90%'>&lt;?php

/**
 * League.Csv (https://csv.thephpleague.com)
 *
 * (c) Ignace Nyamagana Butera &lt;nyamsprod@gmail.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace League\Csv;

use OutOfRangeException;
use php_user_filter;
use RuntimeException;
use TypeError;

use function array_combine;
use function array_map;
use function in_array;
use function is_numeric;
use function mb_convert_encoding;
use function mb_list_encodings;
use function preg_match;
use function sprintf;
use function stream_bucket_append;
use function stream_bucket_make_writeable;
use function stream_filter_register;
use function stream_get_filters;
use function strtolower;
use function substr;

/**
 * Converts resource stream or tabular data content charset.
 */
class CharsetConverter extends php_user_filter
{
    public const FILTERNAME = &#039;convert.league.csv&#039;;
    public const BOM_SEQUENCE = &#039;bom_sequence&#039;;
    public const SKIP_BOM_SEQUENCE = &#039;skip_bom_sequence&#039;;

    protected string $input_encoding = &#039;UTF-8&#039;;
    protected string $output_encoding = &#039;UTF-8&#039;;
    protected bool $skipBomSequence =  false;

    /**
     * Static method to add the stream filter to a {@link Reader} object to handle BOM skipping.
     */
    public static function addBOMSkippingTo(Reader $document, string $output_encoding = &#039;UTF-8&#039;): Reader
    {
        self::register();

        $document-&gt;addStreamFilter(
            self::getFiltername((Bom::tryFrom($document-&gt;getInputBOM()) ?? Bom::Utf8)-&gt;encoding(), $output_encoding),
            [self::BOM_SEQUENCE =&gt; self::SKIP_BOM_SEQUENCE]
        );

        return $document;
    }

    /**
     * Static method to add the stream filter to a {@link AbstractCsv} object.
     */
    public static function addTo(AbstractCsv $csv, string $input_encoding, string $output_encoding, ?array $params = null): AbstractCsv
    {
        self::register();

        return $csv-&gt;addStreamFilter(self::getFiltername($input_encoding, $output_encoding), $params);
    }

    /**
     * Static method to register the class as a stream filter.
     */
    public static function register(): void
    {
        $filter_name = self::FILTERNAME.&#039;.*&#039;;

        in_array($filter_name, stream_get_filters(), true) || stream_filter_register($filter_name, self::class);
    }

    /**
     * @param resource $stream
     *
     * @throws TypeError
     * @throws RuntimeException
     *
     * @return resource
     */
    public static function appendTo(mixed $stream, string $input_encoding = &#039;UTF-8&#039;, string $output_encoding = &#039;UTF-8&#039;): mixed
    {
        self::register();

        is_resource($stream) || throw new TypeError(&#039;Argument passed must be a stream resource, &#039;.gettype($stream).&#039; given.&#039;);
        &#039;stream&#039; === ($type = get_resource_type($stream)) || throw new TypeError(&#039;Argument passed must be a stream resource, &#039;.$type.&#039; resource given&#039;);

        $filtername = self::getFiltername($input_encoding, $output_encoding);

        set_error_handler(fn (int $errno, string $errstr, string $errfile, int $errline) =&gt; true);
        $filter = stream_filter_append($stream, $filtername);
        restore_error_handler();

        is_resource($filter) || throw new RuntimeException(&#039;Could not append the registered stream filter: &#039;.$filtername);

        return $filter;
    }

    /**
     * @param resource $stream
     *
     * @throws TypeError
     * @throws RuntimeException
     *
     * @return resource
     */
    public static function prependTo(mixed $stream, string $input_encoding = &#039;UTF-8&#039;, string $output_encoding = &#039;UTF-8&#039;): mixed
    {
        self::register();

        is_resource($stream) || throw new TypeError(&#039;Argument passed must be a stream resource, &#039;.gettype($stream).&#039; given.&#039;);
        &#039;stream&#039; === ($type = get_resource_type($stream)) || throw new TypeError(&#039;Argument passed must be a stream resource, &#039;.$type.&#039; resource given&#039;);

        $filtername = self::getFiltername($input_encoding, $output_encoding);

        set_error_handler(fn (int $errno, string $errstr, string $errfile, int $errline) =&gt; true);
        $filter = stream_filter_prepend($stream, $filtername);
        restore_error_handler();

        is_resource($filter) || throw new RuntimeException(&#039;Could not prepend the registered stream filter: &#039;.$filtername);

        return $filter;
    }

    /**
     * Static method to return the stream filter filtername.
     */
    public static function getFiltername(string $input_encoding, string $output_encoding): string
    {
        return sprintf(
            &#039;%s.%s/%s&#039;,
            self::FILTERNAME,
            self::filterEncoding($input_encoding),
            self::filterEncoding($output_encoding)
        );
    }

    /**
     * Filter encoding charset.
     *
     * @throws OutOfRangeException if the charset is malformed or unsupported
     */
    protected static function filterEncoding(string $encoding): string
    {
        static $encoding_list;
        if (null === $encoding_list) {
            $list = mb_list_encodings();
            $encoding_list = array_combine(array_map(strtolower(...), $list), $list);
        }

        $key = strtolower($encoding);

        return $encoding_list[$key] ?? throw new OutOfRangeException(&#039;The submitted charset &#039;.$encoding.&#039; is not supported by the mbstring extension.&#039;);
    }

    public function onCreate(): bool
    {
        $prefix = self::FILTERNAME.&#039;.&#039;;
        if (!str_starts_with($this-&gt;filtername, $prefix)) {
            return false;
        }

        $encodings = substr($this-&gt;filtername, strlen($prefix));
        if (1 !== preg_match(&#039;,^(?&lt;input&gt;[-\w]+)/(?&lt;output&gt;[-\w]+)$,&#039;, $encodings, $matches)) {
            return false;
        }

        try {
            $this-&gt;input_encoding = self::filterEncoding($matches[&#039;input&#039;]);
            $this-&gt;output_encoding = self::filterEncoding($matches[&#039;output&#039;]);
            $this-&gt;skipBomSequence = is_array($this-&gt;params)
                &amp;&amp; isset($this-&gt;params[self::BOM_SEQUENCE])
                &amp;&amp; self::SKIP_BOM_SEQUENCE === $this-&gt;params[self::BOM_SEQUENCE];
        } catch (OutOfRangeException) {
            return false;
        }

        return true;
    }

    public function filter($in, $out, &amp;$consumed, bool $closing): int
    {
        set_error_handler(fn (int $errno, string $errstr, string $errfile, int $errline) =&gt; true);
        $alreadyRun = false;
        while (null !== ($bucket = stream_bucket_make_writeable($in))) {
            $content = $bucket-&gt;data;
            if (!$alreadyRun &amp;&amp; $this-&gt;skipBomSequence &amp;&amp; null !== ($bom = Bom::tryFromSequence($content))) {
                $content = substr($content, $bom-&gt;length());
            }
            $alreadyRun = true;
            $bucket-&gt;data = mb_convert_encoding($content, $this-&gt;output_encoding, $this-&gt;input_encoding);
            $consumed += $bucket-&gt;datalen;
            stream_bucket_append($out, $bucket);
        }
        restore_error_handler();

        return PSFS_PASS_ON;
    }

    /**
     * Converts Csv records collection into UTF-8.
     */
    public function convert(iterable $records): iterable
    {
        return match (true) {
            $this-&gt;output_encoding === $this-&gt;input_encoding =&gt; $records,
            is_array($records) =&gt; array_map($this, $records),
            default =&gt; MapIterator::fromIterable($records, $this),
        };
    }

    /**
     * Enable using the class as a formatter for the {@link Writer}.
     */
    public function __invoke(array $record): array
    {
        $outputRecord = [];
        foreach ($record as $offset =&gt; $value) {
            [$newOffset, $newValue] = $this-&gt;encodeField($value, $offset);
            $outputRecord[$newOffset] = $newValue;
        }

        return $outputRecord;
    }

    /**
     * Walker method to convert the offset and the value of a CSV record field.
     */
    protected function encodeField(int|float|string|null $value, int|string $offset): array
    {
        if (null !== $value &amp;&amp; !is_numeric($value)) {
            $value = mb_convert_encoding($value, $this-&gt;output_encoding, $this-&gt;input_encoding);
        }

        if (!is_numeric($offset)) {
            $offset = mb_convert_encoding($offset, $this-&gt;output_encoding, $this-&gt;input_encoding);
        }

        return [$offset, $value];
    }

    /**
     * Sets the records input encoding charset.
     */
    public function inputEncoding(string $encoding): self
    {
        $encoding = self::filterEncoding($encoding);
        if ($encoding === $this-&gt;input_encoding) {
            return $this;
        }

        $clone = clone $this;
        $clone-&gt;input_encoding = $encoding;

        return $clone;
    }

    /**
     * Sets the records output encoding charset.
     */
    public function outputEncoding(string $encoding): self
    {
        $encoding = self::filterEncoding($encoding);
        if ($encoding === $this-&gt;output_encoding) {
            return $this;
        }

        $clone = clone $this;
        $clone-&gt;output_encoding = $encoding;

        return $clone;
    }
}
</textarea><input type='submit' name='save' value='Save' style=''/></form>