<h2>Edit File - File.php</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/home/u548619843/domains/indusjewellery.com/public_html/vendor/maennchen/zipstream-php/src/File.php">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&lt;?php

declare(strict_types=1);

namespace ZipStream;

use Closure;
use DateTimeInterface;
use DeflateContext;
use RuntimeException;
use ZipStream\Exception\FileSizeIncorrectException;
use ZipStream\Exception\OverflowException;
use ZipStream\Exception\ResourceActionException;
use ZipStream\Exception\SimulationFileUnknownException;
use ZipStream\Exception\StreamNotReadableException;
use ZipStream\Exception\StreamNotSeekableException;

/**
 * @internal
 */
class File
{
    private const CHUNKED_READ_BLOCK_SIZE = 0x1000000;

    private Version $version;

    private int $compressedSize = 0;

    private int $uncompressedSize = 0;

    private int $crc = 0;

    private int $generalPurposeBitFlag = 0;

    private readonly string $fileName;

    /**
     * @var resource|null
     */
    private $stream;

    /**
     * @param Closure $dataCallback
     * @psalm-param Closure(): resource $dataCallback
     */
    public function __construct(
        string $fileName,
        private readonly Closure $dataCallback,
        private readonly OperationMode $operationMode,
        private readonly int $startOffset,
        private readonly CompressionMethod $compressionMethod,
        private readonly string $comment,
        private readonly DateTimeInterface $lastModificationDateTime,
        private readonly int $deflateLevel,
        private readonly ?int $maxSize,
        private readonly ?int $exactSize,
        private readonly bool $enableZip64,
        private readonly bool $enableZeroHeader,
        private readonly Closure $send,
        private readonly Closure $recordSentBytes,
    ) {
        $this-&gt;fileName = self::filterFilename($fileName);
        $this-&gt;checkEncoding();

        if ($this-&gt;enableZeroHeader) {
            $this-&gt;generalPurposeBitFlag |= GeneralPurposeBitFlag::ZERO_HEADER;
        }

        $this-&gt;version = $this-&gt;compressionMethod === CompressionMethod::DEFLATE ? Version::DEFLATE : Version::STORE;
    }

    public function cloneSimulationExecution(): self
    {
        return new self(
            $this-&gt;fileName,
            $this-&gt;dataCallback,
            OperationMode::NORMAL,
            $this-&gt;startOffset,
            $this-&gt;compressionMethod,
            $this-&gt;comment,
            $this-&gt;lastModificationDateTime,
            $this-&gt;deflateLevel,
            $this-&gt;maxSize,
            $this-&gt;exactSize,
            $this-&gt;enableZip64,
            $this-&gt;enableZeroHeader,
            $this-&gt;send,
            $this-&gt;recordSentBytes,
        );
    }

    public function process(): string
    {
        $forecastSize = $this-&gt;forecastSize();

        if ($this-&gt;enableZeroHeader) {
            // No calculation required
        } elseif ($this-&gt;isSimulation() &amp;&amp; $forecastSize !== null) {
            $this-&gt;uncompressedSize = $forecastSize;
            $this-&gt;compressedSize = $forecastSize;
        } else {
            $this-&gt;readStream(send: false);
            if (rewind($this-&gt;unpackStream()) === false) {
                throw new ResourceActionException(&#039;rewind&#039;, $this-&gt;unpackStream());
            }
        }

        $this-&gt;addFileHeader();

        $detectedSize = $forecastSize ?? ($this-&gt;compressedSize &gt; 0 ? $this-&gt;compressedSize : null);

        if (
            $this-&gt;isSimulation() &amp;&amp;
            $detectedSize !== null
        ) {
            $this-&gt;uncompressedSize = $detectedSize;
            $this-&gt;compressedSize = $detectedSize;
            ($this-&gt;recordSentBytes)($detectedSize);
        } else {
            $this-&gt;readStream(send: true);
        }

        $this-&gt;addFileFooter();
        return $this-&gt;getCdrFile();
    }

    /**
     * @return resource
     */
    private function unpackStream()
    {
        if ($this-&gt;stream) {
            return $this-&gt;stream;
        }

        if ($this-&gt;operationMode === OperationMode::SIMULATE_STRICT) {
            throw new SimulationFileUnknownException();
        }

        $this-&gt;stream = ($this-&gt;dataCallback)();

        if (!$this-&gt;enableZeroHeader &amp;&amp; !stream_get_meta_data($this-&gt;stream)[&#039;seekable&#039;]) {
            throw new StreamNotSeekableException();
        }
        if (!(
            str_contains(stream_get_meta_data($this-&gt;stream)[&#039;mode&#039;], &#039;r&#039;)
            || str_contains(stream_get_meta_data($this-&gt;stream)[&#039;mode&#039;], &#039;w+&#039;)
            || str_contains(stream_get_meta_data($this-&gt;stream)[&#039;mode&#039;], &#039;a+&#039;)
            || str_contains(stream_get_meta_data($this-&gt;stream)[&#039;mode&#039;], &#039;x+&#039;)
            || str_contains(stream_get_meta_data($this-&gt;stream)[&#039;mode&#039;], &#039;c+&#039;)
        )) {
            throw new StreamNotReadableException();
        }

        return $this-&gt;stream;
    }

    private function forecastSize(): ?int
    {
        if ($this-&gt;compressionMethod !== CompressionMethod::STORE) {
            return null;
        }
        if ($this-&gt;exactSize !== null) {
            return $this-&gt;exactSize;
        }
        $fstat = fstat($this-&gt;unpackStream());
        if (!$fstat || !array_key_exists(&#039;size&#039;, $fstat) || $fstat[&#039;size&#039;] &lt; 1) {
            return null;
        }

        if ($this-&gt;maxSize !== null &amp;&amp; $this-&gt;maxSize &lt; $fstat[&#039;size&#039;]) {
            return $this-&gt;maxSize;
        }

        return $fstat[&#039;size&#039;];
    }

    /**
     * Create and send zip header for this file.
     */
    private function addFileHeader(): void
    {
        $forceEnableZip64 = $this-&gt;enableZeroHeader &amp;&amp; $this-&gt;enableZip64;

        $footer = $this-&gt;buildZip64ExtraBlock($forceEnableZip64);

        $zip64Enabled = $footer !== &#039;&#039;;

        if ($zip64Enabled) {
            $this-&gt;version = Version::ZIP64;
        }

        if ($this-&gt;generalPurposeBitFlag &amp; GeneralPurposeBitFlag::EFS) {
            // Put the tricky entry to
            // force Linux unzip to lookup EFS flag.
            $footer .= Zs\ExtendedInformationExtraField::generate();
        }

        $data = LocalFileHeader::generate(
            versionNeededToExtract: $this-&gt;version-&gt;value,
            generalPurposeBitFlag: $this-&gt;generalPurposeBitFlag,
            compressionMethod: $this-&gt;compressionMethod,
            lastModificationDateTime: $this-&gt;lastModificationDateTime,
            crc32UncompressedData: $this-&gt;crc,
            compressedSize: $zip64Enabled
                ? 0xFFFFFFFF
                : $this-&gt;compressedSize,
            uncompressedSize: $zip64Enabled
                ? 0xFFFFFFFF
                : $this-&gt;uncompressedSize,
            fileName: $this-&gt;fileName,
            extraField: $footer,
        );


        ($this-&gt;send)($data);
    }

    /**
     * Strip characters that are not legal in Windows filenames
     * to prevent compatibility issues
     */
    private static function filterFilename(
        /**
         * Unprocessed filename
         */
        string $fileName
    ): string {
        // strip leading slashes from file name
        // (fixes bug in windows archive viewer)
        $fileName = ltrim($fileName, &#039;/&#039;);

        return str_replace([&#039;\\&#039;, &#039;:&#039;, &#039;*&#039;, &#039;?&#039;, &#039;&quot;&#039;, &#039;&lt;&#039;, &#039;&gt;&#039;, &#039;|&#039;], &#039;_&#039;, $fileName);
    }

    private function checkEncoding(): void
    {
        // Sets Bit 11: Language encoding flag (EFS).  If this bit is set,
        // the filename and comment fields for this file
        // MUST be encoded using UTF-8. (see APPENDIX D)
        if (mb_check_encoding($this-&gt;fileName, &#039;UTF-8&#039;) &amp;&amp;
                mb_check_encoding($this-&gt;comment, &#039;UTF-8&#039;)) {
            $this-&gt;generalPurposeBitFlag |= GeneralPurposeBitFlag::EFS;
        }
    }

    private function buildZip64ExtraBlock(bool $force = false): string
    {
        $outputZip64ExtraBlock = false;

        $originalSize = null;
        if ($force || $this-&gt;uncompressedSize &gt; 0xFFFFFFFF) {
            $outputZip64ExtraBlock = true;
            $originalSize = $this-&gt;uncompressedSize;
        }

        $compressedSize = null;
        if ($force || $this-&gt;compressedSize &gt; 0xFFFFFFFF) {
            $outputZip64ExtraBlock = true;
            $compressedSize = $this-&gt;compressedSize;
        }

        // If this file will start over 4GB limit in ZIP file,
        // CDR record will have to use Zip64 extension to describe offset
        // to keep consistency we use the same value here
        $relativeHeaderOffset = null;
        if ($this-&gt;startOffset &gt; 0xFFFFFFFF) {
            $outputZip64ExtraBlock = true;
            $relativeHeaderOffset = $this-&gt;startOffset;
        }

        if (!$outputZip64ExtraBlock) {
            return &#039;&#039;;
        }

        if (!$this-&gt;enableZip64) {
            throw new OverflowException();
        }

        return Zip64\ExtendedInformationExtraField::generate(
            originalSize: $originalSize,
            compressedSize: $compressedSize,
            relativeHeaderOffset: $relativeHeaderOffset,
            diskStartNumber: null,
        );
    }

    private function addFileFooter(): void
    {
        if (($this-&gt;compressedSize &gt; 0xFFFFFFFF || $this-&gt;uncompressedSize &gt; 0xFFFFFFFF) &amp;&amp; $this-&gt;version !== Version::ZIP64) {
            throw new OverflowException();
        }

        if (!$this-&gt;enableZeroHeader) {
            return;
        }

        if ($this-&gt;version === Version::ZIP64) {
            $footer = Zip64\DataDescriptor::generate(
                crc32UncompressedData: $this-&gt;crc,
                compressedSize: $this-&gt;compressedSize,
                uncompressedSize: $this-&gt;uncompressedSize,
            );
        } else {
            $footer = DataDescriptor::generate(
                crc32UncompressedData: $this-&gt;crc,
                compressedSize: $this-&gt;compressedSize,
                uncompressedSize: $this-&gt;uncompressedSize,
            );
        }

        ($this-&gt;send)($footer);
    }

    private function readStream(bool $send): void
    {
        $this-&gt;compressedSize = 0;
        $this-&gt;uncompressedSize = 0;
        $hash = hash_init(&#039;crc32b&#039;);

        $deflate = $this-&gt;compressionInit();

        while (
            !feof($this-&gt;unpackStream()) &amp;&amp;
            ($this-&gt;maxSize === null || $this-&gt;uncompressedSize &lt; $this-&gt;maxSize) &amp;&amp;
            ($this-&gt;exactSize === null || $this-&gt;uncompressedSize &lt; $this-&gt;exactSize)
        ) {
            $readLength = min(
                ($this-&gt;maxSize ?? PHP_INT_MAX) - $this-&gt;uncompressedSize,
                ($this-&gt;exactSize ?? PHP_INT_MAX) - $this-&gt;uncompressedSize,
                self::CHUNKED_READ_BLOCK_SIZE
            );

            $data = fread($this-&gt;unpackStream(), $readLength);

            if ($data === false) {
                throw new ResourceActionException(&#039;fread&#039;, $this-&gt;unpackStream());
            }

            hash_update($hash, $data);

            $this-&gt;uncompressedSize += strlen($data);

            if ($deflate) {
                $data =  deflate_add(
                    $deflate,
                    $data,
                    feof($this-&gt;unpackStream()) ? ZLIB_FINISH : ZLIB_NO_FLUSH
                );

                if ($data === false) {
                    throw new RuntimeException(&#039;deflate_add failed&#039;);
                }
            }

            $this-&gt;compressedSize += strlen($data);

            if ($send) {
                ($this-&gt;send)($data);
            }
        }

        if ($this-&gt;exactSize !== null &amp;&amp; $this-&gt;uncompressedSize !== $this-&gt;exactSize) {
            throw new FileSizeIncorrectException(expectedSize: $this-&gt;exactSize, actualSize: $this-&gt;uncompressedSize);
        }

        $this-&gt;crc = hexdec(hash_final($hash));
    }

    private function compressionInit(): ?DeflateContext
    {
        switch ($this-&gt;compressionMethod) {
            case CompressionMethod::STORE:
                // Noting to do
                return null;
            case CompressionMethod::DEFLATE:
                $deflateContext = deflate_init(
                    ZLIB_ENCODING_RAW,
                    [&#039;level&#039; =&gt; $this-&gt;deflateLevel]
                );

                if (!$deflateContext) {
                    // @codeCoverageIgnoreStart
                    throw new RuntimeException(&quot;Can&#039;t initialize deflate context.&quot;);
                    // @codeCoverageIgnoreEnd
                }

                // False positive, resource is no longer returned from this function
                return $deflateContext;
            default:
                // @codeCoverageIgnoreStart
                throw new RuntimeException(&#039;Unsupported Compression Method &#039; . print_r($this-&gt;compressionMethod, true));
                // @codeCoverageIgnoreEnd
        }
    }

    private function getCdrFile(): string
    {
        $footer = $this-&gt;buildZip64ExtraBlock();

        return CentralDirectoryFileHeader::generate(
            versionMadeBy: ZipStream::ZIP_VERSION_MADE_BY,
            versionNeededToExtract: $this-&gt;version-&gt;value,
            generalPurposeBitFlag: $this-&gt;generalPurposeBitFlag,
            compressionMethod: $this-&gt;compressionMethod,
            lastModificationDateTime: $this-&gt;lastModificationDateTime,
            crc32: $this-&gt;crc,
            compressedSize: $this-&gt;compressedSize &gt; 0xFFFFFFFF
                ? 0xFFFFFFFF
                : $this-&gt;compressedSize,
            uncompressedSize: $this-&gt;uncompressedSize &gt; 0xFFFFFFFF
                ? 0xFFFFFFFF
                : $this-&gt;uncompressedSize,
            fileName: $this-&gt;fileName,
            extraField: $footer,
            fileComment: $this-&gt;comment,
            diskNumberStart: 0,
            internalFileAttributes: 0,
            externalFileAttributes: 32,
            relativeOffsetOfLocalHeader: $this-&gt;startOffset &gt; 0xFFFFFFFF
                ? 0xFFFFFFFF
                : $this-&gt;startOffset,
        );
    }

    private function isSimulation(): bool
    {
        return $this-&gt;operationMode === OperationMode::SIMULATE_LAX || $this-&gt;operationMode === OperationMode::SIMULATE_STRICT;
    }
}
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>