
ðŸ²dfcvðŸ°ddâ‹‰(â— âˆ¸ â—)â‹Š@% PNG ï»¿%k25u25%fgd5n!ï»¿ PNG ï»¿%k25u25%fgd5n!PK     V_]q['    6  zipstream-php/test/Zip64/EndOfCentralDirectoryTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test\Zip64;

use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\EndOfCentralDirectory;

class EndOfCentralDirectoryTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $descriptor = EndOfCentralDirectory::generate(
            versionMadeBy: 0x3333,
            versionNeededToExtract: 0x4444,
            numberOfThisDisk: 0x55555555,
            numberOfTheDiskWithCentralDirectoryStart: 0x66666666,
            numberOfCentralDirectoryEntriesOnThisDisk: (0x77777777 << 32) + 0x88888888,
            numberOfCentralDirectoryEntries: (0x99999999 << 32) + 0xAAAAAAAA,
            sizeOfCentralDirectory: (0xBBBBBBBB << 32) + 0xCCCCCCCC,
            centralDirectoryStartOffsetOnDisk: (0xDDDDDDDD << 32) + 0xEEEEEEEE,
            extensibleDataSector: 'foo',
        );

        $this->assertSame(
            bin2hex($descriptor),
            '504b0606' . // 4 bytes;zip64 end of central dir signature - 0x06064b50
            '2f00000000000000' . // 8 bytes; size of zip64 end of central directory record
            '3333' . // 2 bytes; version made by
            '4444' . // 2 bytes; version needed to extract
            '55555555' . // 4 bytes; number of this disk
            '66666666' . // 4 bytes; number of the disk with the start of the central directory
            '8888888877777777' . // 8 bytes; total number of entries in the central directory on this disk
            'aaaaaaaa99999999' . // 8 bytes; total number of entries in the central directory
            'ccccccccbbbbbbbb' . // 8 bytes; size of the central directory
            'eeeeeeeedddddddd' . // 8 bytes; offset of start of central directory with respect to the starting disk number
            bin2hex('foo')
        );
    }
}
PK     V_]¥ZXH5  5  /  zipstream-php/test/Zip64/DataDescriptorTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test\Zip64;

use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\DataDescriptor;

class DataDescriptorTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $descriptor = DataDescriptor::generate(
            crc32UncompressedData: 0x11111111,
            compressedSize: (0x77777777 << 32) +  0x66666666,
            uncompressedSize: (0x99999999 << 32) + 0x88888888,
        );

        $this->assertSame(
            bin2hex($descriptor),
            '504b0708' . // 4 bytes; Optional data descriptor signature = 0x08074b50
            '11111111' . // 4 bytes; CRC-32 of uncompressed data
            '6666666677777777' . // 8 bytes; Compressed size
            '8888888899999999' // 8 bytes; Uncompressed size
        );
    }
}
PK     V_]gNÛé    >  zipstream-php/test/Zip64/ExtendedInformationExtraFieldTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test\Zip64;

use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\ExtendedInformationExtraField;

class ExtendedInformationExtraFieldTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $extraField = ExtendedInformationExtraField::generate(
            originalSize: (0x77777777 << 32) + 0x66666666,
            compressedSize: (0x99999999 << 32) + 0x88888888,
            relativeHeaderOffset: (0x22222222 << 32) + 0x11111111,
            diskStartNumber: 0x33333333,
        );

        $this->assertSame(
            bin2hex($extraField),
            '0100' . // 2 bytes; Tag for this "extra" block type
            '1c00' . // 2 bytes; Size of this "extra" block
            '6666666677777777' . // 8 bytes; Original uncompressed file size
            '8888888899999999' . // 8 bytes; Size of compressed data
            '1111111122222222' . // 8 bytes; Offset of local header record
            '33333333' // 4 bytes; Number of the disk on which this file starts
        );
    }

    public function testSerializesEmptyCorrectly(): void
    {
        $extraField = ExtendedInformationExtraField::generate();

        $this->assertSame(
            bin2hex($extraField),
            '0100' . // 2 bytes; Tag for this "extra" block type
            '0000' // 2 bytes; Size of this "extra" block
        );
    }
}
PK     V_]¨²øåØ  Ø  =  zipstream-php/test/Zip64/EndOfCentralDirectoryLocatorTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test\Zip64;

use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\EndOfCentralDirectoryLocator;

class EndOfCentralDirectoryLocatorTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $descriptor = EndOfCentralDirectoryLocator::generate(
            numberOfTheDiskWithZip64CentralDirectoryStart: 0x11111111,
            zip64centralDirectoryStartOffsetOnDisk: (0x22222222 << 32) + 0x33333333,
            totalNumberOfDisks: 0x44444444,
        );

        $this->assertSame(
            bin2hex($descriptor),
            '504b0607' . // 4 bytes; zip64 end of central dir locator signature - 0x07064b50
            '11111111' . // 4 bytes; number of the disk with the start of the zip64 end of central directory
            '3333333322222222' . // 28 bytes; relative offset of the zip64 end of central directory record
            '44444444' // 4 bytes;total number of disks
        );
    }
}
PK     V_]‡¢Rˆ    ;  zipstream-php/test/Zs/ExtendedInformationExtraFieldTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test\Zs;

use PHPUnit\Framework\TestCase;
use ZipStream\Zs\ExtendedInformationExtraField;

class ExtendedInformationExtraFieldTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $extraField = ExtendedInformationExtraField::generate();

        $this->assertSame(
            bin2hex((string) $extraField),
            '5356' . // 2 bytes; Tag for this "extra" block type
            '0000' // 2 bytes; TODO: Document
        );
    }
}
PK     V_]Z ×5  5    zipstream-php/test/Util.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use function fgets;
use function pclose;
use function popen;
use function preg_match;

use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

use function strtolower;

use ZipArchive;

trait Util
{
    protected function cmdExists(string $command): bool
    {
        if (strtolower(\substr(PHP_OS, 0, 3)) === 'win') {
            $fp = popen("where $command", 'r');
            $result = fgets($fp, 255);
            $exists = !preg_match('#Could not find files#', $result);
            pclose($fp);
        } else { // non-Windows
            $fp = popen("which $command", 'r');
            $result = fgets($fp, 255);
            $exists = !empty($result);
            pclose($fp);
        }

        return $exists;
    }

    protected function dumpZipContents(string $path): string
    {
        if (!$this->cmdExists('hexdump')) {
            return '';
        }

        $output = [];

        if (!exec("hexdump -C \"$path\" | head -n 50", $output)) {
            return '';
        }

        return "\nHexdump:\n" . implode("\n", $output);
    }

    protected function validateAndExtractZip(string $zipPath): string
    {
        $tmpDir = $this->getTmpDir();

        $zipArchive = new ZipArchive();
        $result = $zipArchive->open($zipPath);

        if ($result !== true) {
            $codeName = $this->zipArchiveOpenErrorCodeName($result);
            $debugInformation = $this->dumpZipContents($zipPath);

            $this->fail("Failed to open {$zipPath}. Code: $result ($codeName)$debugInformation");

            return $tmpDir;
        }

        $this->assertSame(0, $zipArchive->status);
        $this->assertSame(0, $zipArchive->statusSys);

        $zipArchive->extractTo($tmpDir);
        $zipArchive->close();

        return $tmpDir;
    }

    protected function zipArchiveOpenErrorCodeName(int $code): string
    {
        switch ($code) {
            case ZipArchive::ER_EXISTS: return 'ER_EXISTS';
            case ZipArchive::ER_INCONS: return 'ER_INCONS';
            case ZipArchive::ER_INVAL: return 'ER_INVAL';
            case ZipArchive::ER_MEMORY: return 'ER_MEMORY';
            case ZipArchive::ER_NOENT: return 'ER_NOENT';
            case ZipArchive::ER_NOZIP: return 'ER_NOZIP';
            case ZipArchive::ER_OPEN: return 'ER_OPEN';
            case ZipArchive::ER_READ: return 'ER_READ';
            case ZipArchive::ER_SEEK: return 'ER_SEEK';
            default: return 'unknown';
        }
    }

    protected function getTmpDir(): string
    {
        $tmp = tempnam(sys_get_temp_dir(), 'zipstreamtest');
        unlink($tmp);
        mkdir($tmp) or $this->fail('Failed to make directory');

        return $tmp;
    }

    /**
     * @return string[]
     */
    protected function getRecursiveFileList(string $path, bool $includeDirectories = false): array
    {
        $data = [];
        $path = (string) realpath($path);
        $files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path));

        $pathLen = strlen($path);
        foreach ($files as $file) {
            $filePath = $file->getRealPath();

            if (is_dir($filePath) && !$includeDirectories) {
                continue;
            }

            $data[] = substr($filePath, $pathLen + 1);
        }

        sort($data);

        return $data;
    }
}
PK     V_]ºw„,j  j  0  zipstream-php/test/EndOfCentralDirectoryTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use PHPUnit\Framework\TestCase;
use ZipStream\EndOfCentralDirectory;

class EndOfCentralDirectoryTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $this->assertSame(
            bin2hex(EndOfCentralDirectory::generate(
                numberOfThisDisk: 0x00,
                numberOfTheDiskWithCentralDirectoryStart: 0x00,
                numberOfCentralDirectoryEntriesOnThisDisk: 0x10,
                numberOfCentralDirectoryEntries: 0x10,
                sizeOfCentralDirectory: 0x22,
                centralDirectoryStartOffsetOnDisk: 0x33,
                zipFileComment: 'foo',
            )),
            '504b0506' . // 4 bytes; end of central dir signature 0x06054b50
            '0000' . // 2 bytes; number of this disk
            '0000' . // 2 bytes; number of the disk with the start of the central directory
            '1000' . // 2 bytes; total number of entries in the central directory on this disk
            '1000' . // 2 bytes; total number of entries in the central directory
            '22000000' . // 4 bytes; size of the central directory
            '33000000' . // 4 bytes; offset of start of central directory with respect to the starting disk number
            '0300' . // 2 bytes; .ZIP file comment length
            bin2hex('foo')
        );
    }
}
PK     V_]9ÛúÉ  É  *  zipstream-php/test/LocalFileHeaderTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use DateTimeImmutable;
use PHPUnit\Framework\TestCase;
use ZipStream\CompressionMethod;
use ZipStream\LocalFileHeader;

class LocalFileHeaderTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $dateTime = new DateTimeImmutable('2022-01-01 01:01:01Z');

        $header = LocalFileHeader::generate(
            versionNeededToExtract: 0x002D,
            generalPurposeBitFlag: 0x2222,
            compressionMethod: CompressionMethod::DEFLATE,
            lastModificationDateTime: $dateTime,
            crc32UncompressedData: 0x11111111,
            compressedSize: 0x77777777,
            uncompressedSize: 0x99999999,
            fileName: 'test.png',
            extraField: 'some content'
        );

        $this->assertSame(
            bin2hex((string) $header),
            '504b0304' . // 4 bytes; Local file header signature
            '2d00' . // 2 bytes; Version needed to extract (minimum)
            '2222' . // 2 bytes; General purpose bit flag
            '0800' . // 2 bytes; Compression method; e.g. none = 0, DEFLATE = 8
            '2008' . // 2 bytes; File last modification time
            '2154' . // 2 bytes; File last modification date
            '11111111' . // 4 bytes; CRC-32 of uncompressed data
            '77777777' . // 4 bytes; Compressed size (or 0xffffffff for ZIP64)
            '99999999' . // 4 bytes; Uncompressed size (or 0xffffffff for ZIP64)
            '0800' . // 2 bytes; File name length (n)
            '0c00' . // 2 bytes; Extra field length (m)
            '746573742e706e67' . // n bytes; File name
            '736f6d6520636f6e74656e74' // m bytes; Extra field
        );
    }
}
PK     V_]Sýê  ê  )  zipstream-php/test/EndlessCycleStream.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use Psr\Http\Message\StreamInterface;
use RuntimeException;

class EndlessCycleStream implements StreamInterface
{
    private int $offset = 0;

    public function __construct(private readonly string $toRepeat = '0') {}

    public function __toString(): string
    {
        throw new RuntimeException('Infinite Stream!');
    }

    public function close(): void
    {
        $this->detach();
    }

    /**
     * @return null
     */
    public function detach()
    {
        return;
    }

    public function getSize(): ?int
    {
        return null;
    }

    public function tell(): int
    {
        return $this->offset;
    }

    public function eof(): bool
    {
        return false;
    }

    public function isSeekable(): bool
    {
        return true;
    }

    public function seek(int $offset, int $whence = SEEK_SET): void
    {
        switch ($whence) {
            case SEEK_SET:
                $this->offset = $offset;
                break;
            case SEEK_CUR:
                $this->offset += $offset;
                break;
            case SEEK_END:
                throw new RuntimeException('Infinite Stream!');
                break;
        }
    }

    public function rewind(): void
    {
        $this->seek(0);
    }

    public function isWritable(): bool
    {
        return false;
    }

    public function write(string $string): int
    {
        throw new RuntimeException('Not writeable');
    }

    public function isReadable(): bool
    {
        return true;
    }

    public function read(int $length): string
    {
        $this->offset += $length;
        return substr(str_repeat($this->toRepeat, (int) ceil($length / strlen($this->toRepeat))), 0, $length);
    }

    public function getContents(): string
    {
        throw new RuntimeException('Infinite Stream!');
    }

    public function getMetadata(?string $key = null): array|null
    {
        return $key !== null ? null : [];
    }
}
PK     V_]ŽEwÚ  Ú  )  zipstream-php/test/DataDescriptorTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use PHPUnit\Framework\TestCase;
use ZipStream\DataDescriptor;

class DataDescriptorTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $this->assertSame(
            bin2hex(DataDescriptor::generate(
                crc32UncompressedData: 0x11111111,
                compressedSize: 0x77777777,
                uncompressedSize: 0x99999999,
            )),
            '504b0708' . // 4 bytes; Optional data descriptor signature = 0x08074b50
            '11111111' . // 4 bytes; CRC-32 of uncompressed data
            '77777777' . // 4 bytes; Compressed size
            '99999999' // 4 bytes; Uncompressed size
        );
    }
}
PK     V_]q@Uß  ß    zipstream-php/test/TimeTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use DateTimeImmutable;
use PHPUnit\Framework\TestCase;
use ZipStream\Exception\DosTimeOverflowException;
use ZipStream\Time;

class TimeTest extends TestCase
{
    public function testNormalDateToDosTime(): void
    {
        $this->assertSame(
            Time::dateTimeToDosTime(new DateTimeImmutable('2014-11-17T17:46:08Z')),
            1165069764
        );

        // January 1 1980 - DOS Epoch.
        $this->assertSame(
            Time::dateTimeToDosTime(new DateTimeImmutable('1980-01-01T00:00:00+00:00')),
            2162688
        );

        // Local timezone different than UTC.
        $prevLocalTimezone = date_default_timezone_get();
        date_default_timezone_set('Europe/Berlin');
        $this->assertSame(
            Time::dateTimeToDosTime(new DateTimeImmutable('1980-01-01T00:00:00+00:00')),
            2162688
        );
        date_default_timezone_set($prevLocalTimezone);
    }

    public function testTooEarlyDateToDosTime(): void
    {
        $this->expectException(DosTimeOverflowException::class);

        // January 1 1980 is the minimum DOS Epoch.
        Time::dateTimeToDosTime(new DateTimeImmutable('1970-01-01T00:00:00+00:00'));
    }
}
PK     V_]q
PÜq   q      zipstream-php/test/bootstrap.phpnu „[µü¤        <?php

declare(strict_types=1);

date_default_timezone_set('UTC');

require __DIR__ . '/../vendor/autoload.php';
PK     V_]	Š0êÚ  Ú  5  zipstream-php/test/CentralDirectoryFileHeaderTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use DateTimeImmutable;
use PHPUnit\Framework\TestCase;
use ZipStream\CentralDirectoryFileHeader;
use ZipStream\CompressionMethod;

class CentralDirectoryFileHeaderTest extends TestCase
{
    public function testSerializesCorrectly(): void
    {
        $dateTime = new DateTimeImmutable('2022-01-01 01:01:01Z');

        $header = CentralDirectoryFileHeader::generate(
            versionMadeBy: 0x603,
            versionNeededToExtract: 0x002D,
            generalPurposeBitFlag: 0x2222,
            compressionMethod: CompressionMethod::DEFLATE,
            lastModificationDateTime: $dateTime,
            crc32: 0x11111111,
            compressedSize: 0x77777777,
            uncompressedSize: 0x99999999,
            fileName: 'test.png',
            extraField: 'some content',
            fileComment: 'some comment',
            diskNumberStart: 0,
            internalFileAttributes: 0,
            externalFileAttributes: 32,
            relativeOffsetOfLocalHeader: 0x1234,
        );

        $this->assertSame(
            bin2hex($header),
            '504b0102' . // 4 bytes; central file header signature
            '0306' . // 2 bytes; version made by
            '2d00' . // 2 bytes; version needed to extract
            '2222' . // 2 bytes; general purpose bit flag
            '0800' . // 2 bytes; compression method
            '2008' . // 2 bytes; last mod file time
            '2154' . // 2 bytes; last mod file date
            '11111111' . // 4 bytes; crc-32
            '77777777' . // 4 bytes; compressed size
            '99999999' . // 4 bytes; uncompressed size
            '0800' . // 2 bytes; file name length (n)
            '0c00' . // 2 bytes; extra field length (m)
            '0c00' . // 2 bytes; file comment length (o)
            '0000' . // 2 bytes; disk number start
            '0000' . // 2 bytes; internal file attributes
            '20000000' . // 4 bytes; external file attributes
            '34120000' . // 4 bytes; relative offset of local header
            '746573742e706e67' . // n bytes; file name
            '736f6d6520636f6e74656e74' . // m bytes; extra field
            '736f6d6520636f6d6d656e74' // o bytes; file comment
        );
    }
}
PK     V_]>›Ó¿s  s  -  zipstream-php/test/FaultInjectionResource.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

class FaultInjectionResource
{
    public const NAME = 'zipstream-php-test-broken-resource';

    /** @var resource */
    public $context;

    private array $injectFaults;

    private string $mode;

    /**
     * @return resource
     */
    public static function getResource(array $injectFaults)
    {
        self::register();

        return fopen(self::NAME . '://foobar', 'rw+', false, self::createStreamContext($injectFaults));
    }

    public function stream_open(string $path, string $mode, int $options, string &$opened_path = null): bool
    {
        $options = stream_context_get_options($this->context);

        if (!isset($options[self::NAME]['injectFaults'])) {
            return false;
        }

        $this->mode = $mode;
        $this->injectFaults = $options[self::NAME]['injectFaults'];

        if ($this->shouldFail(__FUNCTION__)) {
            return false;
        }

        return true;
    }

    public function stream_write(string $data)
    {
        if ($this->shouldFail(__FUNCTION__)) {
            return false;
        }
        return true;
    }

    public function stream_eof()
    {
        return true;
    }

    public function stream_seek(int $offset, int $whence): bool
    {
        if ($this->shouldFail(__FUNCTION__)) {
            return false;
        }

        return true;
    }

    public function stream_tell(): int
    {
        if ($this->shouldFail(__FUNCTION__)) {
            return false;
        }

        return 0;
    }

    public static function register(): void
    {
        if (!in_array(self::NAME, stream_get_wrappers(), true)) {
            stream_wrapper_register(self::NAME, __CLASS__);
        }
    }

    public function stream_stat(): array
    {
        static $modeMap = [
            'r'  => 33060,
            'rb' => 33060,
            'r+' => 33206,
            'w'  => 33188,
            'wb' => 33188,
        ];

        return [
            'dev'     => 0,
            'ino'     => 0,
            'mode'    => $modeMap[$this->mode],
            'nlink'   => 0,
            'uid'     => 0,
            'gid'     => 0,
            'rdev'    => 0,
            'size'    => 0,
            'atime'   => 0,
            'mtime'   => 0,
            'ctime'   => 0,
            'blksize' => 0,
            'blocks'  => 0,
        ];
    }

    public function url_stat(string $path, int $flags): array
    {
        return [
            'dev'     => 0,
            'ino'     => 0,
            'mode'    => 0,
            'nlink'   => 0,
            'uid'     => 0,
            'gid'     => 0,
            'rdev'    => 0,
            'size'    => 0,
            'atime'   => 0,
            'mtime'   => 0,
            'ctime'   => 0,
            'blksize' => 0,
            'blocks'  => 0,
        ];
    }

    private static function createStreamContext(array $injectFaults)
    {
        return stream_context_create([
            self::NAME => ['injectFaults' => $injectFaults],
        ]);
    }

    private function shouldFail(string $function): bool
    {
        return in_array($function, $this->injectFaults, true);
    }
}
PK     V_]“=    !  zipstream-php/test/Assertions.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

trait Assertions
{
    protected function assertFileContains(string $filePath, string $needle): void
    {
        $last = '';

        $handle = fopen($filePath, 'r');
        while (!feof($handle)) {
            $line = fgets($handle, 1024);

            if (str_contains($last . $line, $needle)) {
                fclose($handle);
                return;
            }

            $last = $line;
        }

        fclose($handle);

        $this->fail("File {$filePath} must contain {$needle}");
    }

    protected function assertFileDoesNotContain(string $filePath, string $needle): void
    {
        $last = '';

        $handle = fopen($filePath, 'r');
        while (!feof($handle)) {
            $line = fgets($handle, 1024);

            if (str_contains($last . $line, $needle)) {
                fclose($handle);

                $this->fail("File {$filePath} must not contain {$needle}");
            }

            $last = $line;
        }

        fclose($handle);
    }
}
PK     V_]tÅÿJ  J    zipstream-php/test/Tempfile.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

trait Tempfile
{
    protected string|null $tempfile;

    /**
     * @var resource
     */
    protected $tempfileStream;

    protected function setUp(): void
    {
        [$tempfile, $tempfileStream] = $this->getTmpFileStream();

        $this->tempfile = $tempfile;
        $this->tempfileStream = $tempfileStream;
    }

    protected function tearDown(): void
    {
        unlink($this->tempfile);
        if (is_resource($this->tempfileStream)) {
            fclose($this->tempfileStream);
        }

        $this->tempfile = null;
        $this->tempfileStream = null;
    }

    protected function getTmpFileStream(): array
    {
        $tmp = tempnam(sys_get_temp_dir(), 'zipstreamtest');
        $stream = fopen($tmp, 'wb+');

        return [$tmp, $stream];
    }
}
PK     V_]k­Ÿ­Þ“  Þ“  $  zipstream-php/test/ZipStreamTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use DateTimeImmutable;
use GuzzleHttp\Psr7\Response;
use GuzzleHttp\Psr7\StreamWrapper;
use org\bovigo\vfs\vfsStream;
use PHPUnit\Framework\TestCase;
use Psr\Http\Message\StreamInterface;
use RuntimeException;
use ZipArchive;
use ZipStream\CompressionMethod;
use ZipStream\Exception\FileNotFoundException;
use ZipStream\Exception\FileNotReadableException;
use ZipStream\Exception\FileSizeIncorrectException;
use ZipStream\Exception\OverflowException;
use ZipStream\Exception\ResourceActionException;
use ZipStream\Exception\SimulationFileUnknownException;
use ZipStream\Exception\StreamNotReadableException;
use ZipStream\Exception\StreamNotSeekableException;
use ZipStream\OperationMode;
use ZipStream\PackField;
use ZipStream\ZipStream;

class ZipStreamTest extends TestCase
{
    use Util;
    use Assertions;
    use Tempfile;

    public function testAddFile(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $zip->addFile('sample.txt', 'Sample String Data');
        $zip->addFile('test/sample.txt', 'More Simple Sample Data');

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.txt', 'test' . DIRECTORY_SEPARATOR . 'sample.txt'], $files);

        $this->assertStringEqualsFile($tmpDir . '/sample.txt', 'Sample String Data');
        $this->assertStringEqualsFile($tmpDir . '/test/sample.txt', 'More Simple Sample Data');
    }

    public function testAddFileUtf8NameComment(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $name = 'Ã¡rvÃ­ztÅ±rÅ‘ tÃ¼kÃ¶rfÃºrÃ³gÃ©p.txt';
        $content = 'Sample String Data';
        $comment =
            'Filename has every special characters ' .
            'from Hungarian language in lowercase. ' .
            'In uppercase: ÃÃÅ°ÅÃœÃ–ÃšÃ“Ã‰';

        $zip->addFile(fileName: $name, data: $content, comment: $comment);
        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame([$name], $files);
        $this->assertStringEqualsFile($tmpDir . '/' . $name, $content);

        $zipArchive = new ZipArchive();
        $zipArchive->open($this->tempfile);
        $this->assertSame($comment, $zipArchive->getCommentName($name));
    }

    public function testAddFileUtf8NameNonUtfComment(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $name = 'Ã¡.txt';
        $content = 'any';
        $comment = mb_convert_encoding('Ã¡', 'ISO-8859-2', 'UTF-8');

        // @see https://libzip.org/documentation/zip_file_get_comment.html
        //
        // mb_convert_encoding hasn't CP437.
        // nearly CP850 (DOS-Latin-1)
        $guessComment = mb_convert_encoding($comment, 'UTF-8', 'CP850');

        $zip->addFile(fileName: $name, data: $content, comment: $comment);

        $zip->finish();

        $zipArch = new ZipArchive();
        $zipArch->open($this->tempfile);
        $this->assertSame($guessComment, $zipArch->getCommentName($name));
        $this->assertSame($comment, $zipArch->getCommentName($name, ZipArchive::FL_ENC_RAW));
    }

    public function testAddFileWithStorageMethod(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $zip->addFile(fileName: 'sample.txt', data: 'Sample String Data', compressionMethod: CompressionMethod::STORE);
        $zip->addFile(fileName: 'test/sample.txt', data: 'More Simple Sample Data');
        $zip->finish();

        $zipArchive = new ZipArchive();
        $zipArchive->open($this->tempfile);

        $sample1 = $zipArchive->statName('sample.txt');
        $sample12 = $zipArchive->statName('test/sample.txt');
        $this->assertSame($sample1['comp_method'], CompressionMethod::STORE->value);
        $this->assertSame($sample12['comp_method'], CompressionMethod::DEFLATE->value);

        $zipArchive->close();
    }

    public function testAddFileFromPath(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        [$tmpExample, $streamExample] = $this->getTmpFileStream();
        fwrite($streamExample, 'Sample String Data');
        fclose($streamExample);
        $zip->addFileFromPath(fileName: 'sample.txt', path: $tmpExample);

        [$tmpExample, $streamExample] = $this->getTmpFileStream();
        fwrite($streamExample, 'More Simple Sample Data');
        fclose($streamExample);
        $zip->addFileFromPath(fileName: 'test/sample.txt', path: $tmpExample);

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.txt', 'test' . DIRECTORY_SEPARATOR . 'sample.txt'], $files);

        $this->assertStringEqualsFile($tmpDir . '/sample.txt', 'Sample String Data');
        $this->assertStringEqualsFile($tmpDir . '/test/sample.txt', 'More Simple Sample Data');

        unlink($tmpExample);
    }

    public function testAddFileFromPathFileNotFoundException(): void
    {
        $this->expectException(FileNotFoundException::class);

        // Get ZipStream Object
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        // Trigger error by adding a file which doesn't exist
        $zip->addFileFromPath(fileName: 'foobar.php', path: '/foo/bar/foobar.php');
    }

    public function testAddFileFromPathFileNotReadableException(): void
    {
        $this->expectException(FileNotReadableException::class);

        // create new virtual filesystem
        $root = vfsStream::setup('vfs');
        // create a virtual file with no permissions
        $file = vfsStream::newFile('foo.txt', 0)->at($root)->setContent('bar');

        // Get ZipStream Object
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $zip->addFileFromPath('foo.txt', $file->url());
    }

    public function testAddFileFromPathWithStorageMethod(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        [$tmpExample, $streamExample] = $this->getTmpFileStream();
        fwrite($streamExample, 'Sample String Data');
        fclose($streamExample);
        $zip->addFileFromPath(fileName: 'sample.txt', path: $tmpExample, compressionMethod: CompressionMethod::STORE);

        [$tmpExample, $streamExample] = $this->getTmpFileStream();
        fwrite($streamExample, 'More Simple Sample Data');
        fclose($streamExample);
        $zip->addFileFromPath('test/sample.txt', $tmpExample);

        $zip->finish();

        $zipArchive = new ZipArchive();
        $zipArchive->open($this->tempfile);

        $sample1 = $zipArchive->statName('sample.txt');
        $this->assertSame(CompressionMethod::STORE->value, $sample1['comp_method']);

        $sample2 = $zipArchive->statName('test/sample.txt');
        $this->assertSame(CompressionMethod::DEFLATE->value, $sample2['comp_method']);

        $zipArchive->close();
    }

    public function testAddLargeFileFromPath(): void
    {
        foreach ([CompressionMethod::DEFLATE, CompressionMethod::STORE] as $compressionMethod) {
            foreach ([false, true] as $zeroHeader) {
                foreach ([false, true] as $zip64) {
                    if ($zeroHeader && $compressionMethod === CompressionMethod::DEFLATE) {
                        continue;
                    }
                    $this->addLargeFileFileFromPath(
                        compressionMethod: $compressionMethod,
                        zeroHeader: $zeroHeader,
                        zip64: $zip64
                    );
                }
            }
        }
    }

    public function testAddFileFromStream(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        // In this test we can't use temporary stream to feed data
        // because zlib.deflate filter gives empty string before PHP 7
        // it works fine with file stream
        $streamExample = fopen(__FILE__, 'rb');
        $zip->addFileFromStream('sample.txt', $streamExample);
        fclose($streamExample);

        $streamExample2 = fopen('php://temp', 'wb+');
        fwrite($streamExample2, 'More Simple Sample Data');
        rewind($streamExample2); // move the pointer back to the beginning of file.
        $zip->addFileFromStream('test/sample.txt', $streamExample2); //, $fileOptions);
        fclose($streamExample2);

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.txt', 'test' . DIRECTORY_SEPARATOR . 'sample.txt'], $files);

        $this->assertStringEqualsFile(__FILE__, file_get_contents($tmpDir . '/sample.txt'));
        $this->assertStringEqualsFile($tmpDir . '/test/sample.txt', 'More Simple Sample Data');
    }

    public function testAddFileFromStreamUnreadableInput(): void
    {
        $this->expectException(StreamNotReadableException::class);

        [$tmpInput] = $this->getTmpFileStream();

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $streamUnreadable = fopen($tmpInput, 'w');

        $zip->addFileFromStream('sample.json', $streamUnreadable);
    }

    public function testAddFileFromStreamBrokenOutputWrite(): void
    {
        $this->expectException(ResourceActionException::class);

        $outputStream = FaultInjectionResource::getResource(['stream_write']);

        $zip = new ZipStream(
            outputStream: $outputStream,
            sendHttpHeaders: false,
        );

        $zip->addFile('sample.txt', 'foobar');
    }

    public function testAddFileFromStreamBrokenInputRewind(): void
    {
        $this->expectException(ResourceActionException::class);

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            defaultEnableZeroHeader: false,
        );

        $fileStream = FaultInjectionResource::getResource(['stream_seek']);

        $zip->addFileFromStream('sample.txt', $fileStream, maxSize: 0);
    }

    public function testAddFileFromStreamUnseekableInputWithoutZeroHeader(): void
    {
        $this->expectException(StreamNotSeekableException::class);

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            defaultEnableZeroHeader: false,
        );

        if (file_exists('/dev/null')) {
            $streamUnseekable = fopen('/dev/null', 'w+');
        } elseif (file_exists('NUL')) {
            $streamUnseekable = fopen('NUL', 'w+');
        } else {
            $this->markTestSkipped('Needs file /dev/null');
        }

        $zip->addFileFromStream('sample.txt', $streamUnseekable, maxSize: 2);
    }

    public function testAddFileFromStreamUnseekableInputWithZeroHeader(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            defaultEnableZeroHeader: true,
            defaultCompressionMethod: CompressionMethod::STORE,
        );

        $streamUnseekable = StreamWrapper::getResource(new class ('test') extends EndlessCycleStream {
            public function isSeekable(): bool
            {
                return false;
            }

            public function seek(int $offset, int $whence = SEEK_SET): void
            {
                throw new RuntimeException('Not seekable');
            }
        });

        $zip->addFileFromStream('sample.txt', $streamUnseekable, maxSize: 7);

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.txt'], $files);

        $this->assertSame(filesize($tmpDir . '/sample.txt'), 7);
    }

    public function testAddFileFromStreamWithStorageMethod(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $streamExample = fopen('php://temp', 'wb+');
        fwrite($streamExample, 'Sample String Data');
        rewind($streamExample); // move the pointer back to the beginning of file.
        $zip->addFileFromStream('sample.txt', $streamExample, compressionMethod: CompressionMethod::STORE);
        fclose($streamExample);

        $streamExample2 = fopen('php://temp', 'bw+');
        fwrite($streamExample2, 'More Simple Sample Data');
        rewind($streamExample2); // move the pointer back to the beginning of file.
        $zip->addFileFromStream('test/sample.txt', $streamExample2, compressionMethod: CompressionMethod::DEFLATE);
        fclose($streamExample2);

        $zip->finish();

        $zipArchive = new ZipArchive();
        $zipArchive->open($this->tempfile);

        $sample1 = $zipArchive->statName('sample.txt');
        $this->assertSame(CompressionMethod::STORE->value, $sample1['comp_method']);

        $sample2 = $zipArchive->statName('test/sample.txt');
        $this->assertSame(CompressionMethod::DEFLATE->value, $sample2['comp_method']);

        $zipArchive->close();
    }

    public function testAddFileFromPsr7Stream(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $body = 'Sample String Data';
        $response = new Response(200, [], $body);

        $zip->addFileFromPsr7Stream('sample.json', $response->getBody());
        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.json'], $files);
        $this->assertStringEqualsFile($tmpDir . '/sample.json', $body);
    }

    /**
     * @group slow
     */
    public function testAddLargeFileFromPsr7Stream(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: true,
        );

        $zip->addFileFromPsr7Stream(
            fileName: 'sample.json',
            stream: new EndlessCycleStream('0'),
            maxSize: 0x100000000,
            compressionMethod: CompressionMethod::STORE,
            lastModificationDateTime: new DateTimeImmutable('2022-01-01 01:01:01Z'),
        );
        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.json'], $files);
        $this->assertFileIsReadable($tmpDir . '/sample.json');
        $this->assertStringStartsWith('000000', file_get_contents(filename: $tmpDir . '/sample.json', length: 20));
    }

    public function testContinueFinishedZip(): void
    {
        $this->expectException(RuntimeException::class);

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );
        $zip->finish();

        $zip->addFile('sample.txt', '1234');
    }

    /**
     * @group slow
     */
    public function testManyFilesWithoutZip64(): void
    {
        $this->expectException(OverflowException::class);

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: false,
        );

        for ($i = 0; $i <= 0xFFFF; $i++) {
            $zip->addFile('sample' . $i, '');
        }

        $zip->finish();
    }

    /**
     * @group slow
     */
    public function testManyFilesWithZip64(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: true,
        );

        for ($i = 0; $i <= 0xFFFF; $i++) {
            $zip->addFile('sample' . $i, '');
        }

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);

        $this->assertSame(count($files), 0x10000);
    }

    /**
     * @group slow
     */
    public function testLongZipWithout64(): void
    {
        $this->expectException(OverflowException::class);

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: false,
            defaultCompressionMethod: CompressionMethod::STORE,
        );

        for ($i = 0; $i < 4; $i++) {
            $zip->addFileFromPsr7Stream(
                fileName: 'sample' . $i,
                stream: new EndlessCycleStream('0'),
                maxSize: 0xFFFFFFFF,
                compressionMethod: CompressionMethod::STORE,
                lastModificationDateTime: new DateTimeImmutable('2022-01-01 01:01:01Z'),
            );
        }
    }

    /**
     * @group slow
     */
    public function testLongZipWith64(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: true,
            defaultCompressionMethod: CompressionMethod::STORE,
        );

        for ($i = 0; $i < 4; $i++) {
            $zip->addFileFromPsr7Stream(
                fileName: 'sample' . $i,
                stream: new EndlessCycleStream('0'),
                maxSize: 0x5FFFFFFF,
                compressionMethod: CompressionMethod::STORE,
                lastModificationDateTime: new DateTimeImmutable('2022-01-01 01:01:01Z'),
            );
        }

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample0', 'sample1', 'sample2', 'sample3'], $files);
    }

    /**
     * @group slow
     */
    public function testAddLargeFileWithoutZip64WithZeroHeader(): void
    {
        $this->expectException(OverflowException::class);

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: false,
            defaultEnableZeroHeader: true,
        );

        $zip->addFileFromPsr7Stream(
            fileName: 'sample.json',
            stream: new EndlessCycleStream('0'),
            maxSize: 0x100000000,
            compressionMethod: CompressionMethod::STORE,
            lastModificationDateTime: new DateTimeImmutable('2022-01-01 01:01:01Z'),
        );
    }

    /**
     * @group slow
     */
    public function testAddsZip64HeaderWhenNeeded(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: true,
            defaultEnableZeroHeader: false,
        );

        $zip->addFileFromPsr7Stream(
            fileName: 'sample.json',
            stream: new EndlessCycleStream('0'),
            maxSize: 0x100000000,
            compressionMethod: CompressionMethod::STORE,
            lastModificationDateTime: new DateTimeImmutable('2022-01-01 01:01:01Z'),
        );

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);
        $files = $this->getRecursiveFileList($tmpDir);

        $this->assertSame(['sample.json'], $files);
        $this->assertFileContains($this->tempfile, PackField::pack(
            new PackField(format: 'V', value: 0x06064b50)
        ));
    }

    /**
     * @group slow
     */
    public function testDoesNotAddZip64HeaderWhenNotNeeded(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: true,
            defaultEnableZeroHeader: false,
        );

        $zip->addFileFromPsr7Stream(
            fileName: 'sample.json',
            stream: new EndlessCycleStream('0'),
            maxSize: 0x10,
            compressionMethod: CompressionMethod::STORE,
            lastModificationDateTime: new DateTimeImmutable('2022-01-01 01:01:01Z'),
        );

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);
        $files = $this->getRecursiveFileList($tmpDir);

        $this->assertSame(['sample.json'], $files);
        $this->assertFileDoesNotContain($this->tempfile, PackField::pack(
            new PackField(format: 'V', value: 0x06064b50)
        ));
    }

    /**
     * @group slow
     */
    public function testAddLargeFileWithoutZip64WithoutZeroHeader(): void
    {
        $this->expectException(OverflowException::class);

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
            enableZip64: false,
            defaultEnableZeroHeader: false,
        );

        $zip->addFileFromPsr7Stream(
            fileName: 'sample.json',
            stream: new EndlessCycleStream('0'),
            maxSize: 0x100000000,
            compressionMethod: CompressionMethod::STORE,
            lastModificationDateTime: new DateTimeImmutable('2022-01-01 01:01:01Z'),
        );
    }

    public function testAddFileFromPsr7StreamWithOutputToPsr7Stream(): void
    {
        $psr7OutputStream = new ResourceStream($this->tempfileStream);

        $zip = new ZipStream(
            outputStream: $psr7OutputStream,
            sendHttpHeaders: false,
        );

        $body = 'Sample String Data';
        $response = new Response(200, [], $body);

        $zip->addFileFromPsr7Stream(
            fileName: 'sample.json',
            stream: $response->getBody(),
            compressionMethod: CompressionMethod::STORE,
        );
        $zip->finish();
        $psr7OutputStream->close();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);
        $files = $this->getRecursiveFileList($tmpDir);

        $this->assertSame(['sample.json'], $files);
        $this->assertStringEqualsFile($tmpDir . '/sample.json', $body);
    }

    public function testAddFileFromPsr7StreamWithFileSizeSet(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $body = 'Sample String Data';
        $fileSize = strlen($body);
        // Add fake padding
        $fakePadding = "\0\0\0\0\0\0";
        $response = new Response(200, [], $body . $fakePadding);

        $zip->addFileFromPsr7Stream(
            fileName: 'sample.json',
            stream: $response->getBody(),
            compressionMethod: CompressionMethod::STORE,
            maxSize: $fileSize
        );
        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.json'], $files);
        $this->assertStringEqualsFile($tmpDir . '/sample.json', $body);
    }

    public function testCreateArchiveHeaders(): void
    {
        $headers = [];

        $httpHeaderCallback = function (string $header) use (&$headers) {
            $headers[] = $header;
        };

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: true,
            outputName: 'example.zip',
            httpHeaderCallback: $httpHeaderCallback,
        );

        $zip->addFile(
            fileName: 'sample.json',
            data: 'foo',
        );
        $zip->finish();

        $this->assertContains('Content-Type: application/x-zip', $headers);
        $this->assertContains("Content-Disposition: attachment; filename*=UTF-8''example.zip", $headers);
        $this->assertContains('Pragma: public', $headers);
        $this->assertContains('Cache-Control: public, must-revalidate', $headers);
        $this->assertContains('Content-Transfer-Encoding: binary', $headers);
    }

    public function testCreateArchiveWithFlushOptionSet(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            flushOutput: true,
            sendHttpHeaders: false,
        );

        $zip->addFile('sample.txt', 'Sample String Data');
        $zip->addFile('test/sample.txt', 'More Simple Sample Data');

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.txt', 'test' . DIRECTORY_SEPARATOR . 'sample.txt'], $files);

        $this->assertStringEqualsFile($tmpDir . '/sample.txt', 'Sample String Data');
        $this->assertStringEqualsFile($tmpDir . '/test/sample.txt', 'More Simple Sample Data');
    }

    public function testCreateArchiveWithOutputBufferingOffAndFlushOptionSet(): void
    {
        // WORKAROUND (1/2): remove phpunit's output buffer in order to run test without any buffering
        ob_end_flush();
        $this->assertSame(0, ob_get_level());

        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            flushOutput: true,
            sendHttpHeaders: false,
        );

        $zip->addFile('sample.txt', 'Sample String Data');

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);
        $this->assertStringEqualsFile($tmpDir . '/sample.txt', 'Sample String Data');

        // WORKAROUND (2/2): add back output buffering so that PHPUnit doesn't complain that it is missing
        ob_start();
    }

    public function testAddEmptyDirectory(): void
    {
        $zip = new ZipStream(
            outputStream: $this->tempfileStream,
            sendHttpHeaders: false,
        );

        $zip->addDirectory('foo');

        $zip->finish();

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir, includeDirectories: true);

        $this->assertContains('foo', $files);

        $this->assertFileExists($tmpDir . DIRECTORY_SEPARATOR . 'foo');
        $this->assertDirectoryExists($tmpDir . DIRECTORY_SEPARATOR . 'foo');
    }

    public function testAddFileSimulate(): void
    {
        $create = function (OperationMode $operationMode): int {
            $zip = new ZipStream(
                sendHttpHeaders: false,
                operationMode: $operationMode,
                defaultEnableZeroHeader: true,
                outputStream: $this->tempfileStream,
            );

            $zip->addFile('sample.txt', 'Sample String Data');
            $zip->addFile('test/sample.txt', 'More Simple Sample Data');

            return $zip->finish();
        };


        $sizeExpected = $create(OperationMode::NORMAL);
        $sizeActual = $create(OperationMode::SIMULATE_LAX);

        $this->assertEquals($sizeExpected, $sizeActual);
    }

    public function testAddFileSimulateWithMaxSize(): void
    {
        $create = function (OperationMode $operationMode): int {
            $zip = new ZipStream(
                sendHttpHeaders: false,
                operationMode: $operationMode,
                defaultCompressionMethod: CompressionMethod::STORE,
                defaultEnableZeroHeader: true,
                outputStream: $this->tempfileStream,
            );

            $zip->addFile('sample.txt', 'Sample String Data', maxSize: 0);

            return $zip->finish();
        };


        $sizeExpected = $create(OperationMode::NORMAL);
        $sizeActual = $create(OperationMode::SIMULATE_LAX);

        $this->assertEquals($sizeExpected, $sizeActual);
    }

    public function testAddFileSimulateWithFstat(): void
    {
        $create = function (OperationMode $operationMode): int {
            $zip = new ZipStream(
                sendHttpHeaders: false,
                operationMode: $operationMode,
                defaultCompressionMethod: CompressionMethod::STORE,
                defaultEnableZeroHeader: true,
                outputStream: $this->tempfileStream,
            );

            $zip->addFile('sample.txt', 'Sample String Data');
            $zip->addFile('test/sample.txt', 'More Simple Sample Data');

            return $zip->finish();
        };


        $sizeExpected = $create(OperationMode::NORMAL);
        $sizeActual = $create(OperationMode::SIMULATE_LAX);

        $this->assertEquals($sizeExpected, $sizeActual);
    }

    public function testAddFileSimulateWithExactSizeZero(): void
    {
        $create = function (OperationMode $operationMode): int {
            $zip = new ZipStream(
                sendHttpHeaders: false,
                operationMode: $operationMode,
                defaultCompressionMethod: CompressionMethod::STORE,
                defaultEnableZeroHeader: true,
                outputStream: $this->tempfileStream,
            );

            $zip->addFile('sample.txt', 'Sample String Data', exactSize: 18);

            return $zip->finish();
        };


        $sizeExpected = $create(OperationMode::NORMAL);
        $sizeActual = $create(OperationMode::SIMULATE_LAX);

        $this->assertEquals($sizeExpected, $sizeActual);
    }

    public function testAddFileSimulateWithExactSizeInitial(): void
    {
        $create = function (OperationMode $operationMode): int {
            $zip = new ZipStream(
                sendHttpHeaders: false,
                operationMode: $operationMode,
                defaultCompressionMethod: CompressionMethod::STORE,
                defaultEnableZeroHeader: false,
                outputStream: $this->tempfileStream,
            );

            $zip->addFile('sample.txt', 'Sample String Data', exactSize: 18);

            return $zip->finish();
        };

        $sizeExpected = $create(OperationMode::NORMAL);
        $sizeActual = $create(OperationMode::SIMULATE_LAX);

        $this->assertEquals($sizeExpected, $sizeActual);
    }

    public function testAddFileSimulateWithZeroSizeInFstat(): void
    {
        $create = function (OperationMode $operationMode): int {
            $zip = new ZipStream(
                sendHttpHeaders: false,
                operationMode: $operationMode,
                defaultCompressionMethod: CompressionMethod::STORE,
                defaultEnableZeroHeader: false,
                outputStream: $this->tempfileStream,
            );

            $zip->addFileFromPsr7Stream('sample.txt', new class implements StreamInterface {
                public $pos = 0;

                public function __toString(): string
                {
                    return 'test';
                }

                public function close(): void {}

                public function detach() {}

                public function getSize(): ?int
                {
                    return null;
                }

                public function tell(): int
                {
                    return $this->pos;
                }

                public function eof(): bool
                {
                    return $this->pos >= 4;
                }

                public function isSeekable(): bool
                {
                    return true;
                }

                public function seek(int $offset, int $whence = SEEK_SET): void
                {
                    $this->pos = $offset;
                }

                public function rewind(): void
                {
                    $this->pos = 0;
                }

                public function isWritable(): bool
                {
                    return false;
                }

                public function write(string $string): int
                {
                    return 0;
                }

                public function isReadable(): bool
                {
                    return true;
                }

                public function read(int $length): string
                {
                    $data = substr('test', $this->pos, $length);
                    $this->pos += strlen($data);
                    return $data;
                }

                public function getContents(): string
                {
                    return $this->read(4);
                }

                public function getMetadata(?string $key = null)
                {
                    return $key !== null ? null : [];
                }
            });

            return $zip->finish();
        };

        $sizeExpected = $create(OperationMode::NORMAL);
        $sizeActual = $create(OperationMode::SIMULATE_LAX);


        $this->assertEquals($sizeExpected, $sizeActual);
    }

    public function testAddFileSimulateWithWrongExactSize(): void
    {
        $this->expectException(FileSizeIncorrectException::class);

        $zip = new ZipStream(
            sendHttpHeaders: false,
            operationMode: OperationMode::SIMULATE_LAX,
        );

        $zip->addFile('sample.txt', 'Sample String Data', exactSize: 1000);
    }

    public function testAddFileSimulateStrictZero(): void
    {
        $this->expectException(SimulationFileUnknownException::class);

        $zip = new ZipStream(
            sendHttpHeaders: false,
            operationMode: OperationMode::SIMULATE_STRICT,
            defaultEnableZeroHeader: true
        );

        $zip->addFile('sample.txt', 'Sample String Data');
    }

    public function testAddFileSimulateStrictInitial(): void
    {
        $this->expectException(SimulationFileUnknownException::class);

        $zip = new ZipStream(
            sendHttpHeaders: false,
            operationMode: OperationMode::SIMULATE_STRICT,
            defaultEnableZeroHeader: false
        );

        $zip->addFile('sample.txt', 'Sample String Data');
    }

    public function testAddFileCallbackStrict(): void
    {
        $this->expectException(SimulationFileUnknownException::class);

        $zip = new ZipStream(
            sendHttpHeaders: false,
            operationMode: OperationMode::SIMULATE_STRICT,
            defaultEnableZeroHeader: false
        );

        $zip->addFileFromCallback('sample.txt', callback: function () {
            return '';
        });
    }

    public function testAddFileCallbackLax(): void
    {
        $zip = new ZipStream(
            operationMode: OperationMode::SIMULATE_LAX,
            defaultEnableZeroHeader: false,
            sendHttpHeaders: false,
        );

        $zip->addFileFromCallback('sample.txt', callback: function () {
            return 'Sample String Data';
        });

        $size = $zip->finish();

        $this->assertEquals($size, 142);
    }

    public function testExecuteSimulation(): void
    {
        $zip = new ZipStream(
            operationMode: OperationMode::SIMULATE_STRICT,
            defaultCompressionMethod: CompressionMethod::STORE,
            defaultEnableZeroHeader: false,
            sendHttpHeaders: false,
            outputStream: $this->tempfileStream,
        );

        $zip->addFileFromCallback(
            'sample.txt',
            exactSize: 18,
            callback: function () {
                return 'Sample String Data';
            }
        );

        $zip->addFileFromCallback(
            '.gitkeep',
            exactSize: 0,
            callback: function () {
                return '';
            }
        );

        $size = $zip->finish();

        $this->assertEquals(filesize($this->tempfile), 0);

        $zip->executeSimulation();

        clearstatcache();

        $this->assertEquals(filesize($this->tempfile), $size);

        $tmpDir = $this->validateAndExtractZip($this->tempfile);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['.gitkeep', 'sample.txt'], $files);
    }

    public function testExecuteSimulationBeforeFinish(): void
    {
        $this->expectException(RuntimeException::class);

        $zip = new ZipStream(
            operationMode: OperationMode::SIMULATE_LAX,
            defaultEnableZeroHeader: false,
            sendHttpHeaders: false,
            outputStream: $this->tempfileStream,
        );

        $zip->executeSimulation();
    }

    private function addLargeFileFileFromPath(CompressionMethod $compressionMethod, $zeroHeader, $zip64): void
    {
        [$tmp, $stream] = $this->getTmpFileStream();

        $zip = new ZipStream(
            outputStream: $stream,
            sendHttpHeaders: false,
            defaultEnableZeroHeader: $zeroHeader,
            enableZip64: $zip64,
        );

        [$tmpExample, $streamExample] = $this->getTmpFileStream();
        for ($i = 0; $i <= 10000; $i++) {
            fwrite($streamExample, sha1((string) $i));
            if ($i % 100 === 0) {
                fwrite($streamExample, "\n");
            }
        }
        fclose($streamExample);
        $shaExample = sha1_file($tmpExample);
        $zip->addFileFromPath('sample.txt', $tmpExample);
        unlink($tmpExample);

        $zip->finish();
        fclose($stream);

        $tmpDir = $this->validateAndExtractZip($tmp);

        $files = $this->getRecursiveFileList($tmpDir);
        $this->assertSame(['sample.txt'], $files);

        $this->assertSame(sha1_file($tmpDir . '/sample.txt'), $shaExample, "SHA-1 Mismatch Method: {$compressionMethod->value}");

        unlink($tmp);
    }
}
PK     V_]ba=z®  ®  $  zipstream-php/test/PackFieldTest.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use PHPUnit\Framework\TestCase;
use RuntimeException;
use ZipStream\PackField;

class PackFieldTest extends TestCase
{
    public function testPacksFields(): void
    {
        $this->assertSame(
            bin2hex(PackField::pack(new PackField(format: 'v', value: 0x1122))),
            '2211',
        );
    }

    public function testOverflow2(): void
    {
        $this->expectException(RuntimeException::class);

        PackField::pack(new PackField(format: 'v', value: 0xFFFFF));
    }

    public function testOverflow4(): void
    {
        $this->expectException(RuntimeException::class);

        PackField::pack(new PackField(format: 'V', value: 0xFFFFFFFFF));
    }

    public function testUnknownOperator(): void
    {
        $this->assertSame(
            bin2hex(PackField::pack(new PackField(format: 'a', value: 0x1122))),
            '34',
        );
    }
}
PK     V_]²ÌÊÙq  q  %  zipstream-php/test/ResourceStream.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Test;

use Psr\Http\Message\StreamInterface;
use RuntimeException;

/**
 * @internal
 */
class ResourceStream implements StreamInterface
{
    public function __construct(
        /**
         * @var resource
         */
        private $stream
    ) {}

    public function __toString(): string
    {
        if ($this->isSeekable()) {
            $this->seek(0);
        }
        return (string) stream_get_contents($this->stream);
    }

    public function close(): void
    {
        $stream = $this->detach();
        if ($stream) {
            fclose($stream);
        }
    }

    public function detach()
    {
        $result = $this->stream;
        // According to the interface, the stream is left in an unusable state;
        /** @psalm-suppress PossiblyNullPropertyAssignmentValue */
        $this->stream = null;
        return $result;
    }

    public function seek(int $offset, int $whence = SEEK_SET): void
    {
        if (!$this->isSeekable()) {
            throw new RuntimeException();
        }
        if (fseek($this->stream, $offset, $whence) !== 0) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException();
            // @codeCoverageIgnoreEnd
        }
    }

    public function isSeekable(): bool
    {
        return (bool) $this->getMetadata('seekable');
    }

    public function getMetadata(?string $key = null)
    {
        $metadata = stream_get_meta_data($this->stream);
        return $key !== null ? @$metadata[$key] : $metadata;
    }

    public function getSize(): ?int
    {
        $stats = fstat($this->stream);
        return $stats['size'];
    }

    public function tell(): int
    {
        $position = ftell($this->stream);
        if ($position === false) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException();
            // @codeCoverageIgnoreEnd
        }
        return $position;
    }

    public function eof(): bool
    {
        return feof($this->stream);
    }

    public function rewind(): void
    {
        $this->seek(0);
    }

    public function write(string $string): int
    {
        if (!$this->isWritable()) {
            throw new RuntimeException();
        }
        if (fwrite($this->stream, $string) === false) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException();
            // @codeCoverageIgnoreEnd
        }
        return strlen($string);
    }

    public function isWritable(): bool
    {
        $mode = $this->getMetadata('mode');
        if (!is_string($mode)) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException('Could not get stream mode from metadata!');
            // @codeCoverageIgnoreEnd
        }
        return preg_match('/[waxc+]/', $mode) === 1;
    }

    public function read(int $length): string
    {
        if (!$this->isReadable()) {
            throw new RuntimeException();
        }
        $result = fread($this->stream, $length);
        if ($result === false) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException();
            // @codeCoverageIgnoreEnd
        }
        return $result;
    }

    public function isReadable(): bool
    {
        $mode = $this->getMetadata('mode');
        if (!is_string($mode)) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException('Could not get stream mode from metadata!');
            // @codeCoverageIgnoreEnd
        }
        return preg_match('/[r+]/', $mode) === 1;
    }

    public function getContents(): string
    {
        if (!$this->isReadable()) {
            throw new RuntimeException();
        }
        $result = stream_get_contents($this->stream);
        if ($result === false) {
            // @codeCoverageIgnoreStart
            throw new RuntimeException();
            // @codeCoverageIgnoreEnd
        }
        return $result;
    }
}
PK     V_]EµÆ   Æ     zipstream-php/.phive/phars.xmlnu „[µü¤        <?xml version="1.0" encoding="UTF-8"?>
<phive xmlns="https://phar.io/phive">
  <phar name="phpdocumentor" version="^3.3.1" installed="3.4.3" location="./tools/phpdocumentor" copy="false"/>
</phive>
PK     V_]ÃnÀt‡  ‡  ;  zipstream-php/.github/PULL_REQUEST_TEMPLATE/FAILING_TEST.mdnu „[µü¤        <!---
name: ðŸž Failing Test
about: You found a bug and have a failing test?
labels: bug, tests
--->

<!--
- Please do not send a pull request for an issue in a version of ZipStream-PHP
  that is no longer supported.
  See: https://github.com/maennchen/ZipStream-PHP#version-support
- Please target the oldest branch of ZipStream-PHP that is still supported and
  where the test fails.
-->
PK     V_]Txšl  l  2  zipstream-php/.github/PULL_REQUEST_TEMPLATE/FIX.mdnu „[µü¤        <!---
name: ðŸž Bug Fix
about: You have a fix for a bug?
labels: bug
--->

<!--
- Please do not send a pull request for an issue in a version of ZipStream-PHP
  that is no longer supported.
  See: https://github.com/maennchen/ZipStream-PHP#version-support
- Please target the oldest branch of ZipStream-PHP that is still supported and
  affected by this bug.
-->
PK     V_]–f Ñ   Ñ   :  zipstream-php/.github/PULL_REQUEST_TEMPLATE/NEW_FEATURE.mdnu „[µü¤        <!---
name: ðŸŽ‰ New Feature
about: You have implemented some neat idea that you want to make part of ZipStream-PHP?
labels: type/enhancement
--->

<!--
- Please target the `main` branch of ZipStream-PHP.
-->
PK     V_]‰a2´²   ²   :  zipstream-php/.github/PULL_REQUEST_TEMPLATE/IMPROVEMENT.mdnu „[µü¤        <!---
name: âš™ Improvement
about: You have some improvement to make ZipStream-PHP better?
labels: enhancement
--->

<!--
- Please target the `main` branch of ZipStream-PHP.
-->
PK     V_]<z*Èð  ð  ,  zipstream-php/.github/ISSUE_TEMPLATE/BUG.ymlnu „[µü¤        name: ðŸž Bug Report
description: Something is broken?
labels: ["bug"]
body:
  - type: markdown
    attributes:
      value: |
        - Create a discussion instead if you are looking for support:
          https://github.com/maennchen/ZipStream-PHP/discussions
  - type: input
    id: version
    attributes:
      label: ZipStream-PHP version
      placeholder: x.y.z
    validations:
      required: true
  - type: input
    id: php-version
    attributes:
      label: PHP version
      placeholder: x.y.z
    validations:
      required: true
  - type: checkboxes
    id: constraints
    attributes:
      label: Constraints for Bug Report
      options:
        - label: |
            I'm using a version of ZipStream that is currently supported:
            https://github.com/maennchen/ZipStream-PHP#version-support
          required: true
        - label: |
            I'm using a version of PHP that has active support:
            https://www.php.net/supported-versions.php
          required: true
        - label: |
            I'm using a version of PHP that is compatible with your used
            ZipStream version.
          required: true
        - label: |
            I'm using the latest release of the used ZipStream major version.
          required: true
  - type: textarea
    id: summary
    attributes:
      label: Summary
      description: Provide a summary describing the problem you are experiencing.
    validations:
      required: true
  - type: textarea
    id: current-behaviour
    attributes:
      label: Current behavior
      description: What is the current (buggy) behavior?
    validations:
      required: true
  - type: textarea
    id: reproduction
    attributes:
      label: How to reproduce
      description: Provide steps to reproduce the bug.
    validations:
      required: true
  - type: textarea
    id: expected-behaviour
    attributes:
      label: Expected behavior
      description: What was the expected (correct) behavior?
    validations:
      required: true
PK     V_].Q½ôD  D  0  zipstream-php/.github/ISSUE_TEMPLATE/FEATURE.ymlnu „[µü¤        name: ðŸŽ‰ Feature Request
description: You have a neat idea that should be implemented?
labels: ["enhancement"]
body:
  - type: textarea
    id: description
    attributes:
      label: Description
      description: Provide a summary of the feature you would like to see implemented.
    validations:
      required: true
PK     V_]#xÌéÜ  Ü  -  zipstream-php/.github/workflows/scorecard.ymlnu „[µü¤        # This workflow uses actions that are not certified by GitHub. They are provided
# by a third-party and are governed by separate terms of service, privacy
# policy, and support documentation.

name: Scorecard supply-chain security
on:
  # For Branch-Protection check. Only the default branch is supported. See
  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
  branch_protection_rule:
  # To guarantee Maintained check is occasionally updated. See
  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
  schedule:
    - cron: '28 11 * * 3'
  push:
    branches: [ "main" ]

# Declare default permissions as read only.
permissions: read-all

jobs:
  analysis:
    name: Scorecard analysis
    runs-on: ubuntu-latest
    permissions:
      # Needed to upload the results to code-scanning dashboard.
      security-events: write
      # Needed to publish results and get a badge (see publish_results below).
      id-token: write
      # Uncomment the permissions below if installing in a private repository.
      # contents: read
      # actions: read

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: "Checkout code"
        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
        with:
          persist-credentials: false

      - name: "Run analysis"
        uses: ossf/scorecard-action@62b2cac7ed8198b15735ed49ab1e5cf35480ba46 # v2.4.0
        with:
          results_file: results.sarif
          results_format: sarif
          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
          # - you want to enable the Branch-Protection check on a *public* repository, or
          # - you are installing Scorecard on a *private* repository
          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action?tab=readme-ov-file#authentication-with-fine-grained-pat-optional.
          # repo_token: ${{ secrets.SCORECARD_TOKEN }}

          # Public repositories:
          #   - Publish results to OpenSSF REST API for easy access by consumers
          #   - Allows the repository to include the Scorecard badge.
          #   - See https://github.com/ossf/scorecard-action#publishing-results.
          # For private repositories:
          #   - `publish_results` will always be set to `false`, regardless
          #     of the value entered here.
          publish_results: true

      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
      # format to the repository Actions tab.
      - name: "Upload artifact"
        uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4.4.1
        with:
          name: SARIF file
          path: results.sarif
          retention-days: 5

      # Upload the results to GitHub's code scanning dashboard (optional).
      # Commenting out will disable upload of results to your repo's Code Scanning dashboard
      - name: "Upload to code-scanning"
        uses: github/codeql-action/upload-sarif@c36620d31ac7c881962c3d9dd939c40ec9434f2b # v3.26.12
        with:
          sarif_file: results.sarif
PK     V_]C”	  	  .  zipstream-php/.github/workflows/tag-stable.ymlnu „[µü¤        on:
  push:
    tags:
      - "[0-9]+.[0-9]+.[0-9]+"

name: "Stable Tag"

permissions:
  contents: read

jobs:
  docs:
    name: "Docs"

    uses: ./.github/workflows/part_docs.yml

  release:
    name: "Release"

    needs: ["docs"]

    permissions:
      id-token: write
      contents: write
      attestations: write

    uses: ./.github/workflows/part_release.yml
    with:
      releaseName: "${{ github.ref_name }}"
      stable: true

  deploy_pages:
    name: "Deploy to GitHub Pages"

    needs: ["release", "docs"]

    runs-on: ubuntu-latest

    permissions:
      pages: write
      id-token: write

    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5
PK     V_]vÌ    -  zipstream-php/.github/workflows/part_docs.ymlnu „[µü¤        on:
  workflow_call: {}

name: "Documentation"

permissions:
  contents: read

jobs:
  generate:
    name: "Generate"

    runs-on: ubuntu-latest

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: Checkout Code
        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
      - name: SetUp PHP
        id: setup-php
        uses: shivammathur/setup-php@c541c155eee45413f5b09a52248675b1a2575231 # v2
        with:
          php-version: "8.3"
          tools: phive
      - name: Cache Tools
        uses: actions/cache@3624ceb22c1c5a301c8db4169662070a689d9ea8 # v4.1.1
        id: cache
        with:
          path: ~/.phive
          key: tools-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-${{ hashFiles('**/phars.xml') }}
          restore-keys: |
            tools-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-
            tools-${{ steps.setup-php.outputs.php-version }}-
            tools-
      - name: Install Tools
        run: composer run install:tools
      - name: Generate Docs
        run: composer run docs:generate
      - uses: actions/upload-artifact@604373da6381bf24206979c74d06a550515601b9 # v4.4.1
        with:
          name: docs
          path: docs
      - name: Package for GitHub Pages
        uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa # v3.0.1
        with:
          path: docs

PK     V_]Èº«  «  3  zipstream-php/.github/workflows/part_dependabot.ymlnu „[µü¤        on:
  workflow_call: {}

name: "Dependabot"

permissions:
  contents: read

jobs:
  automerge_dependabot:
    name: "Automerge PRs"

    runs-on: ubuntu-latest

    permissions:
      pull-requests: write
      contents: write

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - uses: fastify/github-action-merge-dependabot@3892334d1c649bb8119af3d22a3f3766bd5e593f # v3.10.2
        with:
          github-token: ${{ github.token }}
          use-github-auto-merge: true
          # Major Updates need to be merged manually
          target: minor
PK     V_]Ó}‘3C  C  -  zipstream-php/.github/workflows/part_test.ymlnu „[µü¤        on:
  workflow_call:

name: "Test"

permissions:
  contents: read

jobs:
  phpunit:
    name: PHPUnit (PHP ${{ matrix.php }} on ${{ matrix.os }})

    runs-on: ${{ matrix.os }}

    continue-on-error: ${{ matrix.experimental }}

    strategy:
      fail-fast: false
      matrix:
        php: ["8.1", "8.2", "8.3"]
        os: [ubuntu-latest]
        experimental: [false]
        include:
          - php: nightly
            os: ubuntu-latest
            experimental: true
          - php: "8.3"
            os: windows-latest
            experimental: false
          - php: "8.3"
            os: macos-latest
            experimental: false

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: Checkout Code
        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
      - name: SetUp PHP
        id: setup-php
        uses: shivammathur/setup-php@c541c155eee45413f5b09a52248675b1a2575231 # v2
        with:
          php-version: "${{ matrix.php }}"
          tools: phpunit
          coverage: xdebug
          extensions: xdebug,zip
      - name: Get composer cache directory
        id: composer-cache-common
        if: "${{ runner.os != 'Windows' }}"
        run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
      - name: Get composer cache directory
        id: composer-cache-windows
        if: "${{ runner.os == 'Windows' }}"
        run: echo "dir=$(composer config cache-files-dir)" >> $env:GITHUB_OUTPUT
      - name: Cache Deps
        uses: actions/cache@3624ceb22c1c5a301c8db4169662070a689d9ea8 # v4.1.1
        id: cache
        with:
          path: ${{ steps.composer-cache-common.outputs.dir }}${{ steps.composer-cache-windows.outputs.dir }}
          key: deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-composer-${{ hashFiles('**/composer.lock') }}
          restore-keys: |
            deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-composer-
            deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-
            deps-${{ steps.setup-php.outputs.php-version }}-
            deps-
      - name: Install Deps
        if: matrix.php != 'nightly'
        run: composer install --prefer-dist
      - name: Install Deps (ignore PHP requirement)
        if: matrix.php == 'nightly'
        run: composer install --prefer-dist --ignore-platform-req=php+
      - name: Run PHPUnit
        run: composer run test:unit
        env:
          XDEBUG_MODE: coverage
      - name: Upload coverage results to Coveralls
        env:
          COVERALLS_REPO_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          COVERALLS_PARALLEL: true
          COVERALLS_FLAG_NAME: ${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}
        run: composer run coverage:report
        continue-on-error: ${{ matrix.experimental }}

  mark_coverage_done:
    needs: ["phpunit"]

    runs-on: ubuntu-latest

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: Coveralls Finished
        uses: coverallsapp/github-action@643bc377ffa44ace6394b2b5d0d3950076de9f63 # v2.3.0
        with:
          github-token: ${{ secrets.github_token }}
          parallel-finished: true

  psalm:
    name: Run Psalm

    runs-on: "ubuntu-latest"

    permissions:
      security-events: write

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: Checkout Code
        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
      - name: SetUp PHP
        id: setup-php
        uses: shivammathur/setup-php@c541c155eee45413f5b09a52248675b1a2575231 # v2
        with:
          php-version: "8.3"
      - name: Get composer cache directory
        id: composer-cache
        run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
      - name: Cache Deps
        uses: actions/cache@3624ceb22c1c5a301c8db4169662070a689d9ea8 # v4.1.1
        id: cache
        with:
          path: ${{ steps.composer-cache.outputs.dir }}
          key: deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-composer-${{ hashFiles('**/composer.lock') }}
          restore-keys: |
            deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-composer-
            deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-
            deps-${{ steps.setup-php.outputs.php-version }}-
            deps-
      - name: Install Deps
        run: composer install --prefer-dist
      - name: Run Psalm
        run: composer run test:lint -- --report=results.sarif
      - name: "Upload SARIF"
        uses: github/codeql-action/upload-sarif@c36620d31ac7c881962c3d9dd939c40ec9434f2b # v3
        with:
          sarif_file: results.sarif

  php-cs:
    name: Run PHP-CS

    runs-on: "ubuntu-latest"

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: Checkout Code
        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
      - name: SetUp PHP
        id: setup-php
        uses: shivammathur/setup-php@c541c155eee45413f5b09a52248675b1a2575231 # v2
        with:
          php-version: "8.3"
      - name: Get composer cache directory
        id: composer-cache
        run: echo "dir=$(composer config cache-files-dir)" >> $GITHUB_OUTPUT
      - name: Cache Deps
        uses: actions/cache@3624ceb22c1c5a301c8db4169662070a689d9ea8 # v4.1.1
        id: cache
        with:
          path: ${{ steps.composer-cache.outputs.dir }}
          key: deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-composer-${{ hashFiles('**/composer.lock') }}
          restore-keys: |
            deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-composer-
            deps-${{ runner.os }}-${{ steps.setup-php.outputs.php-version }}-
            deps-${{ steps.setup-php.outputs.php-version }}-
            deps-
      - name: Install Deps
        run: composer install --prefer-dist
      - name: Run PHP-CS
        run: composer run test:formatted
PK     V_]MÔYr5  5  /  zipstream-php/.github/workflows/branch_main.ymlnu „[µü¤        on:
  push:
    branches:
      - "main"

name: "Main Branch"

permissions:
  contents: read

jobs:
  test:
    name: "Test"

    permissions:
      contents: read
      security-events: write

    uses: ./.github/workflows/part_test.yml

  docs:
    name: "Docs"

    uses: ./.github/workflows/part_docs.yml
PK     V_]<ôÚ    &  zipstream-php/.github/workflows/pr.ymlnu „[µü¤        on:
  pull_request:
    branches:
      - "*"
  workflow_dispatch: {}

name: "Pull Request"

permissions:
  contents: read

jobs:
  test:
    name: "Test"

    permissions:
      contents: read
      security-events: write

    uses: ./.github/workflows/part_test.yml

  docs:
    name: "Docs"

    uses: ./.github/workflows/part_docs.yml

  dependabot:
    name: "Dependabot"

    if: ${{ github.actor == 'dependabot[bot]'}}

    permissions:
      pull-requests: write
      contents: write

    uses: ./.github/workflows/part_dependabot.yml

  dependency-review:
    name: Dependency Review
    runs-on: ubuntu-latest
    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: 'Checkout Repository'
        uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
      - name: 'Dependency Review'
        uses: actions/dependency-review-action@5a2ce3f5b92ee19cbb1541a4984c76d921601d7c # v4.3.4
PK     V_]ôõo	  o	  0  zipstream-php/.github/workflows/part_release.ymlnu „[µü¤        on:
  workflow_call:
    inputs:
      releaseName:
        required: true
        type: string
      stable:
        required: false
        type: boolean
        default: false

name: "Release"

permissions:
  contents: read

jobs:
  create:
    name: Create Release

    runs-on: ubuntu-latest

    permissions:
      contents: write

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - name: Create prerelease
        if: ${{ !inputs.stable }}
        env:
          GITHUB_TOKEN: ${{ github.token }}
        run: |
          gh release create \
            --repo ${{ github.repository }} \
            --title ${{ inputs.releaseName }} \
            --prerelease \
            --generate-notes \
            ${{ inputs.releaseName }}

      - name: Create release
        if: ${{ inputs.stable }}
        env:
          GITHUB_TOKEN: ${{ github.token }}
        run: |
          gh release create \
            --repo ${{ github.repository }} \
            --title ${{ inputs.releaseName }} \
            --generate-notes \
            ${{ inputs.releaseName }}

  upload_release:
    name: "Upload"

    needs: ["create"]

    runs-on: ubuntu-latest

    permissions:
      id-token: write
      contents: write
      attestations: write

    steps:
      - name: Harden Runner
        uses: step-security/harden-runner@91182cccc01eb5e619899d80e4e971d6181294a7 # v2.10.1
        with:
          egress-policy: audit

      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
      - uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8
        with:
          name: docs
          path: docs
      - run: |
          tar -czvf docs.tar.gz docs
      - name: "Attest Documentation"
        id: attestation
        uses: actions/attest-build-provenance@1c608d11d69870c2092266b3f9a6f3abbf17002c # v1.4.3
        with:
          subject-path: "docs.tar.gz"
      - name: Copy Attestation
        run: cp "$ATTESTATION" docs.tar.gz.sigstore
        env:
          ATTESTATION: "${{ steps.attestation.outputs.bundle-path }}"
      - name: Upload
        env:
          GITHUB_TOKEN: ${{ github.token }}
        run: |
          gh release upload --clobber "${{ github.ref_name }}" \
            docs.tar.gz docs.tar.gz.sigstore
PK     V_]®+/Ø²  ²  ,  zipstream-php/.github/workflows/tag-beta.ymlnu „[µü¤        on:
  push:
    tags:
      - "[0-9]+.[0-9]+.[0-9]+-beta.[0-9]+"

name: "Beta Tag"

permissions:
  contents: read

jobs:
  docs:
    name: "Docs"

    uses: ./.github/workflows/part_docs.yml

  release:
    name: "Release"

    needs: ["docs"]

    permissions:
      id-token: write
      contents: write
      attestations: write

    uses: ./.github/workflows/part_release.yml
    with:
      releaseName: "${{ github.ref_name }}"
PK     V_]8Òfæ      !  zipstream-php/.github/FUNDING.ymlnu „[µü¤        github: maennchen
PK     V_]îDˆ    $  zipstream-php/.github/dependabot.ymlnu „[µü¤        version: 2
updates:
  - package-ecosystem: "composer"
    directory: "/"
    schedule:
      interval: "daily"
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
    groups:
      github-actions:
        applies-to: version-updatesPK     V_]hÆþ=  =  #  zipstream-php/.github/scorecard.ymlnu „[µü¤        annotations:
  - checks:
      - fuzzing
    reasons:
      - reason: not-applicable # PHP is memory safe
  - checks:
      - packaging
    reasons:
      - reason: not-supported # Using Composer
  - checks:
      - signed-releases
    reasons:
      - reason: not-applicable # Releases are distributed via Composer

PK     V_]âe38  8  !  zipstream-php/.github/SECURITY.mdnu „[µü¤        # Security Policy

[![OpenSSF Vulnerability Disclosure](https://img.shields.io/badge/OpenSSF-Vulnerability_Disclosure-green)](https://github.com/ossf/oss-vulnerability-guide/blob/main/finder-guide.md)
[![GitHub Report](https://img.shields.io/badge/GitHub-Security_Advisories-blue)](https://github.com/maennchen/ZipStream-PHP/security/advisories/new)
[![Email Report](https://img.shields.io/badge/Email-jonatan%40maennchen.ch-blue)](mailto:jonatan@maennchen.ch)

This repository follows the
[OpenSSF Vulnerability Disclosure guide](https://github.com/ossf/oss-vulnerability-guide/tree/main).
You can learn more about it in the
[Finders Guide](https://github.com/ossf/oss-vulnerability-guide/blob/main/finder-guide.md).

Please report vulnerabilities via the
[GitHub Security Vulnerability Reporting](https://github.com/maennchen/ZipStream-PHP/security/advisories/new)
or via email to [`jonatan@maennchen.ch`](mailto:jonatan@maennchen.ch) if this does
not work for you.

Our vulnerability management team will respond within 3 working days of your
report. If the issue is confirmed as a vulnerability, we will open a Security
Advisory. This project follows a 90 day disclosure timeline.

If you have questions about reporting security issues, email the vulnerability
management team: [`jonatan@maennchen.ch`](mailto:jonatan@maennchen.ch)
PK     V_]v÷W    .  zipstream-php/.github/PULL_REQUEST_TEMPLATE.mdnu „[µü¤        Please go the the `Preview` tab and select the appropriate sub-template:

* [ðŸž Failing Test](?expand=1&template=FAILING_TEST.md)
* [ðŸž Bug Fix](?expand=1&template=FIX.md)
* [âš™ Improvement](?expand=1&template=IMPROVEMENT.md)
* [ðŸŽ‰ New Feature](?expand=1&template=NEW_FEATURE.md)
PK     V_]ŒÕù8ô  ô  %  zipstream-php/.github/CONTRIBUTING.mdnu „[µü¤        # Contributing to ZipStream-PHP

## Welcome!

We look forward to your contributions! Here are some examples how you can
contribute:

- [Report a bug](https://github.com/maennchen/ZipStream-PHP/issues/new?labels=bug&template=BUG.md)
- [Propose a new feature](https://github.com/maennchen/ZipStream-PHP/issues/new?labels=enhancement&template=FEATURE.md)
- [Send a pull request](https://github.com/maennchen/ZipStream-PHP/pulls)

## We have a Code of Conduct

Please note that this project is released with a
[Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this
project you agree to abide by its terms.

## Any contributions you make will be under the MIT License

When you submit code changes, your submissions are understood to be under the
same [MIT License](https://github.com/maennchen/ZipStream-PHP/blob/main/LICENSE)
that covers the project. By contributing to this project, you agree that your
contributions will be licensed under its MIT License.

## Write bug reports with detail, background, and sample code

In your bug report, please provide the following:

- A quick summary and/or background
- Steps to reproduce
  - Be specific!
  - Give sample code if you can.
- What you expected would happen
- What actually happens
- Notes (possibly including why you think this might be happening, or stuff you
- tried that didn't work)

Please do not report a bug for a version of ZIPStream-PHP that is no longer
supported (`< 3.0.0`). Please do not report a bug if you are using a version of
PHP that is not supported by the version of ZipStream-PHP you are using.

Please post code and output as text
([using proper markup](https://guides.github.com/features/mastering-markdown/)).
Do not post screenshots of code or output.

Please include the output of `composer info | sort`.

## Workflow for Pull Requests

1. Fork the repository.
2. Create your branch from `main` if you plan to implement new functionality or
   change existing code significantly; create your branch from the oldest branch
   that is affected by the bug if you plan to fix a bug.
3. Implement your change and add tests for it.
4. Ensure the test suite passes.
5. Ensure the code complies with our coding guidelines (see below).
6. Send that pull request!

Please make sure you have
[set up your user name and email address](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup)
for use with Git. Strings such as `silly nick name <root@localhost>` look really
stupid in the commit history of a project.

We encourage you to
[sign your Git commits with your GPG key](https://docs.github.com/en/github/authenticating-to-github/signing-commits).

Pull requests for new features must be based on the `main` branch.

We are trying to keep backwards compatibility breaks in ZipStream-PHP to a
minimum. Please take this into account when proposing changes.

Due to time constraints, we are not always able to respond as quickly as we
would like. Please do not take delays personal and feel free to remind us if you
feel that we forgot to respond.

## Coding Guidelines

This project comes with a configuration file (located at `/psalm.yml` in the
repository) that you can use to perform static analysis (with a focus on type
checking):

```bash
$ .composer run test:lint
```

This project comes with a configuration file (located at
`/.php-cs-fixer.dist.php` in the repository) that you can use to (re)format your
source code for compliance with this project's coding guidelines:

```bash
$ composer run format
```

Please understand that we will not accept a pull request when its changes
violate this project's coding guidelines.

## Using ZipStream-PHP from a Git checkout

The following commands can be used to perform the initial checkout of
ZipStream-PHP:

```bash
$ git clone git@github.com:maennchen/ZipStream-PHP.git

$ cd ZipStream-PHP
```

Install ZipStream-PHP's dependencies using [Composer](https://getcomposer.org/):

```bash
$ composer install
$ composer run install:tools # Install phpDocumentor using phive
```

## Running ZipStream-PHP's test suite

After following the steps shown above, ZipStream-PHP's test suite is run like
this:

```bash
$ composer run test:unit
```

There's some slow tests in the test suite that test the handling of big files in
the archives. To skip them use the following command instead:

```bash
$ composer run test:unit:fast
```

## Generating ZipStream-PHP Documentation

To generate the documentation for the library, run:

```bash
$ composer run docs:generate
```

The guide documentation pages can be found in the `/guides/` directory.
PK     V_]–‚lm  m  (  zipstream-php/.github/CODE_OF_CONDUCT.mdnu „[µü¤        # Contributor Covenant Code of Conduct

## Our Pledge

We as members, contributors, and leaders pledge to make participation in our
community a harassment-free experience for everyone, regardless of age, body
size, visible or invisible disability, ethnicity, sex characteristics, gender
identity and expression, level of experience, education, socio-economic status,
nationality, personal appearance, race, caste, color, religion, or sexual
identity and orientation.

We pledge to act and interact in ways that contribute to an open, welcoming,
diverse, inclusive, and healthy community.

## Our Standards

Examples of behavior that contributes to a positive environment for our
community include:

- Demonstrating empathy and kindness toward other people
- Being respectful of differing opinions, viewpoints, and experiences
- Giving and gracefully accepting constructive feedback
- Accepting responsibility and apologizing to those affected by our mistakes,
  and learning from the experience
- Focusing on what is best not just for us as individuals, but for the overall
  community

Examples of unacceptable behavior include:

- The use of sexualized language or imagery, and sexual attention or advances of
  any kind
- Trolling, insulting or derogatory comments, and personal or political attacks
- Public or private harassment
- Publishing others' private information, such as a physical or email address,
  without their explicit permission
- Other conduct which could reasonably be considered inappropriate in a
  professional setting

## Enforcement Responsibilities

Community leaders are responsible for clarifying and enforcing our standards of
acceptable behavior and will take appropriate and fair corrective action in
response to any behavior that they deem inappropriate, threatening, offensive,
or harmful.

Community leaders have the right and responsibility to remove, edit, or reject
comments, commits, code, wiki edits, issues, and other contributions that are
not aligned to this Code of Conduct, and will communicate reasons for moderation
decisions when appropriate.

## Scope

This Code of Conduct applies within all community spaces, and also applies when
an individual is officially representing the community in public spaces.
Examples of representing our community include using an official e-mail address,
posting via an official social media account, or acting as an appointed
representative at an online or offline event.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be
reported to the community leaders responsible for enforcement at
jonatan@maennchen.ch.
All complaints will be reviewed and investigated promptly and fairly.

All community leaders are obligated to respect the privacy and security of the
reporter of any incident.

## Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining
the consequences for any action they deem in violation of this Code of Conduct:

### 1. Correction

**Community Impact**: Use of inappropriate language or other behavior deemed
unprofessional or unwelcome in the community.

**Consequence**: A private, written warning from community leaders, providing
clarity around the nature of the violation and an explanation of why the
behavior was inappropriate. A public apology may be requested.

### 2. Warning

**Community Impact**: A violation through a single incident or series of
actions.

**Consequence**: A warning with consequences for continued behavior. No
interaction with the people involved, including unsolicited interaction with
those enforcing the Code of Conduct, for a specified period of time. This
includes avoiding interactions in community spaces as well as external channels
like social media. Violating these terms may lead to a temporary or permanent
ban.

### 3. Temporary Ban

**Community Impact**: A serious violation of community standards, including
sustained inappropriate behavior.

**Consequence**: A temporary ban from any sort of interaction or public
communication with the community for a specified period of time. No public or
private interaction with the people involved, including unsolicited interaction
with those enforcing the Code of Conduct, is allowed during this period.
Violating these terms may lead to a permanent ban.

### 4. Permanent Ban

**Community Impact**: Demonstrating a pattern of violation of community
standards, including sustained inappropriate behavior, harassment of an
individual, or aggression toward or disparagement of classes of individuals.

**Consequence**: A permanent ban from any sort of public interaction within the
community.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 2.1, available at
[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].

Community Impact Guidelines were inspired by
[Mozilla's code of conduct enforcement ladder][mozilla coc].

For answers to common questions about this code of conduct, see the FAQ at
[https://www.contributor-covenant.org/faq][faq]. Translations are available at
[https://www.contributor-covenant.org/translations][translations].

[homepage]: https://www.contributor-covenant.org
[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
[mozilla coc]: https://github.com/mozilla/diversity
[faq]: https://www.contributor-covenant.org/faq
[translations]: https://www.contributor-covenant.org/translations
PK     V_]èY‚²  ²  -  zipstream-php/.phpdoc/template/base.html.twignu „[µü¤        {% extends 'layout.html.twig' %}

{% set topMenu = {
    "menu": [
        { "name": "Guides", "url": "https://maennchen.dev/ZipStream-PHP/guide/index.html"},
        { "name": "API", "url": "https://maennchen.dev/ZipStream-PHP/classes/ZipStream-ZipStream.html"},
        { "name": "Issues", "url": "https://github.com/maennchen/ZipStream-PHP/issues"},
    ],
    "social": [
        { "iconClass": "fab fa-github", "url": "https://github.com/maennchen/ZipStream-PHP"},
        { "iconClass": "fas fa-envelope-open-text", "url": "https://github.com/maennchen/ZipStream-PHP/discussions"},
        { "iconClass": "fas fa-money-bill", "url": "https://opencollective.com/zipstream"},
    ]
}
%}PK     V_]I]U§â  â  >  zipstream-php/src/Exception/SimulationFileUnknownException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a strict simulation is executed and the file
 * information can't be determined without reading the entire file.
 */
class SimulationFileUnknownException extends Exception
{
    public function __construct()
    {
        parent::__construct('The details of the strict simulation file could not be determined without reading the entire file.');
    }
}
PK     V_]Ù°93  3  7  zipstream-php/src/Exception/ResourceActionException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a resource like `fread` returns false
 */
class ResourceActionException extends Exception
{
    /**
     * @var ?resource
     */
    public $resource;

    /**
     * @param resource $resource
     */
    public function __construct(
        public readonly string $function,
        $resource = null,
    ) {
        $this->resource = $resource;
        parent::__construct('Function ' . $function . 'failed on resource.');
    }
}
PK     V_]öÑÛî  î  8  zipstream-php/src/Exception/DosTimeOverflowException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use DateTimeInterface;
use ZipStream\Exception;

/**
 * This Exception gets invoked if a file wasn't found
 */
class DosTimeOverflowException extends Exception
{
    /**
     * @internal
     */
    public function __construct(
        public readonly DateTimeInterface $dateTime
    ) {
        parent::__construct('The date ' . $dateTime->format(DateTimeInterface::ATOM) . " can't be represented as DOS time / date.");
    }
}
PK     V_]e‚¹.    8  zipstream-php/src/Exception/FileNotReadableException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a file wasn't found
 */
class FileNotReadableException extends Exception
{
    /**
     * @internal
     */
    public function __construct(
        public readonly string $path
    ) {
        parent::__construct("The file with the path $path isn't readable.");
    }
}
PK     V_]'A„Û‹  ‹  5  zipstream-php/src/Exception/FileNotFoundException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a file wasn't found
 */
class FileNotFoundException extends Exception
{
    /**
     * @internal
     */
    public function __construct(
        public readonly string $path
    ) {
        parent::__construct("The file with the path $path wasn't found.");
    }
}
PK     V_])ž¡«  «  :  zipstream-php/src/Exception/StreamNotSeekableException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a non seekable stream is
 * provided and zero headers are disabled.
 */
class StreamNotSeekableException extends Exception
{
    /**
     * @internal
     */
    public function __construct()
    {
        parent::__construct('enableZeroHeader must be enable to add non seekable streams');
    }
}
PK     V_](¨”Ô    1  zipstream-php/src/Exception/OverflowException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a counter value exceeds storage size
 */
class OverflowException extends Exception
{
    /**
     * @internal
     */
    public function __construct()
    {
        parent::__construct('File size exceeds limit of 32 bit integer. Please enable "zip64" option.');
    }
}
PK     V_]Ó¶Û”a  a  :  zipstream-php/src/Exception/StreamNotReadableException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a stream can't be read.
 */
class StreamNotReadableException extends Exception
{
    /**
     * @internal
     */
    public function __construct()
    {
        parent::__construct('The stream could not be read.');
    }
}
PK     V_]jâ>¬    :  zipstream-php/src/Exception/FileSizeIncorrectException.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Exception;

use ZipStream\Exception;

/**
 * This Exception gets invoked if a file is not as large as it was specified.
 */
class FileSizeIncorrectException extends Exception
{
    /**
     * @internal
     */
    public function __construct(
        public readonly int $expectedSize,
        public readonly int $actualSize
    ) {
        parent::__construct("File is {$actualSize} instead of {$expectedSize} bytes large. Adjust `exactSize` parameter.");
    }
}
PK     V_]$!ú<&  &  1  zipstream-php/src/Zip64/EndOfCentralDirectory.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Zip64;

use ZipStream\PackField;

/**
 * @internal
 */
abstract class EndOfCentralDirectory
{
    private const SIGNATURE = 0x06064b50;

    public static function generate(
        int $versionMadeBy,
        int $versionNeededToExtract,
        int $numberOfThisDisk,
        int $numberOfTheDiskWithCentralDirectoryStart,
        int $numberOfCentralDirectoryEntriesOnThisDisk,
        int $numberOfCentralDirectoryEntries,
        int $sizeOfCentralDirectory,
        int $centralDirectoryStartOffsetOnDisk,
        string $extensibleDataSector,
    ): string {
        $recordSize = 44 + strlen($extensibleDataSector); // (length of block - 12) = 44;

        /** @psalm-suppress MixedArgument */
        return PackField::pack(
            new PackField(format: 'V', value: static::SIGNATURE),
            new PackField(format: 'P', value: $recordSize),
            new PackField(format: 'v', value: $versionMadeBy),
            new PackField(format: 'v', value: $versionNeededToExtract),
            new PackField(format: 'V', value: $numberOfThisDisk),
            new PackField(format: 'V', value: $numberOfTheDiskWithCentralDirectoryStart),
            new PackField(format: 'P', value: $numberOfCentralDirectoryEntriesOnThisDisk),
            new PackField(format: 'P', value: $numberOfCentralDirectoryEntries),
            new PackField(format: 'P', value: $sizeOfCentralDirectory),
            new PackField(format: 'P', value: $centralDirectoryStartOffsetOnDisk),
        ) . $extensibleDataSector;
    }
}
PK     V_]@$è)  )  8  zipstream-php/src/Zip64/EndOfCentralDirectoryLocator.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Zip64;

use ZipStream\PackField;

/**
 * @internal
 */
abstract class EndOfCentralDirectoryLocator
{
    private const SIGNATURE = 0x07064b50;

    public static function generate(
        int $numberOfTheDiskWithZip64CentralDirectoryStart,
        int $zip64centralDirectoryStartOffsetOnDisk,
        int $totalNumberOfDisks,
    ): string {
        /** @psalm-suppress MixedArgument */
        return PackField::pack(
            new PackField(format: 'V', value: static::SIGNATURE),
            new PackField(format: 'V', value: $numberOfTheDiskWithZip64CentralDirectoryStart),
            new PackField(format: 'P', value: $zip64centralDirectoryStartOffsetOnDisk),
            new PackField(format: 'V', value: $totalNumberOfDisks),
        );
    }
}
PK     V_]y×pˆ  ˆ  *  zipstream-php/src/Zip64/DataDescriptor.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Zip64;

use ZipStream\PackField;

/**
 * @internal
 */
abstract class DataDescriptor
{
    private const SIGNATURE = 0x08074b50;

    public static function generate(
        int $crc32UncompressedData,
        int $compressedSize,
        int $uncompressedSize,
    ): string {
        return PackField::pack(
            new PackField(format: 'V', value: self::SIGNATURE),
            new PackField(format: 'V', value: $crc32UncompressedData),
            new PackField(format: 'P', value: $compressedSize),
            new PackField(format: 'P', value: $uncompressedSize),
        );
    }
}
PK     V_]á5ýOJ  J  9  zipstream-php/src/Zip64/ExtendedInformationExtraField.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Zip64;

use ZipStream\PackField;

/**
 * @internal
 */
abstract class ExtendedInformationExtraField
{
    private const TAG = 0x0001;

    public static function generate(
        ?int $originalSize = null,
        ?int $compressedSize = null,
        ?int $relativeHeaderOffset = null,
        ?int $diskStartNumber = null,
    ): string {
        return PackField::pack(
            new PackField(format: 'v', value: self::TAG),
            new PackField(
                format: 'v',
                value: ($originalSize === null ? 0 : 8) +
                    ($compressedSize === null ? 0 : 8) +
                    ($relativeHeaderOffset === null ? 0 : 8) +
                    ($diskStartNumber === null ? 0 : 4)
            ),
            ...($originalSize === null ? [] : [
                new PackField(format: 'P', value: $originalSize),
            ]),
            ...($compressedSize === null ? [] : [
                new PackField(format: 'P', value: $compressedSize),
            ]),
            ...($relativeHeaderOffset === null ? [] : [
                new PackField(format: 'P', value: $relativeHeaderOffset),
            ]),
            ...($diskStartNumber === null ? [] : [
                new PackField(format: 'V', value: $diskStartNumber),
            ]),
        );
    }
}
PK     V_]ÚkÍÿ‘  ‘  6  zipstream-php/src/Zs/ExtendedInformationExtraField.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream\Zs;

use ZipStream\PackField;

/**
 * @internal
 */
abstract class ExtendedInformationExtraField
{
    private const TAG = 0x5653;

    public static function generate(): string
    {
        return PackField::pack(
            new PackField(format: 'v', value: self::TAG),
            new PackField(format: 'v', value: 0x0000),
        );
    }
}
PK     V_]ï_íJZ  Z  '  zipstream-php/src/CompressionMethod.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

enum CompressionMethod: int
{
    /**
     * The file is stored (no compression)
     */
    case STORE = 0x00;

    // 0x01: legacy algorithm - The file is Shrunk
    // 0x02: legacy algorithm - The file is Reduced with compression factor 1
    // 0x03: legacy algorithm - The file is Reduced with compression factor 2
    // 0x04: legacy algorithm - The file is Reduced with compression factor 3
    // 0x05: legacy algorithm - The file is Reduced with compression factor 4
    // 0x06: legacy algorithm - The file is Imploded
    // 0x07: Reserved for Tokenizing compression algorithm

    /**
     * The file is Deflated
     */
    case DEFLATE = 0x08;

    // /**
    //  * Enhanced Deflating using Deflate64(tm)
    //  */
    // case DEFLATE_64 = 0x09;

    // /**
    //  * PKWARE Data Compression Library Imploding (old IBM TERSE)
    //  */
    // case PKWARE = 0x0a;

    // // 0x0b: Reserved by PKWARE

    // /**
    //  * File is compressed using BZIP2 algorithm
    //  */
    // case BZIP2 = 0x0c;

    // // 0x0d: Reserved by PKWARE

    // /**
    //  * LZMA
    //  */
    // case LZMA = 0x0e;

    // // 0x0f: Reserved by PKWARE

    // /**
    //  * IBM z/OS CMPSC Compression
    //  */
    // case IBM_ZOS_CMPSC = 0x10;

    // // 0x11: Reserved by PKWARE

    // /**
    //  * File is compressed using IBM TERSE
    //  */
    // case IBM_TERSE = 0x12;

    // /**
    //  * IBM LZ77 z Architecture
    //  */
    // case IBM_LZ77 = 0x13;

    // // 0x14: deprecated (use method 93 for zstd)

    // /**
    //  * Zstandard (zstd) Compression
    //  */
    // case ZSTD = 0x5d;

    // /**
    //  * MP3 Compression
    //  */
    // case MP3 = 0x5e;

    // /**
    //  * XZ Compression
    //  */
    // case XZ = 0x5f;

    // /**
    //  * JPEG variant
    //  */
    // case JPEG = 0x60;

    // /**
    //  * WavPack compressed data
    //  */
    // case WAV_PACK = 0x61;

    // /**
    //  * PPMd version I, Rev 1
    //  */
    // case PPMD_1_1 = 0x62;

    // /**
    //  * AE-x encryption marker
    //  */
    // case AE_X_ENCRYPTION = 0x63;
}
PK     V_]+vÛ(ƒ4  ƒ4    zipstream-php/src/File.phpnu „[µü¤        <?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->fileName = self::filterFilename($fileName);
        $this->checkEncoding();

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

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

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

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

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

        $this->addFileHeader();

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

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

        $this->addFileFooter();
        return $this->getCdrFile();
    }

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

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

        $this->stream = ($this->dataCallback)();

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

        return $this->stream;
    }

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

        if ($this->maxSize !== null && $this->maxSize < $fstat['size']) {
            return $this->maxSize;
        }

        return $fstat['size'];
    }

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

        $footer = $this->buildZip64ExtraBlock($forceEnableZip64);

        $zip64Enabled = $footer !== '';

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

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

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


        ($this->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, '/');

        return str_replace(['\\', ':', '*', '?', '"', '<', '>', '|'], '_', $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->fileName, 'UTF-8') &&
                mb_check_encoding($this->comment, 'UTF-8')) {
            $this->generalPurposeBitFlag |= GeneralPurposeBitFlag::EFS;
        }
    }

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

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

        $compressedSize = null;
        if ($force || $this->compressedSize > 0xFFFFFFFF) {
            $outputZip64ExtraBlock = true;
            $compressedSize = $this->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->startOffset > 0xFFFFFFFF) {
            $outputZip64ExtraBlock = true;
            $relativeHeaderOffset = $this->startOffset;
        }

        if (!$outputZip64ExtraBlock) {
            return '';
        }

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

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

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

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

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

        ($this->send)($footer);
    }

    private function readStream(bool $send): void
    {
        $this->compressedSize = 0;
        $this->uncompressedSize = 0;
        $hash = hash_init('crc32b');

        $deflate = $this->compressionInit();

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

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

            hash_update($hash, $data);

            $this->uncompressedSize += strlen($data);

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

            $this->compressedSize += strlen($data);

            if ($send) {
                ($this->send)($data);
            }
        }

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

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

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

                if (!$deflateContext) {
                    // @codeCoverageIgnoreStart
                    throw new RuntimeException("Can't initialize deflate context.");
                    // @codeCoverageIgnoreEnd
                }

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

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

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

    private function isSimulation(): bool
    {
        return $this->operationMode === OperationMode::SIMULATE_LAX || $this->operationMode === OperationMode::SIMULATE_STRICT;
    }
}
PK     V_]T¹)ã  ã  +  zipstream-php/src/EndOfCentralDirectory.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

/**
 * @internal
 */
abstract class EndOfCentralDirectory
{
    private const SIGNATURE = 0x06054b50;

    public static function generate(
        int $numberOfThisDisk,
        int $numberOfTheDiskWithCentralDirectoryStart,
        int $numberOfCentralDirectoryEntriesOnThisDisk,
        int $numberOfCentralDirectoryEntries,
        int $sizeOfCentralDirectory,
        int $centralDirectoryStartOffsetOnDisk,
        string $zipFileComment,
    ): string {
        /** @psalm-suppress MixedArgument */
        return PackField::pack(
            new PackField(format: 'V', value: static::SIGNATURE),
            new PackField(format: 'v', value: $numberOfThisDisk),
            new PackField(format: 'v', value: $numberOfTheDiskWithCentralDirectoryStart),
            new PackField(format: 'v', value: $numberOfCentralDirectoryEntriesOnThisDisk),
            new PackField(format: 'v', value: $numberOfCentralDirectoryEntries),
            new PackField(format: 'V', value: $sizeOfCentralDirectory),
            new PackField(format: 'V', value: $centralDirectoryStartOffsetOnDisk),
            new PackField(format: 'v', value: strlen($zipFileComment)),
        ) . $zipFileComment;
    }
}
PK     V_]U1/t²   ²     zipstream-php/src/Version.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

enum Version: int
{
    case STORE = 0x000A; // 1.00
    case DEFLATE = 0x0014; // 2.00
    case ZIP64 = 0x002D; // 4.50
}
PK     V_]Úá¸0      zipstream-php/src/Time.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

use DateInterval;
use DateTimeImmutable;
use DateTimeInterface;
use ZipStream\Exception\DosTimeOverflowException;

/**
 * @internal
 */
abstract class Time
{
    private const DOS_MINIMUM_DATE = '1980-01-01 00:00:00Z';

    public static function dateTimeToDosTime(DateTimeInterface $dateTime): int
    {
        $dosMinimumDate = new DateTimeImmutable(self::DOS_MINIMUM_DATE);

        if ($dateTime->getTimestamp() < $dosMinimumDate->getTimestamp()) {
            throw new DosTimeOverflowException(dateTime: $dateTime);
        }

        $dateTime = DateTimeImmutable::createFromInterface($dateTime)->sub(new DateInterval('P1980Y'));

        [$year, $month, $day, $hour, $minute, $second] = explode(' ', $dateTime->format('Y n j G i s'));

        return
            ((int) $year << 25) |
            ((int) $month << 21) |
            ((int) $day << 16) |
            ((int) $hour << 11) |
            ((int) $minute << 5) |
            ((int) $second >> 1);
    }
}
PK     V_]/Íl¦  ¦  0  zipstream-php/src/CentralDirectoryFileHeader.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

use DateTimeInterface;

/**
 * @internal
 */
abstract class CentralDirectoryFileHeader
{
    private const SIGNATURE = 0x02014b50;

    public static function generate(
        int $versionMadeBy,
        int $versionNeededToExtract,
        int $generalPurposeBitFlag,
        CompressionMethod $compressionMethod,
        DateTimeInterface $lastModificationDateTime,
        int $crc32,
        int $compressedSize,
        int $uncompressedSize,
        string $fileName,
        string $extraField,
        string $fileComment,
        int $diskNumberStart,
        int $internalFileAttributes,
        int $externalFileAttributes,
        int $relativeOffsetOfLocalHeader,
    ): string {
        return PackField::pack(
            new PackField(format: 'V', value: self::SIGNATURE),
            new PackField(format: 'v', value: $versionMadeBy),
            new PackField(format: 'v', value: $versionNeededToExtract),
            new PackField(format: 'v', value: $generalPurposeBitFlag),
            new PackField(format: 'v', value: $compressionMethod->value),
            new PackField(format: 'V', value: Time::dateTimeToDosTime($lastModificationDateTime)),
            new PackField(format: 'V', value: $crc32),
            new PackField(format: 'V', value: $compressedSize),
            new PackField(format: 'V', value: $uncompressedSize),
            new PackField(format: 'v', value: strlen($fileName)),
            new PackField(format: 'v', value: strlen($extraField)),
            new PackField(format: 'v', value: strlen($fileComment)),
            new PackField(format: 'v', value: $diskNumberStart),
            new PackField(format: 'v', value: $internalFileAttributes),
            new PackField(format: 'V', value: $externalFileAttributes),
            new PackField(format: 'V', value: $relativeOffsetOfLocalHeader),
        ) . $fileName . $extraField . $fileComment;
    }
}
PK     V_]|øZ)h  h  $  zipstream-php/src/DataDescriptor.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

/**
 * @internal
 */
abstract class DataDescriptor
{
    private const SIGNATURE = 0x08074b50;

    public static function generate(
        int $crc32UncompressedData,
        int $compressedSize,
        int $uncompressedSize,
    ): string {
        return PackField::pack(
            new PackField(format: 'V', value: self::SIGNATURE),
            new PackField(format: 'V', value: $crc32UncompressedData),
            new PackField(format: 'V', value: $compressedSize),
            new PackField(format: 'V', value: $uncompressedSize),
        );
    }
}
PK     V_]%ù}–#  #  #  zipstream-php/src/OperationMode.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

/**
 * ZipStream execution operation modes
 */
enum OperationMode
{
    /**
     * Stream file into output stream
     */
    case NORMAL;

    /**
     * Simulate the zip to figure out the resulting file size
     *
     * This only supports entries where the file size is known beforehand and
     * deflation is disabled.
     */
    case SIMULATE_STRICT;

    /**
     * Simulate the zip to figure out the resulting file size
     *
     * If the file size is not known beforehand or deflation is enabled, the
     * entry streams will be read and rewound.
     *
     * If the entry does not support rewinding either, you will not be able to
     * use the same stream in a later operation mode like `NORMAL`.
     */
    case SIMULATE_LAX;
}
PK     V_]÷Ôu‡l  ‡l    zipstream-php/src/ZipStream.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

use Closure;
use DateTimeImmutable;
use DateTimeInterface;
use GuzzleHttp\Psr7\StreamWrapper;
use Psr\Http\Message\StreamInterface;
use RuntimeException;
use ZipStream\Exception\FileNotFoundException;
use ZipStream\Exception\FileNotReadableException;
use ZipStream\Exception\OverflowException;
use ZipStream\Exception\ResourceActionException;

/**
 * Streamed, dynamically generated zip archives.
 *
 * ## Usage
 *
 * Streaming zip archives is a simple, three-step process:
 *
 * 1.  Create the zip stream:
 *
 * ```php
 * $zip = new ZipStream(outputName: 'example.zip');
 * ```
 *
 * 2.  Add one or more files to the archive:
 *
 * ```php
 * // add first file
 * $zip->addFile(fileName: 'world.txt', data: 'Hello World');
 *
 * // add second file
 * $zip->addFile(fileName: 'moon.txt', data: 'Hello Moon');
 * ```
 *
 * 3.  Finish the zip stream:
 *
 * ```php
 * $zip->finish();
 * ```
 *
 * You can also add an archive comment, add comments to individual files,
 * and adjust the timestamp of files. See the API documentation for each
 * method below for additional information.
 *
 * ## Example
 *
 * ```php
 * // create a new zip stream object
 * $zip = new ZipStream(outputName: 'some_files.zip');
 *
 * // list of local files
 * $files = array('foo.txt', 'bar.jpg');
 *
 * // read and add each file to the archive
 * foreach ($files as $path)
 *   $zip->addFileFromPath(fileName: $path, $path);
 *
 * // write archive footer to stream
 * $zip->finish();
 * ```
 */
class ZipStream
{
    /**
     * This number corresponds to the ZIP version/OS used (2 bytes)
     * From: https://www.iana.org/assignments/media-types/application/zip
     * The upper byte (leftmost one) indicates the host system (OS) for the
     * file.  Software can use this information to determine
     * the line record format for text files etc.  The current
     * mappings are:
     *
     * 0 - MS-DOS and OS/2 (F.A.T. file systems)
     * 1 - Amiga                     2 - VAX/VMS
     * 3 - *nix                      4 - VM/CMS
     * 5 - Atari ST                  6 - OS/2 H.P.F.S.
     * 7 - Macintosh                 8 - Z-System
     * 9 - CP/M                      10 thru 255 - unused
     *
     * The lower byte (rightmost one) indicates the version number of the
     * software used to encode the file.  The value/10
     * indicates the major version number, and the value
     * mod 10 is the minor version number.
     * Here we are using 6 for the OS, indicating OS/2 H.P.F.S.
     * to prevent file permissions issues upon extract (see #84)
     * 0x603 is 00000110 00000011 in binary, so 6 and 3
     *
     * @internal
     */
    public const ZIP_VERSION_MADE_BY = 0x603;

    private bool $ready = true;

    private int $offset = 0;

    /**
     * @var string[]
     */
    private array $centralDirectoryRecords = [];

    /**
     * @var resource
     */
    private $outputStream;

    private readonly Closure $httpHeaderCallback;

    /**
     * @var File[]
     */
    private array $recordedSimulation = [];

    /**
     * Create a new ZipStream object.
     *
     * ##### Examples
     *
     * ```php
     * // create a new zip file named 'foo.zip'
     * $zip = new ZipStream(outputName: 'foo.zip');
     *
     * // create a new zip file named 'bar.zip' with a comment
     * $zip = new ZipStream(
     *   outputName: 'bar.zip',
     *   comment: 'this is a comment for the zip file.',
     * );
     * ```
     *
     * @param OperationMode $operationMode
     * The mode can be used to switch between `NORMAL` and `SIMULATION_*` modes.
     * For details see the `OperationMode` documentation.
     *
     * Default to `NORMAL`.
     *
     * @param string $comment
     * Archive Level Comment
     *
     * @param StreamInterface|resource|null $outputStream
     * Override the output of the archive to a different target.
     *
     * By default the archive is sent to `STDOUT`.
     *
     * @param CompressionMethod $defaultCompressionMethod
     * How to handle file compression. Legal values are
     * `CompressionMethod::DEFLATE` (the default), or
     * `CompressionMethod::STORE`. `STORE` sends the file raw and is
     * significantly faster, while `DEFLATE` compresses the file and
     * is much, much slower.
     *
     * @param int $defaultDeflateLevel
     * Default deflation level. Only relevant if `compressionMethod`
     * is `DEFLATE`.
     *
     * See details of [`deflate_init`](https://www.php.net/manual/en/function.deflate-init.php#refsect1-function.deflate-init-parameters)
     *
     * @param bool $enableZip64
     * Enable Zip64 extension, supporting very large
     * archives (any size > 4 GB or file count > 64k)
     *
     * @param bool $defaultEnableZeroHeader
     * Enable streaming files with single read.
     *
     * When the zero header is set, the file is streamed into the output
     * and the size & checksum are added at the end of the file. This is the
     * fastest method and uses the least memory. Unfortunately not all
     * ZIP clients fully support this and can lead to clients reporting
     * the generated ZIP files as corrupted in combination with other
     * circumstances. (Zip64 enabled, using UTF8 in comments / names etc.)
     *
     * When the zero header is not set, the length & checksum need to be
     * defined before the file is actually added. To prevent loading all
     * the data into memory, the data has to be read twice. If the data
     * which is added is not seekable, this call will fail.
     *
     * @param bool $sendHttpHeaders
     * Boolean indicating whether or not to send
     * the HTTP headers for this file.
     *
     * @param ?Closure $httpHeaderCallback
     * The method called to send HTTP headers
     *
     * @param string|null $outputName
     * The name of the created archive.
     *
     * Only relevant if `$sendHttpHeaders = true`.
     *
     * @param string $contentDisposition
     * HTTP Content-Disposition
     *
     * Only relevant if `sendHttpHeaders = true`.
     *
     * @param string $contentType
     * HTTP Content Type
     *
     * Only relevant if `sendHttpHeaders = true`.
     *
     * @param bool $flushOutput
     * Enable flush after every write to output stream.
     *
     * @return self
     */
    public function __construct(
        private OperationMode $operationMode = OperationMode::NORMAL,
        private readonly string $comment = '',
        $outputStream = null,
        private readonly CompressionMethod $defaultCompressionMethod = CompressionMethod::DEFLATE,
        private readonly int $defaultDeflateLevel = 6,
        private readonly bool $enableZip64 = true,
        private readonly bool $defaultEnableZeroHeader = true,
        private bool $sendHttpHeaders = true,
        ?Closure $httpHeaderCallback = null,
        private readonly ?string $outputName = null,
        private readonly string $contentDisposition = 'attachment',
        private readonly string $contentType = 'application/x-zip',
        private bool $flushOutput = false,
    ) {
        $this->outputStream = self::normalizeStream($outputStream);
        $this->httpHeaderCallback = $httpHeaderCallback ?? header(...);
    }

    /**
     * Add a file to the archive.
     *
     * ##### File Options
     *
     * See {@see addFileFromPsr7Stream()}
     *
     * ##### Examples
     *
     * ```php
     * // add a file named 'world.txt'
     * $zip->addFile(fileName: 'world.txt', data: 'Hello World!');
     *
     * // add a file named 'bar.jpg' with a comment and a last-modified
     * // time of two hours ago
     * $zip->addFile(
     *   fileName: 'bar.jpg',
     *   data: $data,
     *   comment: 'this is a comment about bar.jpg',
     *   lastModificationDateTime: new DateTime('2 hours ago'),
     * );
     * ```
     *
     * @param string $data
     *
     * contents of file
     */
    public function addFile(
        string $fileName,
        string $data,
        string $comment = '',
        ?CompressionMethod $compressionMethod = null,
        ?int $deflateLevel = null,
        ?DateTimeInterface $lastModificationDateTime = null,
        ?int $maxSize = null,
        ?int $exactSize = null,
        ?bool $enableZeroHeader = null,
    ): void {
        $this->addFileFromCallback(
            fileName: $fileName,
            callback: fn() => $data,
            comment: $comment,
            compressionMethod: $compressionMethod,
            deflateLevel: $deflateLevel,
            lastModificationDateTime: $lastModificationDateTime,
            maxSize: $maxSize,
            exactSize: $exactSize,
            enableZeroHeader: $enableZeroHeader,
        );
    }

    /**
     * Add a file at path to the archive.
     *
     * ##### File Options
     *
     * See {@see addFileFromPsr7Stream()}
     *
     * ###### Examples
     *
     * ```php
     * // add a file named 'foo.txt' from the local file '/tmp/foo.txt'
     * $zip->addFileFromPath(
     *   fileName: 'foo.txt',
     *   path: '/tmp/foo.txt',
     * );
     *
     * // add a file named 'bigfile.rar' from the local file
     * // '/usr/share/bigfile.rar' with a comment and a last-modified
     * // time of two hours ago
     * $zip->addFileFromPath(
     *   fileName: 'bigfile.rar',
     *   path: '/usr/share/bigfile.rar',
     *   comment: 'this is a comment about bigfile.rar',
     *   lastModificationDateTime: new DateTime('2 hours ago'),
     * );
     * ```
     *
     * @throws \ZipStream\Exception\FileNotFoundException
     * @throws \ZipStream\Exception\FileNotReadableException
     */
    public function addFileFromPath(
        /**
         * name of file in archive (including directory path).
         */
        string $fileName,

        /**
         * path to file on disk (note: paths should be encoded using
         * UNIX-style forward slashes -- e.g '/path/to/some/file').
         */
        string $path,
        string $comment = '',
        ?CompressionMethod $compressionMethod = null,
        ?int $deflateLevel = null,
        ?DateTimeInterface $lastModificationDateTime = null,
        ?int $maxSize = null,
        ?int $exactSize = null,
        ?bool $enableZeroHeader = null,
    ): void {
        if (!is_readable($path)) {
            if (!file_exists($path)) {
                throw new FileNotFoundException($path);
            }
            throw new FileNotReadableException($path);
        }

        $fileTime = filemtime($path);
        if ($fileTime !== false) {
            $lastModificationDateTime ??= (new DateTimeImmutable())->setTimestamp($fileTime);
        }

        $this->addFileFromCallback(
            fileName: $fileName,
            callback: function () use ($path) {

                $stream =  fopen($path, 'rb');

                if (!$stream) {
                    // @codeCoverageIgnoreStart
                    throw new ResourceActionException('fopen');
                    // @codeCoverageIgnoreEnd
                }

                return $stream;
            },
            comment: $comment,
            compressionMethod: $compressionMethod,
            deflateLevel: $deflateLevel,
            lastModificationDateTime: $lastModificationDateTime,
            maxSize: $maxSize,
            exactSize: $exactSize,
            enableZeroHeader: $enableZeroHeader,
        );
    }

    /**
     * Add an open stream (resource) to the archive.
     *
     * ##### File Options
     *
     * See {@see addFileFromPsr7Stream()}
     *
     * ##### Examples
     *
     * ```php
     * // create a temporary file stream and write text to it
     * $filePointer = tmpfile();
     * fwrite($filePointer, 'The quick brown fox jumped over the lazy dog.');
     *
     * // add a file named 'streamfile.txt' from the content of the stream
     * $archive->addFileFromStream(
     *   fileName: 'streamfile.txt',
     *   stream: $filePointer,
     * );
     * ```
     *
     * @param resource $stream contents of file as a stream resource
     */
    public function addFileFromStream(
        string $fileName,
        $stream,
        string $comment = '',
        ?CompressionMethod $compressionMethod = null,
        ?int $deflateLevel = null,
        ?DateTimeInterface $lastModificationDateTime = null,
        ?int $maxSize = null,
        ?int $exactSize = null,
        ?bool $enableZeroHeader = null,
    ): void {
        $this->addFileFromCallback(
            fileName: $fileName,
            callback: fn() => $stream,
            comment: $comment,
            compressionMethod: $compressionMethod,
            deflateLevel: $deflateLevel,
            lastModificationDateTime: $lastModificationDateTime,
            maxSize: $maxSize,
            exactSize: $exactSize,
            enableZeroHeader: $enableZeroHeader,
        );
    }

    /**
     * Add an open stream to the archive.
     *
     * ##### Examples
     *
     * ```php
     * $stream = $response->getBody();
     * // add a file named 'streamfile.txt' from the content of the stream
     * $archive->addFileFromPsr7Stream(
     *   fileName: 'streamfile.txt',
     *   stream: $stream,
     * );
     * ```
     *
     * @param string $fileName
     * path of file in archive (including directory)
     *
     * @param StreamInterface $stream
     * contents of file as a stream resource
     *
     * @param string $comment
     * ZIP comment for this file
     *
     * @param ?CompressionMethod $compressionMethod
     * Override `defaultCompressionMethod`
     *
     * See {@see __construct()}
     *
     * @param ?int $deflateLevel
     * Override `defaultDeflateLevel`
     *
     * See {@see __construct()}
     *
     * @param ?DateTimeInterface $lastModificationDateTime
     * Set last modification time of file.
     *
     * Default: `now`
     *
     * @param ?int $maxSize
     * Only read `maxSize` bytes from file.
     *
     * The file is considered done when either reaching `EOF`
     * or the `maxSize`.
     *
     * @param ?int $exactSize
     * Read exactly `exactSize` bytes from file.
     * If `EOF` is reached before reading `exactSize` bytes, an error will be
     * thrown. The parameter allows for faster size calculations if the `stream`
     * does not support `fstat` size or is slow and otherwise known beforehand.
     *
     * @param ?bool $enableZeroHeader
     * Override `defaultEnableZeroHeader`
     *
     * See {@see __construct()}
     */
    public function addFileFromPsr7Stream(
        string $fileName,
        StreamInterface $stream,
        string $comment = '',
        ?CompressionMethod $compressionMethod = null,
        ?int $deflateLevel = null,
        ?DateTimeInterface $lastModificationDateTime = null,
        ?int $maxSize = null,
        ?int $exactSize = null,
        ?bool $enableZeroHeader = null,
    ): void {
        $this->addFileFromCallback(
            fileName: $fileName,
            callback: fn() => $stream,
            comment: $comment,
            compressionMethod: $compressionMethod,
            deflateLevel: $deflateLevel,
            lastModificationDateTime: $lastModificationDateTime,
            maxSize: $maxSize,
            exactSize: $exactSize,
            enableZeroHeader: $enableZeroHeader,
        );
    }

    /**
     * Add a file based on a callback.
     *
     * This is useful when you want to simulate a lot of files without keeping
     * all of the file handles open at the same time.
     *
     * ##### Examples
     *
     * ```php
     * foreach($files as $name => $size) {
     *   $archive->addFileFromCallback(
     *     fileName: 'streamfile.txt',
     *     exactSize: $size,
     *     callback: function() use($name): Psr\Http\Message\StreamInterface {
     *       $response = download($name);
     *       return $response->getBody();
     *     }
     *   );
     * }
     * ```
     *
     * @param string $fileName
     * path of file in archive (including directory)
     *
     * @param Closure $callback
     * @psalm-param Closure(): (resource|StreamInterface|string) $callback
     * A callback to get the file contents in the shape of a PHP stream,
     * a Psr StreamInterface implementation, or a string.
     *
     * @param string $comment
     * ZIP comment for this file
     *
     * @param ?CompressionMethod $compressionMethod
     * Override `defaultCompressionMethod`
     *
     * See {@see __construct()}
     *
     * @param ?int $deflateLevel
     * Override `defaultDeflateLevel`
     *
     * See {@see __construct()}
     *
     * @param ?DateTimeInterface $lastModificationDateTime
     * Set last modification time of file.
     *
     * Default: `now`
     *
     * @param ?int $maxSize
     * Only read `maxSize` bytes from file.
     *
     * The file is considered done when either reaching `EOF`
     * or the `maxSize`.
     *
     * @param ?int $exactSize
     * Read exactly `exactSize` bytes from file.
     * If `EOF` is reached before reading `exactSize` bytes, an error will be
     * thrown. The parameter allows for faster size calculations if the `stream`
     * does not support `fstat` size or is slow and otherwise known beforehand.
     *
     * @param ?bool $enableZeroHeader
     * Override `defaultEnableZeroHeader`
     *
     * See {@see __construct()}
     */
    public function addFileFromCallback(
        string $fileName,
        Closure $callback,
        string $comment = '',
        ?CompressionMethod $compressionMethod = null,
        ?int $deflateLevel = null,
        ?DateTimeInterface $lastModificationDateTime = null,
        ?int $maxSize = null,
        ?int $exactSize = null,
        ?bool $enableZeroHeader = null,
    ): void {
        $file = new File(
            dataCallback: function () use ($callback, $maxSize) {
                $data = $callback();

                if (is_resource($data)) {
                    return $data;
                }

                if ($data instanceof StreamInterface) {
                    return StreamWrapper::getResource($data);
                }


                $stream = fopen('php://memory', 'rw+');
                if ($stream === false) {
                    // @codeCoverageIgnoreStart
                    throw new ResourceActionException('fopen');
                    // @codeCoverageIgnoreEnd
                }
                if ($maxSize !== null && fwrite($stream, $data, $maxSize) === false) {
                    // @codeCoverageIgnoreStart
                    throw new ResourceActionException('fwrite', $stream);
                    // @codeCoverageIgnoreEnd
                } elseif (fwrite($stream, $data) === false) {
                    // @codeCoverageIgnoreStart
                    throw new ResourceActionException('fwrite', $stream);
                    // @codeCoverageIgnoreEnd
                }
                if (rewind($stream) === false) {
                    // @codeCoverageIgnoreStart
                    throw new ResourceActionException('rewind', $stream);
                    // @codeCoverageIgnoreEnd
                }

                return $stream;

            },
            send: $this->send(...),
            recordSentBytes: $this->recordSentBytes(...),
            operationMode: $this->operationMode,
            fileName: $fileName,
            startOffset: $this->offset,
            compressionMethod: $compressionMethod ?? $this->defaultCompressionMethod,
            comment: $comment,
            deflateLevel: $deflateLevel ?? $this->defaultDeflateLevel,
            lastModificationDateTime: $lastModificationDateTime ?? new DateTimeImmutable(),
            maxSize: $maxSize,
            exactSize: $exactSize,
            enableZip64: $this->enableZip64,
            enableZeroHeader: $enableZeroHeader ?? $this->defaultEnableZeroHeader,
        );

        if ($this->operationMode !== OperationMode::NORMAL) {
            $this->recordedSimulation[] = $file;
        }

        $this->centralDirectoryRecords[] = $file->process();
    }

    /**
     * Add a directory to the archive.
     *
     * ##### File Options
     *
     * See {@see addFileFromPsr7Stream()}
     *
     * ##### Examples
     *
     * ```php
     * // add a directory named 'world/'
     * $zip->addDirectory(fileName: 'world/');
     * ```
     */
    public function addDirectory(
        string $fileName,
        string $comment = '',
        ?DateTimeInterface $lastModificationDateTime = null,
    ): void {
        if (!str_ends_with($fileName, '/')) {
            $fileName .= '/';
        }

        $this->addFile(
            fileName: $fileName,
            data: '',
            comment: $comment,
            compressionMethod: CompressionMethod::STORE,
            deflateLevel: null,
            lastModificationDateTime: $lastModificationDateTime,
            maxSize: 0,
            exactSize: 0,
            enableZeroHeader: false,
        );
    }

    /**
     * Executes a previously calculated simulation.
     *
     * ##### Example
     *
     * ```php
     * $zip = new ZipStream(
     *   outputName: 'foo.zip',
     *   operationMode: OperationMode::SIMULATE_STRICT,
     * );
     *
     * $zip->addFile('test.txt', 'Hello World');
     *
     * $size = $zip->finish();
     *
     * header('Content-Length: '. $size);
     *
     * $zip->executeSimulation();
     * ```
     */
    public function executeSimulation(): void
    {
        if ($this->operationMode !== OperationMode::NORMAL) {
            throw new RuntimeException('Zip simulation is not finished.');
        }

        foreach ($this->recordedSimulation as $file) {
            $this->centralDirectoryRecords[] = $file->cloneSimulationExecution()->process();
        }

        $this->finish();
    }

    /**
     * Write zip footer to stream.
     *
     * The clase is left in an unusable state after `finish`.
     *
     * ##### Example
     *
     * ```php
     * // write footer to stream
     * $zip->finish();
     * ```
     */
    public function finish(): int
    {
        $centralDirectoryStartOffsetOnDisk = $this->offset;
        $sizeOfCentralDirectory = 0;

        // add trailing cdr file records
        foreach ($this->centralDirectoryRecords as $centralDirectoryRecord) {
            $this->send($centralDirectoryRecord);
            $sizeOfCentralDirectory += strlen($centralDirectoryRecord);
        }

        // Add 64bit headers (if applicable)
        if (count($this->centralDirectoryRecords) >= 0xFFFF ||
            $centralDirectoryStartOffsetOnDisk > 0xFFFFFFFF ||
            $sizeOfCentralDirectory > 0xFFFFFFFF) {
            if (!$this->enableZip64) {
                throw new OverflowException();
            }

            $this->send(Zip64\EndOfCentralDirectory::generate(
                versionMadeBy: self::ZIP_VERSION_MADE_BY,
                versionNeededToExtract: Version::ZIP64->value,
                numberOfThisDisk: 0,
                numberOfTheDiskWithCentralDirectoryStart: 0,
                numberOfCentralDirectoryEntriesOnThisDisk: count($this->centralDirectoryRecords),
                numberOfCentralDirectoryEntries: count($this->centralDirectoryRecords),
                sizeOfCentralDirectory: $sizeOfCentralDirectory,
                centralDirectoryStartOffsetOnDisk: $centralDirectoryStartOffsetOnDisk,
                extensibleDataSector: '',
            ));

            $this->send(Zip64\EndOfCentralDirectoryLocator::generate(
                numberOfTheDiskWithZip64CentralDirectoryStart: 0x00,
                zip64centralDirectoryStartOffsetOnDisk: $centralDirectoryStartOffsetOnDisk + $sizeOfCentralDirectory,
                totalNumberOfDisks: 1,
            ));
        }

        // add trailing cdr eof record
        $numberOfCentralDirectoryEntries = min(count($this->centralDirectoryRecords), 0xFFFF);
        $this->send(EndOfCentralDirectory::generate(
            numberOfThisDisk: 0x00,
            numberOfTheDiskWithCentralDirectoryStart: 0x00,
            numberOfCentralDirectoryEntriesOnThisDisk: $numberOfCentralDirectoryEntries,
            numberOfCentralDirectoryEntries: $numberOfCentralDirectoryEntries,
            sizeOfCentralDirectory: min($sizeOfCentralDirectory, 0xFFFFFFFF),
            centralDirectoryStartOffsetOnDisk: min($centralDirectoryStartOffsetOnDisk, 0xFFFFFFFF),
            zipFileComment: $this->comment,
        ));

        $size = $this->offset;

        // The End
        $this->clear();

        return $size;
    }

    /**
     * @param StreamInterface|resource|null $outputStream
     * @return resource
     */
    private static function normalizeStream($outputStream)
    {
        if ($outputStream instanceof StreamInterface) {
            return StreamWrapper::getResource($outputStream);
        }
        if (is_resource($outputStream)) {
            return $outputStream;
        }
        return fopen('php://output', 'wb');
    }

    /**
     * Record sent bytes
     */
    private function recordSentBytes(int $sentBytes): void
    {
        $this->offset += $sentBytes;
    }

    /**
     * Send string, sending HTTP headers if necessary.
     * Flush output after write if configure option is set.
     */
    private function send(string $data): void
    {
        if (!$this->ready) {
            throw new RuntimeException('Archive is already finished');
        }

        if ($this->operationMode === OperationMode::NORMAL && $this->sendHttpHeaders) {
            $this->sendHttpHeaders();
            $this->sendHttpHeaders = false;
        }

        $this->recordSentBytes(strlen($data));

        if ($this->operationMode === OperationMode::NORMAL) {
            if (fwrite($this->outputStream, $data) === false) {
                throw new ResourceActionException('fwrite', $this->outputStream);
            }

            if ($this->flushOutput) {
                // flush output buffer if it is on and flushable
                $status = ob_get_status();
                if (isset($status['flags']) && is_int($status['flags']) && ($status['flags'] & PHP_OUTPUT_HANDLER_FLUSHABLE)) {
                    ob_flush();
                }

                // Flush system buffers after flushing userspace output buffer
                flush();
            }
        }
    }

    /**
    * Send HTTP headers for this stream.
    */
    private function sendHttpHeaders(): void
    {
        // grab content disposition
        $disposition = $this->contentDisposition;

        if ($this->outputName !== null) {
            // Various different browsers dislike various characters here. Strip them all for safety.
            $safeOutput = trim(str_replace(['"', "'", '\\', ';', "\n", "\r"], '', $this->outputName));

            // Check if we need to UTF-8 encode the filename
            $urlencoded = rawurlencode($safeOutput);
            $disposition .= "; filename*=UTF-8''{$urlencoded}";
        }

        $headers = [
            'Content-Type' => $this->contentType,
            'Content-Disposition' => $disposition,
            'Pragma' => 'public',
            'Cache-Control' => 'public, must-revalidate',
            'Content-Transfer-Encoding' => 'binary',
        ];

        foreach ($headers as $key => $val) {
            ($this->httpHeaderCallback)("$key: $val");
        }
    }

    /**
     * Clear all internal variables. Note that the stream object is not
     * usable after this.
     */
    private function clear(): void
    {
        $this->centralDirectoryRecords = [];
        $this->offset = 0;

        if ($this->operationMode === OperationMode::NORMAL) {
            $this->ready = false;
            $this->recordedSimulation = [];
        } else {
            $this->operationMode = OperationMode::NORMAL;
        }
    }
}
PK     V_]
ø $?  ?  %  zipstream-php/src/LocalFileHeader.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

use DateTimeInterface;

/**
 * @internal
 */
abstract class LocalFileHeader
{
    private const SIGNATURE = 0x04034b50;

    public static function generate(
        int $versionNeededToExtract,
        int $generalPurposeBitFlag,
        CompressionMethod $compressionMethod,
        DateTimeInterface $lastModificationDateTime,
        int $crc32UncompressedData,
        int $compressedSize,
        int $uncompressedSize,
        string $fileName,
        string $extraField,
    ): string {
        return PackField::pack(
            new PackField(format: 'V', value: self::SIGNATURE),
            new PackField(format: 'v', value: $versionNeededToExtract),
            new PackField(format: 'v', value: $generalPurposeBitFlag),
            new PackField(format: 'v', value: $compressionMethod->value),
            new PackField(format: 'V', value: Time::dateTimeToDosTime($lastModificationDateTime)),
            new PackField(format: 'V', value: $crc32UncompressedData),
            new PackField(format: 'V', value: $compressedSize),
            new PackField(format: 'V', value: $uncompressedSize),
            new PackField(format: 'v', value: strlen($fileName)),
            new PackField(format: 'v', value: strlen($extraField)),
        ) . $fileName . $extraField;
    }
}
PK     V_]^¼  ¼    zipstream-php/src/PackField.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

use RuntimeException;

/**
 * @internal
 * TODO: Make class readonly when requiring PHP 8.2 exclusively
 */
class PackField
{
    public const MAX_V = 0xFFFFFFFF;

    public const MAX_v = 0xFFFF;

    public function __construct(
        public readonly string $format,
        public readonly int|string $value
    ) {}

    /**
     * Create a format string and argument list for pack(), then call
     * pack() and return the result.
     */
    public static function pack(self ...$fields): string
    {
        $fmt = array_reduce($fields, function (string $acc, self $field) {
            return $acc . $field->format;
        }, '');

        $args = array_map(function (self $field) {
            switch ($field->format) {
                case 'V':
                    if ($field->value > self::MAX_V) {
                        throw new RuntimeException(print_r($field->value, true) . ' is larger than 32 bits');
                    }
                    break;
                case 'v':
                    if ($field->value > self::MAX_v) {
                        throw new RuntimeException(print_r($field->value, true) . ' is larger than 16 bits');
                    }
                    break;
                case 'P': break;
                default:
                    break;
            }

            return $field->value;
        }, $fields);

        return pack($fmt, ...$args);
    }
}
PK     V_]È5¸‹	  ‹	  +  zipstream-php/src/GeneralPurposeBitFlag.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

/**
 * @internal
 */
abstract class GeneralPurposeBitFlag
{
    /**
     * If set, indicates that the file is encrypted.
     */
    public const ENCRYPTED = 1 << 0;

    /**
     * (For Methods 8 and 9 - Deflating)
     * Normal (-en) compression option was used.
     */
    public const DEFLATE_COMPRESSION_NORMAL = 0 << 1;

    /**
     * (For Methods 8 and 9 - Deflating)
     * Maximum (-exx/-ex) compression option was used.
     */
    public const DEFLATE_COMPRESSION_MAXIMUM = 1 << 1;

    /**
     * (For Methods 8 and 9 - Deflating)
     * Fast (-ef) compression option was used.
     */
    public const DEFLATE_COMPRESSION_FAST = 10 << 1;

    /**
     * (For Methods 8 and 9 - Deflating)
     * Super Fast (-es) compression option was used.
     */
    public const DEFLATE_COMPRESSION_SUPERFAST = 11 << 1;

    /**
     * If the compression method used was type 14,
     * LZMA, then this bit, if set, indicates
     * an end-of-stream (EOS) marker is used to
     * mark the end of the compressed data stream.
     * If clear, then an EOS marker is not present
     * and the compressed data size must be known
     * to extract.
     */
    public const LZMA_EOS = 1 << 1;

    /**
     * If this bit is set, the fields crc-32, compressed
     * size and uncompressed size are set to zero in the
     * local header.  The correct values are put in the
     * data descriptor immediately following the compressed
     * data.
     */
    public const ZERO_HEADER = 1 << 3;

    /**
     * If this bit is set, this indicates that the file is
     * compressed patched data.
     */
    public const COMPRESSED_PATCHED_DATA = 1 << 5;

    /**
     * Strong encryption. If this bit is set, you MUST
     * set the version needed to extract value to at least
     * 50 and you MUST also set bit 0.  If AES encryption
     * is used, the version needed to extract value MUST
     * be at least 51.
     */
    public const STRONG_ENCRYPTION = 1 << 6;

    /**
     * Language encoding flag (EFS).  If this bit is set,
     * the filename and comment fields for this file
     * MUST be encoded using UTF-8.
     */
    public const EFS = 1 << 11;

    /**
     * Set when encrypting the Central Directory to indicate
     * selected data values in the Local Header are masked to
     * hide their actual values.
     */
    public const ENCRYPT_CENTRAL_DIRECTORY = 1 << 13;
}
PK     V_]Ù1üf   f     zipstream-php/src/Exception.phpnu „[µü¤        <?php

declare(strict_types=1);

namespace ZipStream;

abstract class Exception extends \Exception {}
PK     V_]øû±S\  \  &  zipstream-php/guides/ContentLength.rstnu „[µü¤        Adding Content-Length header
=============

Adding a ``Content-Length`` header for ``ZipStream`` can be achieved by
using the options ``SIMULATION_STRICT`` or ``SIMULATION_LAX`` in the
``operationMode`` parameter.

In the ``SIMULATION_STRICT`` mode, ``ZipStream`` will not allow to calculate the
size based on reading the whole file. ``SIMULATION_LAX`` will read the whole
file if neccessary.

``SIMULATION_STRICT`` is therefore useful to make sure that the size can be
calculated efficiently.

.. code-block:: php
    use ZipStream\OperationMode;
    use ZipStream\ZipStream;

    $zip = new ZipStream(
        operationMode: OperationMode::SIMULATE_STRICT, // or SIMULATE_LAX
        defaultEnableZeroHeader: false,
        sendHttpHeaders: true,
        outputStream: $stream,
    );

    // Normally add files
    $zip->addFile('sample.txt', 'Sample String Data');

    // Use addFileFromCallback and exactSize if you want to defer opening of
    // the file resource
    $zip->addFileFromCallback(
        'sample.txt',
        exactSize: 18,
        callback: function () {
            return fopen('...');
        }
    );

    // Read resulting file size
    $size = $zip->finish();
    
    // Tell it to the browser
    header('Content-Length: '. $size);
    
    // Execute the Simulation and stream the actual zip to the client
    $zip->executeSimulation();

PK     V_]Ížö´    $  zipstream-php/guides/PSR7Streams.rstnu „[µü¤        Usage with PSR 7 Streams
===============

PSR-7 streams are `standardized streams <https://www.php-fig.org/psr/psr-7/>`_.

ZipStream-PHP supports working with these streams with the function
``addFileFromPsr7Stream``. 

For all parameters of the function see the API documentation.

Example
---------------

.. code-block:: php

    $stream = $response->getBody();
    // add a file named 'streamfile.txt' from the content of the stream
    $zip->addFileFromPsr7Stream(
        fileName: 'streamfile.txt',
        stream: $stream,
    );
PK     V_]çx608  8  "  zipstream-php/guides/FlySystem.rstnu „[µü¤        Usage with FlySystem
===============

For saving or uploading the generated zip, you can use the
`Flysystem <https://flysystem.thephpleague.com>`_ package, and its many
adapters.

For that you will need to provide another stream than the ``php://output``
default one, and pass it to Flysystem ``putStream`` method.

.. code-block:: php

    // Open Stream only once for read and write since it's a memory stream and
    // the content is lost when closing the stream / opening another one
    $tempStream = fopen('php://memory', 'w+');

    // Create Zip Archive
    $zipStream = new ZipStream(
        outputStream: $tempStream,
        outputName: 'test.zip',
    );
    $zipStream->addFile('test.txt', 'text');
    $zipStream->finish();

    // Store File
    // (see Flysystem documentation, and all its framework integration)
    // Can be any adapter (AWS, Google, Ftp, etc.)
    $adapter = new Local(__DIR__.'/path/to/folder');
    $filesystem = new Filesystem($adapter);

    $filesystem->writeStream('test.zip', $tempStream)

    // Close Stream
    fclose($tempStream);
PK     V_]öŠö|°  °     zipstream-php/guides/Options.rstnu „[µü¤        Available options
===============

Here is the full list of options available to you. You can also have a look at
``src/ZipStream.php`` file.

.. code-block:: php

    use ZipStream\ZipStream;

    require_once 'vendor/autoload.php';

    $zip = new ZipStream(
        // Define output stream
        // (argument is eiter a resource or implementing
        // `Psr\Http\Message\StreamInterface`)
        //
        // Setup with `psr/http-message` & `guzzlehttp/psr7` dependencies
        // required when using `Psr\Http\Message\StreamInterface`.
        outputStream: $filePointer,

        // Set the deflate level (default is 6; use -1 to disable it)
        defaultDeflateLevel: 6,

        // Add a comment to the zip file
        comment: 'This is a comment.',

        // Send http headers (default is true)
        sendHttpHeaders: false,

        // HTTP Content-Disposition.
        // Defaults to 'attachment', where FILENAME is the specified filename.
        // Note that this does nothing if you are not sending HTTP headers.
        contentDisposition: 'attachment',

        // Output Name for HTTP Content-Disposition
        // Defaults to no name
        outputName: "example.zip",

        // HTTP Content-Type.
        // Defaults to 'application/x-zip'.
        // Note that this does nothing if you are not sending HTTP headers.
        contentType: 'application/x-zip',

        // Set the function called for setting headers.
        // Default is the `header()` of PHP
        httpHeaderCallback: header(...),

        // Enable streaming files with single read where general purpose bit 3
        // indicates local file header contain zero values in crc and size
        // fields, these appear only after file contents in data descriptor
        // block.
        // Set to true if your input stream is remote
        // (used with addFileFromStream()).
        // Default is false.
        defaultEnableZeroHeader: false,

        // Enable zip64 extension, allowing very large archives
        // (> 4Gb or file count > 64k)
        // Default is true
        enableZip64: true,

        // Flush output buffer after every write
        // Default is false
        flushOutput: true,
    );
PK     V_]_L_7  7     zipstream-php/guides/Symfony.rstnu „[µü¤        Usage with Symfony
===============

Overview for using ZipStream in Symfony
--------

Using ZipStream in Symfony requires use of Symfony's ``StreamedResponse`` when
used in controller actions.

Wrap your call to the relevant ``ZipStream`` stream method (i.e. ``addFile``,
``addFileFromPath``, ``addFileFromStream``) in Symfony's ``StreamedResponse``
function passing in any required arguments for your use case.

Using Symfony's ``StreamedResponse`` will allow Symfony to stream output from
ZipStream correctly to users' browsers and avoid a corrupted final zip landing
on the users' end.

Example for using ``ZipStream`` in a controller action to zip stream files
stored in an AWS S3 bucket by key:

.. code-block:: php

    use Symfony\Component\HttpFoundation\StreamedResponse;
    use Aws\S3\S3Client;
    use ZipStream;

    //...

    /**
    * @Route("/zipstream", name="zipstream")
    */
    public function zipStreamAction()
    {
        // sample test file on s3
        $s3keys = array(
        "ziptestfolder/file1.txt"
        );

        $s3Client = $this->get('app.amazon.s3'); //s3client service
        $s3Client->registerStreamWrapper(); //required

        // using StreamedResponse to wrap ZipStream functionality
        // for files on AWS s3.
        $response = new StreamedResponse(function() use($s3keys, $s3Client)
        {
            // Define suitable options for ZipStream Archive.
            // this is needed to prevent issues with truncated zip files
            //initialise zipstream with output zip filename and options.
            $zip = new ZipStream\ZipStream(
                outputName: 'test.zip',
                defaultEnableZeroHeader: true,
                contentType: 'application/octet-stream',
            );

            //loop keys - useful for multiple files
            foreach ($s3keys as $key) {
                // Get the file name in S3 key so we can save it to the zip
                //file using the same name.
                $fileName = basename($key);

                // concatenate s3path.
                // replace with your bucket name or get from parameters file.
                $bucket = 'bucketname';
                $s3path = "s3://" . $bucket . "/" . $key;

                //addFileFromStream
                if ($streamRead = fopen($s3path, 'r')) {
                    $zip->addFileFromStream(
                        fileName: $fileName,
                        stream: $streamRead,
                    );
                } else {
                    die('Could not open stream for reading');
                }
            }

            $zip->finish();

        });

        return $response;
    }

In the above example, files on AWS S3 are being streamed from S3 to the Symfon
application via ``fopen`` call when the s3Client has ``registerStreamWrapper``
applied. This stream is then passed to ``ZipStream`` via the
``addFileFromStream`` function, which ZipStream then streams as a zip to the
client browser via Symfony's ``StreamedResponse``. No Zip is created server
side, which makes this approach a more efficient solution for streaming zips to
the client browser especially for larger files.

For the above use case you will need to have installed
`aws/aws-sdk-php-symfony <https://github.com/aws/aws-sdk-php-symfony>`_ to
support accessing S3 objects in your Symfony web application. This is not
required for locally stored files on you server you intend to stream via
``ZipStream``.

See official Symfony documentation for details on
`Symfony's StreamedResponse <https://symfony.com/doc/current/components/http_foundation.html#streaming-a-response>`_ 
``Symfony\Component\HttpFoundation\StreamedResponse``.

Note from `S3 documentation <https://docs.aws.amazon.com/sdk-for-php/v3/developer-guide/s3-stream-wrapper.html>`_:

    Streams opened in "r" mode only allow data to be read from the stream, and
    are not seekable by default. This is so that data can be downloaded from
    Amazon S3 in a truly streaming manner, where previously read bytes do not
    need to be buffered into memory. If you need a stream to be seekable, you
    can pass seekable into the stream context options of a function.

Make sure to configure your S3 context correctly!

Uploading a file
--------

You need to add correct permissions
(see `#120 <https://github.com/maennchen/ZipStream-PHP/issues/120>`_)

**example code**


.. code-block:: php

    $path = "s3://{$adapter->getBucket()}/{$this->getArchivePath()}";

    // the important bit
    $outputContext = stream_context_create([
        's3' => ['ACL' => 'public-read'],
    ]);

    fopen($path, 'w', null, $outputContext);
PK     V_]\©LY‡  ‡     zipstream-php/guides/Varnish.rstnu „[µü¤        Usage with Varnish
=============

Serving a big zip with varnish in between can cause random stream close.
This can be solved by adding attached code to the vcl file.

To avoid the problem, add the following to your varnish config file:

.. code-block::
    sub vcl_recv {
        # Varnish canâ€™t intercept the discussion anymore
        # helps for streaming big zips
        if (req.url ~ "\.(tar|gz|zip|7z|exe)$") {
            return (pipe);
        }
    }
    # Varnish canâ€™t intercept the discussion anymore
    # helps for streaming big zips
    sub vcl_pipe {
        set bereq.http.connection = "close";
        return (pipe);
    }
PK     V_] k—S¸  ¸    zipstream-php/guides/index.rstnu „[µü¤        ZipStream PHP
=============

A fast and simple streaming zip file downloader for PHP. Using this library will
save you from having to write the Zip to disk. You can directly send it to the
user, which is much faster. It can work with S3 buckets or any PSR7 Stream.

.. toctree::

   index
   Symfony
   Options
   StreamOutput
   FlySystem
   PSR7Streams
   Nginx
   Varnish
   ContentLength

Installation
---------------

Simply add a dependency on ``maennchen/zipstream-php`` to your project's
``composer.json`` file if you use Composer to manage the dependencies of your
project. Use following command to add the package to your project's
dependencies:

.. code-block:: sh
   composer require maennchen/zipstream-php

If you want to use``addFileFromPsr7Stream```
(``Psr\Http\Message\StreamInterface``) or use a stream instead of a
``resource`` as ``outputStream``, the following dependencies must be installed
as well:

.. code-block:: sh
   composer require psr/http-message guzzlehttp/psr7

If ``composer install`` yields the following error, your installation is missing
the `mbstring extension <https://www.php.net/manual/en/book.mbstring.php>`_,
either `install it <https://www.php.net/manual/en/mbstring.installation.php>`_
or run the follwoing command:

.. code-block::
    Your requirements could not be resolved to an installable set of packages.

    Problem 1
        - Root composer.json requires PHP extension ext-mbstring * but it is
          missing from your system. Install or enable PHP's mbstrings extension.

.. code-block:: sh
   composer require symfony/polyfill-mbstring

Usage Intro
---------------

Here's a simple example:

.. code-block:: php

   // Autoload the dependencies
   require 'vendor/autoload.php';

   // create a new zipstream object
   $zip = new ZipStream\ZipStream(
      outputName: 'example.zip',

      // enable output of HTTP headers
      sendHttpHeaders: true,
   );

   // create a file named 'hello.txt'
   $zip->addFile(
      fileName: 'hello.txt',
      data: 'This is the contents of hello.txt',
   );

   // add a file named 'some_image.jpg' from a local file 'path/to/image.jpg'
   $zip->addFileFromPath(
      fileName: 'some_image.jpg',
      path: 'path/to/image.jpg',
   );

   // add a file named 'goodbye.txt' from an open stream resource
   $filePointer = tmpfile();
   fwrite($filePointer, 'The quick brown fox jumped over the lazy dog.');
   rewind($filePointer);
   $zip->addFileFromStream(
      fileName: 'goodbye.txt',
      stream: $filePointer,
   );
   fclose($filePointer);

   // add a file named 'streamfile.txt' from the body of a `guzzle` response
   // Setup with `psr/http-message` & `guzzlehttp/psr7` dependencies required.
   $zip->addFileFromPsr7Stream(
      fileName: 'streamfile.txt',
      stream: $response->getBody(),
   );

   // finish the zip stream
   $zip->finish();

You can also add comments, modify file timestamps, and customize (or
disable) the HTTP headers. It is also possible to specify the storage method
when adding files, the current default storage method is ``DEFLATE``
i.e files are stored with Compression mode 0x08.

Known Issues
---------------

The native Mac OS archive extraction tool prior to macOS 10.15 might not open
archives in some conditions. A workaround is to disable the Zip64 feature with
the option ``enableZip64: false``. This limits the archive to 4 Gb and 64k files
but will allow users on macOS 10.14 and below to open them without issue.
See `#116 <https://github.com/maennchen/ZipStream-PHP/issues/116>`_.

The linux ``unzip`` utility might not handle properly unicode characters.
It is recommended to extract with another tool like
`7-zip <https://www.7-zip.org/>`_.
See `#146 <https://github.com/maennchen/ZipStream-PHP/issues/146>`_.

It is the responsability of the client code to make sure that files are not
saved with the same path, as it is not possible for the library to figure it out
while streaming a zip.
See `#154 <https://github.com/maennchen/ZipStream-PHP/issues/154>`_.
PK     V_]5*œ/  /    zipstream-php/guides/Nginx.rstnu „[µü¤        Usage with nginx
=============

If you are using nginx as a webserver, it will try to buffer the response.
So you'll want to disable this with a custom header:

.. code-block:: php
    header('X-Accel-Buffering: no');
    # or with the Response class from Symfony
    $response->headers->set('X-Accel-Buffering', 'no');

Alternatively, you can tweak the
`fastcgi cache parameters <https://nginx.org/en/docs/http/ngx_http_fastcgi_module.html#fastcgi_buffers>`_
within nginx config.

See `original issue <https://github.com/maennchen/ZipStream-PHP/issues/77>`_.PK     V_]óù9>8  8  %  zipstream-php/guides/StreamOutput.rstnu „[µü¤        Stream Output
===============

Stream to S3 Bucket
---------------

.. code-block:: php

    use Aws\S3\S3Client;
    use Aws\Credentials\CredentialProvider;
    use ZipStream\ZipStream;

    $bucket = 'your bucket name';
    $client = new S3Client([
        'region' => 'your region',
        'version' => 'latest',
        'bucketName' => $bucket,
        'credentials' => CredentialProvider::defaultProvider(),
    ]);
    $client->registerStreamWrapper();

    $zipFile = fopen("s3://$bucket/example.zip", 'w');

    $zip = new ZipStream(
        enableZip64: false,
        outputStream: $zipFile,
    );

    $zip->addFile(
        fileName: 'file1.txt',
        data: 'File1 data',
    );
    $zip->addFile(
        fileName: 'file2.txt',
        data: 'File2 data',
    );
    $zip->finish();

    fclose($zipFile);
PK     V_]äø2à%  %    zipstream-php/.editorconfignu „[µü¤        root = true

[*]
end_of_line = lf
insert_final_newline = true
charset = utf-8

[*.{yml,md,xml}]
indent_style = space
indent_size = 2

[*.{rst,php}]
indent_style = space
indent_size = 4

[composer.json]
indent_style = space
indent_size = 2

[composer.lock]
indent_style = space
indent_size = 4
PK     V_]Žl­    $  zipstream-php/.php-cs-fixer.dist.phpnu „[µü¤        <?php

declare(strict_types=1);

/**
 * PHP-CS-Fixer config for ZipStream-PHP
 * @author Nicolas CARPi <nico-git@deltablot.email>
 * @copyright 2022 Nicolas CARPi
 * @see https://github.com/maennchen/ZipStream-PHP
 * @license MIT
 * @package maennchen/ZipStream-PHP
 */

use PhpCsFixer\Config;
use PhpCsFixer\Finder;

$finder = Finder::create()
    ->exclude('.github')
    ->exclude('.phpdoc')
    ->exclude('docs')
    ->exclude('tools')
    ->exclude('vendor')
    ->in(__DIR__);

$config = new Config();
return $config->setRules([
        '@PER' => true,
        '@PER:risky' => true,
        '@PHP82Migration' => true,
        '@PHPUnit84Migration:risky' => true,
        'array_syntax' => ['syntax' => 'short'],
        'class_attributes_separation' => true,
        'declare_strict_types' => true,
        'dir_constant' => true,
        'is_null' => true,
        'no_homoglyph_names' => true,
        'no_null_property_initialization' => true,
        'no_php4_constructor' => true,
        'no_unused_imports' => true,
        'no_useless_else' => true,
        'non_printable_character' => true,
        'ordered_imports' => true,
        'ordered_class_elements' => true,
        'php_unit_construct' => true,
        'pow_to_exponentiation' => true,
        'psr_autoloading' => true,
        'random_api_migration' => true,
        'return_assignment' => true,
        'self_accessor' => true,
        'semicolon_after_instruction' => true,
        'short_scalar_cast' => true,
        'simplified_null_return' => true,
        'single_class_element_per_statement' => true,
        'single_line_comment_style' => true,
        'single_quote' => true,
        'space_after_semicolon' => true,
        'standardize_not_equals' => true,
        'strict_param' => true,
        'ternary_operator_spaces' => true,
        'trailing_comma_in_multiline' => true,
        'trim_array_spaces' => true,
        'unary_operator_spaces' => true,
        'global_namespace_import' => [
            'import_classes' => true,
            'import_functions' => true,
            'import_constants' => true,
        ],
    ])
    ->setFinder($finder)
    ->setRiskyAllowed(true);
PK     V_]Ç/nJœ   œ     zipstream-php/.gitignorenu „[µü¤        /composer.lock
/cov
/coverage.clover.xml
/docs
.idea
/.php-cs-fixer.cache
/.phpdoc/cache
/.phpunit.result.cache
/phpunit.xml
/.phpunit.cache
/tools
/vendor
PK     V_]²ô‡      zipstream-php/README.mdnu „[µü¤        # ZipStream-PHP

[![Main Branch](https://github.com/maennchen/ZipStream-PHP/actions/workflows/branch_main.yml/badge.svg)](https://github.com/maennchen/ZipStream-PHP/actions/workflows/branch_main.yml)
[![Coverage Status](https://coveralls.io/repos/github/maennchen/ZipStream-PHP/badge.svg?branch=main)](https://coveralls.io/github/maennchen/ZipStream-PHP?branch=main)
[![Latest Stable Version](https://poser.pugx.org/maennchen/zipstream-php/v/stable)](https://packagist.org/packages/maennchen/zipstream-php)
[![Total Downloads](https://poser.pugx.org/maennchen/zipstream-php/downloads)](https://packagist.org/packages/maennchen/zipstream-php)
[![Financial Contributors on Open Collective](https://opencollective.com/zipstream/all/badge.svg?label=financial+contributors)](https://opencollective.com/zipstream) [![License](https://img.shields.io/github/license/maennchen/zipstream-php.svg)](LICENSE)
[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/9524/badge)](https://www.bestpractices.dev/projects/9524)
[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/maennchen/ZipStream-PHP/badge)](https://scorecard.dev/viewer/?uri=github.com/maennchen/ZipStream-PHP)

## Unstable Branch

The `main` branch is not stable. Please see the
[releases](https://github.com/maennchen/ZipStream-PHP/releases) for a stable
version.

## Overview

A fast and simple streaming zip file downloader for PHP. Using this library will
save you from having to write the Zip to disk. You can directly send it to the
user, which is much faster. It can work with S3 buckets or any PSR7 Stream.

Please see the [LICENSE](LICENSE) file for licensing and warranty information.

## Installation

Simply add a dependency on maennchen/zipstream-php to your project's
`composer.json` file if you use Composer to manage the dependencies of your
project. Use following command to add the package to your project's dependencies:

```bash
composer require maennchen/zipstream-php
```

## Usage

For detailed instructions, please check the
[Documentation](https://maennchen.github.io/ZipStream-PHP/).

```php
// Autoload the dependencies
require 'vendor/autoload.php';

// create a new zipstream object
$zip = new ZipStream\ZipStream(
    outputName: 'example.zip',

    // enable output of HTTP headers
    sendHttpHeaders: true,
);

// create a file named 'hello.txt'
$zip->addFile(
    fileName: 'hello.txt',
    data: 'This is the contents of hello.txt',
);

// add a file named 'some_image.jpg' from a local file 'path/to/image.jpg'
$zip->addFileFromPath(
    fileName: 'some_image.jpg',
    path: 'path/to/image.jpg',
);

// finish the zip stream
$zip->finish();
```

## Upgrade to version 3.0.0

### General

- Minimum PHP Version: `8.1`
- Only 64bit Architecture is supported.
- The class `ZipStream\Option\Method` has been replaced with the enum
  `ZipStream\CompressionMethod`.
- Most clases have been flagged as `@internal` and should not be used from the
  outside.
  If you're using internal resources to extend this library, please open an
  issue so that a clean interface can be added & published.
  The externally available classes & enums are:
  - `ZipStream\CompressionMethod`
  - `ZipStream\Exception*`
  - `ZipStream\ZipStream`

### Archive Options

- The class `ZipStream\Option\Archive` has been replaced in favor of named
  arguments in the `ZipStream\ZipStream` constuctor.
- The archive options `largeFileSize` & `largeFileMethod` has been removed. If
  you want different `compressionMethods` based on the file size, you'll have to
  implement this yourself.
- The archive option `httpHeaderCallback` changed the type from `callable` to
  `Closure`.
- The archive option `zeroHeader` has been replaced with the option
  `defaultEnableZeroHeader` and can be overridden for every file. Its default
  value changed from `false` to `true`.
- The archive option `statFiles` was removed since the library no longer checks
  filesizes this way.
- The archive option `deflateLevel` has been replaced with the option
  `defaultDeflateLevel` and can be overridden for every file.
- The first argument (`name`) of the `ZipStream\ZipStream` constuctor has been
  replaced with the named argument `outputName`.
- Headers are now also sent if the `outputName` is empty. If you do not want to
  automatically send http headers, set `sendHttpHeaders` to `false`.

### File Options

- The class `ZipStream\Option\File` has been replaced in favor of named
  arguments in the `ZipStream\ZipStream->addFile*` functions.
- The file option `method` has been renamed to `compressionMethod`.
- The file option `time` has been renamed to `lastModificationDateTime`.
- The file option `size` has been renamed to `maxSize`.

## Upgrade to version 2.0.0

https://github.com/maennchen/ZipStream-PHP/tree/2.0.0#upgrade-to-version-200

## Upgrade to version 1.0.0

https://github.com/maennchen/ZipStream-PHP/tree/2.0.0#upgrade-to-version-100

## Contributing

ZipStream-PHP is a collaborative project. Please take a look at the
[.github/CONTRIBUTING.md](.github/CONTRIBUTING.md) file.

## Version Support

Versions are supported according to the table below.

Please do not open any pull requests contradicting the current version support
status.

Careful: Always check the `README` on `main` for up-to-date information.

| Version | New Features | Bugfixes | Security |
|---------|--------------|----------|----------|
| *3*     | âœ“            | âœ“        | âœ“        |
| *2*     | âœ—            | âœ—        | âœ“        |
| *1*     | âœ—            | âœ—        | âœ—        |
| *0*     | âœ—            | âœ—        | âœ—        |

This library aligns itself with the PHP core support. New features and bugfixes
will only target PHP versions according to their current status.

See: https://www.php.net/supported-versions.php

## About the Authors

- Paul Duncan <pabs@pablotron.org> - https://pablotron.org/
- Jonatan MÃ¤nnchen <jonatan@maennchen.ch> - https://maennchen.dev
- Jesse G. Donat <donatj@gmail.com> - https://donatstudios.com
- Nicolas CARPi <nico-git@deltablot.email> - https://www.deltablot.com
- Nik Barham <nik@brokencube.co.uk> - https://www.brokencube.co.uk
PK     V_]‹"Ñ‚  ‚    zipstream-php/psalm.xmlnu „[µü¤        <?xml version="1.0"?>
<psalm
    errorLevel="1"
    resolveFromConfigFile="true"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="https://getpsalm.org/schema/config"
    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
    findUnusedBaselineEntry="true"
    findUnusedCode="true"
    phpVersion="8.1.0"
>
    <!-- TODO: Update phpVersion when raising the minimum supported version -->
    <projectFiles>
        <directory name="src" />
        <ignoreFiles>
            <directory name="vendor" />
        </ignoreFiles>
    </projectFiles>
    <issueHandlers>
        <!-- Turn off dead code warnings for externally called functions -->
        <PossiblyUnusedProperty errorLevel="suppress" />
        <PossiblyUnusedMethod errorLevel="suppress" />
        <PossiblyUnusedReturnValue errorLevel="suppress" />
    </issueHandlers>
</psalm>
PK     V_]d¾77N	  N	    zipstream-php/composer.jsonnu „[µü¤        {
  "name": "maennchen/zipstream-php",
  "description": "ZipStream is a library for dynamically streaming dynamic zip files from PHP without writing to the disk at all on the server.",
  "keywords": ["zip", "stream"],
  "type": "library",
  "license": "MIT",
  "authors": [{
      "name": "Paul Duncan",
      "email": "pabs@pablotron.org"
    },
    {
      "name": "Jonatan MÃ¤nnchen",
      "email": "jonatan@maennchen.ch"
    },
    {
      "name": "Jesse Donat",
      "email": "donatj@gmail.com"
    },
    {
      "name": "AndrÃ¡s KolesÃ¡r",
      "email": "kolesar@kolesar.hu"
    }
  ],
  "require": {
    "php-64bit": "^8.1",
    "ext-mbstring": "*",
    "ext-zlib": "*"
  },
  "require-dev": {
    "phpunit/phpunit": "^10.0",
    "guzzlehttp/guzzle": "^7.5",
    "ext-zip": "*",
    "mikey179/vfsstream": "^1.6",
    "php-coveralls/php-coveralls": "^2.5",
    "friendsofphp/php-cs-fixer": "^3.16",
    "vimeo/psalm": "^5.0"
  },
  "suggest": {
    "psr/http-message": "^2.0",
    "guzzlehttp/psr7": "^2.4"
  },
  "scripts": {
    "format": "php-cs-fixer fix",
    "test": [
      "@test:unit",
      "@test:formatted",
      "@test:lint"
    ],
    "test:unit": "phpunit --coverage-clover=coverage.clover.xml --coverage-html cov",
    "test:unit:slow": "@test:unit --group slow",
    "test:unit:fast": "@test:unit --exclude-group slow",
    "test:formatted": "@format --dry-run --stop-on-violation --using-cache=no",
    "test:lint": "psalm --stats --show-info=true --find-unused-psalm-suppress",
    "coverage:report": "php-coveralls --coverage_clover=coverage.clover.xml --json_path=coveralls-upload.json --insecure",
    "install:tools": "phive install --trust-gpg-keys 0x67F861C3D889C656 --trust-gpg-keys 0x8AC0BAA79732DD42",
    "docs:generate": "tools/phpdocumentor --sourcecode"
  },
  "autoload": {
    "psr-4": {
      "ZipStream\\": "src/"
    }
  },
  "autoload-dev": {
    "psr-4": { "ZipStream\\Test\\": "test/" }
  },
  "archive": {
    "exclude": [
      "/composer.lock",
      "/docs",
      "/.gitattributes",
      "/.github",
      "/.gitignore",
      "/guides",
      "/.phive",
      "/.php-cs-fixer.cache",
      "/.php-cs-fixer.dist.php",
      "/.phpdoc",
      "/phpdoc.dist.xml",
      "/.phpunit.result.cache",
      "/phpunit.xml.dist",
      "/psalm.xml",
      "/test",
      "/tools",
      "/.tool-versions",
      "/vendor"
    ]
  }
}
PK     V_]ß{ï   ï     zipstream-php/results.sarifnu „[µü¤        {"version":"2.1.0","$schema":"https:\/\/json.schemastore.org\/sarif-2.1.0.json","runs":[{"tool":{"driver":{"name":"Psalm","informationUri":"https:\/\/psalm.dev","version":"5.26.1@d747f6500b38ac4f7dfc5edbcae6e4b637d7add0"}},"results":[]}]}
PK     V_]Hî­ì’   ’     zipstream-php/.gitattributesnu „[µü¤        .gitignore     text eol=lf
.gitattributes text eol=lf
*.md       text eol=lf
*.php      text eol=lf
*.yml      text eol=lf
*.xml      text eol=lf
PK     V_]Šì×.
  
    zipstream-php/phpdoc.dist.xmlnu „[µü¤        <?xml version="1.0" encoding="UTF-8" ?>
<phpdocumentor
        configVersion="3"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="https://www.phpdoc.org"
        xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/phpDocumentor/phpDocumentor/master/data/xsd/phpdoc.xsd"
>
    <title>ðŸ’¾ ZipStream-PHP</title>
    <paths>
        <output>docs</output>
    </paths>
    <version number="3.0.0">
        <folder>latest</folder>
        <api>
            <source dsn=".">
                <path>src</path>
            </source>
            <output>api</output>
            <ignore hidden="true" symlinks="true">
                <path>tests/**/*</path>
                <path>vendor/**/*</path>
            </ignore>
            <extensions>
                <extension>php</extension>
            </extensions>
            <visibility>public</visibility>
            <default-package-name>ZipStream</default-package-name>
            <include-source>true</include-source>
        </api>
        <guide>
            <source dsn=".">
                <path>guides</path>
            </source>
            <output>guide</output>
        </guide>
    </version>
    <setting name="guides.enabled" value="true"/>
    <template name="default" />
</phpdocumentor>PK     V_]ò ˆñ
   
     zipstream-php/.tool-versionsnu „[µü¤        php 8.3.1
PK     V_]M¥ØÅñ  ñ    zipstream-php/LICENSEnu „[µü¤        MIT License

Copyright (C) 2007-2009 Paul Duncan <pabs@pablotron.org>
Copyright (C) 2014 Jonatan MÃ¤nnchen <jonatan@maennchen.ch>
Copyright (C) 2014 Jesse G. Donat <donatj@gmail.com>
Copyright (C) 2018 Nicolas CARPi <nicolas.carpi@curie.fr>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
PK     V_]<©˜žÞ  Þ    zipstream-php/phpunit.xml.distnu „[µü¤        <?xml version="1.0"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" bootstrap="test/bootstrap.php" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.1/phpunit.xsd" cacheDirectory=".phpunit.cache">
  <coverage/>
  <testsuites>
    <testsuite name="Application">
      <directory>test</directory>
    </testsuite>
  </testsuites>
  <logging/>
  <source>
    <include>
      <directory suffix=".php">src</directory>
    </include>
  </source>
</phpunit>
PK       V_]q['    6                zipstream-php/test/Zip64/EndOfCentralDirectoryTest.phpnu „[µü¤        PK       V_]¥ZXH5  5  /            q  zipstream-php/test/Zip64/DataDescriptorTest.phpnu „[µü¤        PK       V_]gNÛé    >              zipstream-php/test/Zip64/ExtendedInformationExtraFieldTest.phpnu „[µü¤        PK       V_]¨²øåØ  Ø  =            ò  zipstream-php/test/Zip64/EndOfCentralDirectoryLocatorTest.phpnu „[µü¤        PK       V_]‡¢Rˆ    ;            7  zipstream-php/test/Zs/ExtendedInformationExtraFieldTest.phpnu „[µü¤        PK       V_]Z ×5  5              ±  zipstream-php/test/Util.phpnu „[µü¤        PK       V_]ºw„,j  j  0            1%  zipstream-php/test/EndOfCentralDirectoryTest.phpnu „[µü¤        PK       V_]9ÛúÉ  É  *            û*  zipstream-php/test/LocalFileHeaderTest.phpnu „[µü¤        PK       V_]Sýê  ê  )            2  zipstream-php/test/EndlessCycleStream.phpnu „[µü¤        PK       V_]ŽEwÚ  Ú  )            a:  zipstream-php/test/DataDescriptorTest.phpnu „[µü¤        PK       V_]q@Uß  ß              ”=  zipstream-php/test/TimeTest.phpnu „[µü¤        PK       V_]q
PÜq   q                ÂB  zipstream-php/test/bootstrap.phpnu „[µü¤        PK       V_]	Š0êÚ  Ú  5            ƒC  zipstream-php/test/CentralDirectoryFileHeaderTest.phpnu „[µü¤        PK       V_]>›Ó¿s  s  -            ÂL  zipstream-php/test/FaultInjectionResource.phpnu „[µü¤        PK       V_]“=    !            ’Y  zipstream-php/test/Assertions.phpnu „[µü¤        PK       V_]tÅÿJ  J              ÿ]  zipstream-php/test/Tempfile.phpnu „[µü¤        PK       V_]k­Ÿ­Þ“  Þ“  $            ˜a  zipstream-php/test/ZipStreamTest.phpnu „[µü¤        PK       V_]ba=z®  ®  $            Êõ  zipstream-php/test/PackFieldTest.phpnu „[µü¤        PK       V_]²ÌÊÙq  q  %            Ìù  zipstream-php/test/ResourceStream.phpnu „[µü¤        PK       V_]EµÆ   Æ               ’	 zipstream-php/.phive/phars.xmlnu „[µü¤        PK       V_]ÃnÀt‡  ‡  ;            ¦
 zipstream-php/.github/PULL_REQUEST_TEMPLATE/FAILING_TEST.mdnu „[µü¤        PK       V_]Txšl  l  2            ˜ zipstream-php/.github/PULL_REQUEST_TEMPLATE/FIX.mdnu „[µü¤        PK       V_]–f Ñ   Ñ   :            f zipstream-php/.github/PULL_REQUEST_TEMPLATE/NEW_FEATURE.mdnu „[µü¤        PK       V_]‰a2´²   ²   :            ¡ zipstream-php/.github/PULL_REQUEST_TEMPLATE/IMPROVEMENT.mdnu „[µü¤        PK       V_]<z*Èð  ð  ,            ½ zipstream-php/.github/ISSUE_TEMPLATE/BUG.ymlnu „[µü¤        PK       V_].Q½ôD  D  0            	 zipstream-php/.github/ISSUE_TEMPLATE/FEATURE.ymlnu „[µü¤        PK       V_]#xÌéÜ  Ü  -            ­ zipstream-php/.github/workflows/scorecard.ymlnu „[µü¤        PK       V_]C”	  	  .            æ' zipstream-php/.github/workflows/tag-stable.ymlnu „[µü¤        PK       V_]vÌ    -            M, zipstream-php/.github/workflows/part_docs.ymlnu „[µü¤        PK       V_]Èº«  «  3            ­2 zipstream-php/.github/workflows/part_dependabot.ymlnu „[µü¤        PK       V_]Ó}‘3C  C  -            »5 zipstream-php/.github/workflows/part_test.ymlnu „[µü¤        PK       V_]MÔYr5  5  /            [O zipstream-php/.github/workflows/branch_main.ymlnu „[µü¤        PK       V_]<ôÚ    &            ïP zipstream-php/.github/workflows/pr.ymlnu „[µü¤        PK       V_]ôõo	  o	  0            \U zipstream-php/.github/workflows/part_release.ymlnu „[µü¤        PK       V_]®+/Ø²  ²  ,            +_ zipstream-php/.github/workflows/tag-beta.ymlnu „[µü¤        PK       V_]8Òfæ      !            9a zipstream-php/.github/FUNDING.ymlnu „[µü¤        PK       V_]îDˆ    $            œa zipstream-php/.github/dependabot.ymlnu „[µü¤        PK       V_]hÆþ=  =  #            c zipstream-php/.github/scorecard.ymlnu „[µü¤        PK       V_]âe38  8  !            –d zipstream-php/.github/SECURITY.mdnu „[µü¤        PK       V_]v÷W    .            j zipstream-php/.github/PULL_REQUEST_TEMPLATE.mdnu „[µü¤        PK       V_]ŒÕù8ô  ô  %            œk zipstream-php/.github/CONTRIBUTING.mdnu „[µü¤        PK       V_]–‚lm  m  (            å} zipstream-php/.github/CODE_OF_CONDUCT.mdnu „[µü¤        PK       V_]èY‚²  ²  -            ª“ zipstream-php/.phpdoc/template/base.html.twignu „[µü¤        PK       V_]I]U§â  â  >            ¹– zipstream-php/src/Exception/SimulationFileUnknownException.phpnu „[µü¤        PK       V_]Ù°93  3  7            	™ zipstream-php/src/Exception/ResourceActionException.phpnu „[µü¤        PK       V_]öÑÛî  î  8            £› zipstream-php/src/Exception/DosTimeOverflowException.phpnu „[µü¤        PK       V_]e‚¹.    8            ù zipstream-php/src/Exception/FileNotReadableException.phpnu „[µü¤        PK       V_]'A„Û‹  ‹  5            ñŸ zipstream-php/src/Exception/FileNotFoundException.phpnu „[µü¤        PK       V_])ž¡«  «  :            á¡ zipstream-php/src/Exception/StreamNotSeekableException.phpnu „[µü¤        PK       V_](¨”Ô    1            ö£ zipstream-php/src/Exception/OverflowException.phpnu „[µü¤        PK       V_]Ó¶Û”a  a  :            ç¥ zipstream-php/src/Exception/StreamNotReadableException.phpnu „[µü¤        PK       V_]jâ>¬    :            ²§ zipstream-php/src/Exception/FileSizeIncorrectException.phpnu „[µü¤        PK       V_]$!ú<&  &  1            #ª zipstream-php/src/Zip64/EndOfCentralDirectory.phpnu „[µü¤        PK       V_]@$è)  )  8            ª° zipstream-php/src/Zip64/EndOfCentralDirectoryLocator.phpnu „[µü¤        PK       V_]y×pˆ  ˆ  *            ;´ zipstream-php/src/Zip64/DataDescriptor.phpnu „[µü¤        PK       V_]á5ýOJ  J  9            · zipstream-php/src/Zip64/ExtendedInformationExtraField.phpnu „[µü¤        PK       V_]ÚkÍÿ‘  ‘  6            Ð¼ zipstream-php/src/Zs/ExtendedInformationExtraField.phpnu „[µü¤        PK       V_]ï_íJZ  Z  '            Ç¾ zipstream-php/src/CompressionMethod.phpnu „[µü¤        PK       V_]+vÛ(ƒ4  ƒ4              xÇ zipstream-php/src/File.phpnu „[µü¤        PK       V_]T¹)ã  ã  +            Eü zipstream-php/src/EndOfCentralDirectory.phpnu „[µü¤        PK       V_]U1/t²   ²               ƒ zipstream-php/src/Version.phpnu „[µü¤        PK       V_]Úá¸0                ‚ zipstream-php/src/Time.phpnu „[µü¤        PK       V_]/Íl¦  ¦  0            Ð zipstream-php/src/CentralDirectoryFileHeader.phpnu „[µü¤        PK       V_]|øZ)h  h  $            Ö zipstream-php/src/DataDescriptor.phpnu „[µü¤        PK       V_]%ù}–#  #  #            ’ zipstream-php/src/OperationMode.phpnu „[µü¤        PK       V_]÷Ôu‡l  ‡l               zipstream-php/src/ZipStream.phpnu „[µü¤        PK       V_]
ø $?  ?  %            Þ zipstream-php/src/LocalFileHeader.phpnu „[µü¤        PK       V_]^¼  ¼              r‡ zipstream-php/src/PackField.phpnu „[µü¤        PK       V_]È5¸‹	  ‹	  +            } zipstream-php/src/GeneralPurposeBitFlag.phpnu „[µü¤        PK       V_]Ù1üf   f               c— zipstream-php/src/Exception.phpnu „[µü¤        PK       V_]øû±S\  \  &            ˜ zipstream-php/guides/ContentLength.rstnu „[µü¤        PK       V_]Ížö´    $            Ê zipstream-php/guides/PSR7Streams.rstnu „[µü¤        PK       V_]çx608  8  "            8  zipstream-php/guides/FlySystem.rstnu „[µü¤        PK       V_]öŠö|°  °               Â¤ zipstream-php/guides/Options.rstnu „[µü¤        PK       V_]_L_7  7               Â­ zipstream-php/guides/Symfony.rstnu „[µü¤        PK       V_]\©LY‡  ‡               IÀ zipstream-php/guides/Varnish.rstnu „[µü¤        PK       V_] k—S¸  ¸               Ã zipstream-php/guides/index.rstnu „[µü¤        PK       V_]5*œ/  /              &Ó zipstream-php/guides/Nginx.rstnu „[µü¤        PK       V_]óù9>8  8  %            £Õ zipstream-php/guides/StreamOutput.rstnu „[µü¤        PK       V_]äø2à%  %              0Ù zipstream-php/.editorconfignu „[µü¤        PK       V_]Žl­    $             Ú zipstream-php/.php-cs-fixer.dist.phpnu „[µü¤        PK       V_]Ç/nJœ   œ               uã zipstream-php/.gitignorenu „[µü¤        PK       V_]²ô‡                Yä zipstream-php/README.mdnu „[µü¤        PK       V_]‹"Ñ‚  ‚              ¼ü zipstream-php/psalm.xmlnu „[µü¤        PK       V_]d¾77N	  N	              …  zipstream-php/composer.jsonnu „[µü¤        PK       V_]ß{ï   ï               
 zipstream-php/results.sarifnu „[µü¤        PK       V_]Hî­ì’   ’               X zipstream-php/.gitattributesnu „[µü¤        PK       V_]Šì×.
  
              6 zipstream-php/phpdoc.dist.xmlnu „[µü¤        PK       V_]ò ˆñ
   
                zipstream-php/.tool-versionsnu „[µü¤        PK       V_]M¥ØÅñ  ñ              ã zipstream-php/LICENSEnu „[µü¤        PK       V_]<©˜žÞ  Þ               zipstream-php/phpunit.xml.distnu „[µü¤        PK    [ [ G%  E   