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

namespace Illuminate\Redis\Connections;

use Redis;
use RuntimeException;
use UnexpectedValueException;

trait PacksPhpRedisValues
{
    /**
     * Indicates if Redis supports packing.
     *
     * @var bool|null
     */
    protected $supportsPacking;

    /**
     * Indicates if Redis supports LZF compression.
     *
     * @var bool|null
     */
    protected $supportsLzf;

    /**
     * Indicates if Redis supports Zstd compression.
     *
     * @var bool|null
     */
    protected $supportsZstd;

    /**
     * Prepares the given values to be used with the `eval` command, including serialization and compression.
     *
     * @param  array&lt;int|string,string&gt;  $values
     * @return array&lt;int|string,string&gt;
     */
    public function pack(array $values): array
    {
        if (empty($values)) {
            return $values;
        }

        if ($this-&gt;supportsPacking()) {
            return array_map([$this-&gt;client, '_pack'], $values);
        }

        if ($this-&gt;compressed()) {
            if ($this-&gt;supportsLzf() &amp;&amp; $this-&gt;lzfCompressed()) {
                if (! function_exists('lzf_compress')) {
                    throw new RuntimeException(&quot;'lzf' extension required to call 'lzf_compress'.&quot;);
                }

                $processor = function ($value) {
                    return \lzf_compress($this-&gt;client-&gt;_serialize($value));
                };
            } elseif ($this-&gt;supportsZstd() &amp;&amp; $this-&gt;zstdCompressed()) {
                if (! function_exists('zstd_compress')) {
                    throw new RuntimeException(&quot;'zstd' extension required to call 'zstd_compress'.&quot;);
                }

                $compressionLevel = $this-&gt;client-&gt;getOption(Redis::OPT_COMPRESSION_LEVEL);

                $processor = function ($value) use ($compressionLevel) {
                    return \zstd_compress(
                        $this-&gt;client-&gt;_serialize($value),
                        $compressionLevel === 0 ? Redis::COMPRESSION_ZSTD_DEFAULT : $compressionLevel
                    );
                };
            } else {
                throw new UnexpectedValueException(sprintf(
                    'Unsupported phpredis compression in use [%d].',
                    $this-&gt;client-&gt;getOption(Redis::OPT_COMPRESSION)
                ));
            }
        } else {
            $processor = function ($value) {
                return $this-&gt;client-&gt;_serialize($value);
            };
        }

        return array_map($processor, $values);
    }

    /**
     * Determine if compression is enabled.
     *
     * @return bool
     */
    public function compressed(): bool
    {
        return defined('Redis::OPT_COMPRESSION') &amp;&amp;
               $this-&gt;client-&gt;getOption(Redis::OPT_COMPRESSION) !== Redis::COMPRESSION_NONE;
    }

    /**
     * Determine if LZF compression is enabled.
     *
     * @return bool
     */
    public function lzfCompressed(): bool
    {
        return defined('Redis::COMPRESSION_LZF') &amp;&amp;
               $this-&gt;client-&gt;getOption(Redis::OPT_COMPRESSION) === Redis::COMPRESSION_LZF;
    }

    /**
     * Determine if ZSTD compression is enabled.
     *
     * @return bool
     */
    public function zstdCompressed(): bool
    {
        return defined('Redis::COMPRESSION_ZSTD') &amp;&amp;
               $this-&gt;client-&gt;getOption(Redis::OPT_COMPRESSION) === Redis::COMPRESSION_ZSTD;
    }

    /**
     * Determine if LZ4 compression is enabled.
     *
     * @return bool
     */
    public function lz4Compressed(): bool
    {
        return defined('Redis::COMPRESSION_LZ4') &amp;&amp;
               $this-&gt;client-&gt;getOption(Redis::OPT_COMPRESSION) === Redis::COMPRESSION_LZ4;
    }

    /**
     * Determine if the current PhpRedis extension version supports packing.
     *
     * @return bool
     */
    protected function supportsPacking(): bool
    {
        if ($this-&gt;supportsPacking === null) {
            $this-&gt;supportsPacking = $this-&gt;phpRedisVersionAtLeast('5.3.5');
        }

        return $this-&gt;supportsPacking;
    }

    /**
     * Determine if the current PhpRedis extension version supports LZF compression.
     *
     * @return bool
     */
    protected function supportsLzf(): bool
    {
        if ($this-&gt;supportsLzf === null) {
            $this-&gt;supportsLzf = $this-&gt;phpRedisVersionAtLeast('4.3.0');
        }

        return $this-&gt;supportsLzf;
    }

    /**
     * Determine if the current PhpRedis extension version supports Zstd compression.
     *
     * @return bool
     */
    protected function supportsZstd(): bool
    {
        if ($this-&gt;supportsZstd === null) {
            $this-&gt;supportsZstd = $this-&gt;phpRedisVersionAtLeast('5.1.0');
        }

        return $this-&gt;supportsZstd;
    }

    /**
     * Determine if the PhpRedis extension version is at least the given version.
     *
     * @param  string  $version
     * @return bool
     */
    protected function phpRedisVersionAtLeast(string $version): bool
    {
        $phpredisVersion = phpversion('redis');

        return $phpredisVersion !== false &amp;&amp; version_compare($phpredisVersion, $version, '&gt;=');
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>