fix psalm

Merge tag '4.0.2' into develop
Tagging version 4.0.2 4.0.2
2025-08-14 03:05:02 +02:00 · 2022-06-19 11:27:45 +03:00 · 2022-06-17 14:17:46 +03:00 · 2022-06-17 14:17:46 +03:00 · 2021-12-12 13:42:46 +03:00 · 2021-12-12 12:50:55 +03:00
169 changed files with 24808 additions and 9586 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,11 @@
+.gitattributes export-ignore
+.github export-ignore
+.gitignore export-ignore
+.php_cs export-ignore
+bootstrap.php export-ignore
+logo.svg export-ignore
+phpunit.xml export-ignore
+phpunit.xml.dist export-ignore
+psalm.xml export-ignore
+psalm.xml.dist export-ignore
+tests export-ignore
--- a/.github/ISSUE_TEMPLATE/1_Bug_report.md
+++ b/.github/ISSUE_TEMPLATE/1_Bug_report.md
@@ -0,0 +1,23 @@
+---
+name: 🔴 Bug Report
+about: Report errors and problems
+
+---
+
+| Q                            | A
+| -----------------------------| ---
+| Library version(s) affected: | x.y.z
+| PHP version(s):              | x.y.z
+| OS (with bit depth):         | <!-- ex. Ubuntu 18.04 64-bit -->
+
+**Description**  
+<!-- A clear and concise description of the problem. -->
+
+**How to reproduce**  
+<!-- Code to reproduce the problem. -->
+
+**Possible Solution**  
+<!--- Optional: only if you have suggestions on a fix/reason for the bug -->
+
+**Additional context**  
+<!-- Optional: any other context about the problem: error messages, stack trace, zip files, etc. -->
--- a/.github/ISSUE_TEMPLATE/2_Feature_request.md
+++ b/.github/ISSUE_TEMPLATE/2_Feature_request.md
@@ -0,0 +1,12 @@
+---
+name: 🚀 Feature Request
+about: Ideas for new features and improvements
+
+---
+
+**Description**  
+<!-- A clear and concise description of the new feature. -->
+
+**Example**  
+<!-- A simple example of the new feature in action (include PHP code)
+     If the new feature changes an existing feature, include a simple before/after comparison. -->
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,12 @@
+| Q             | A
+| ------------- | ---
+| Bug fix?      | yes/no
+| New feature?  | yes/no <!-- don't forget to update CHANGELOG.md file -->
+
+<!--
+Write a short README entry for your feature/bugfix here (replace this comment block.)
+
+Do NOT send pull request to `master` branch.
+Please send to `develop` branch instead.
+Any PR to `master` branch will NOT be merged.
+-->
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -0,0 +1,132 @@
+name: build
+
+on:
+    - push
+    - pull_request
+
+jobs:
+    tests:
+        name:    PHP ${{ matrix.php }} Test on ${{ matrix.os }}
+
+        env:
+            extensions:       bz2, dom, iconv, fileinfo, openssl, xml, zlib
+            key:              cache-v1
+            PHPUNIT_COVERAGE: 0
+            PHP_INI:          date.timezone='UTC', memory_limit=-1, opcache.enable=1, opcache.enable_cli=1
+
+        strategy:
+            matrix:
+                os:
+                    - ubuntu-latest
+                    - windows-latest
+                    - macos-latest
+                php:
+                    - '7.4'
+                    - '8.0'
+                    - '8.1'
+
+        runs-on: ${{ matrix.os }}
+
+        steps:
+            -
+                name: Checkout
+                uses: actions/checkout@v1
+
+            -
+                name: Install linux dependencies
+                if:   matrix.os == 'ubuntu-latest'
+                run:  sudo apt-get install unzip p7zip-full
+
+            -
+                name: Install windows dependencies
+                if:   matrix.os == 'windows-latest'
+                run:  choco install zip unzip 7zip
+
+            -
+                name: Install macos dependencies
+                if:   matrix.os == 'macos-latest'
+                run:  brew install zip unzip p7zip
+
+            -
+                name: Disable JIT for PHP 8 on Linux and Mac
+                if:   (matrix.os == 'ubuntu-latest' || matrix.os == 'macos-latest') && matrix.php != '7.4'
+                run:  echo "PHP_INI=\"${PHP_INI}, opcache.jit=0, opcache.jit_buffer_size=0\"" >> $GITHUB_ENV
+
+            -
+                name: Disable JIT for PHP 8 on Windows
+                if:   matrix.os == 'windows-latest' && matrix.php != '7.4'
+                run:  echo "PHP_INI=\"$PHP_INI, opcache.jit=0, opcache.jit_buffer_size=0\"" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+            -
+                name: Install PHP with extensions
+                uses: shivammathur/setup-php@v2
+                with:
+                    php-version: ${{ matrix.php }}
+                    extensions:  ${{ env.extensions }}
+                    coverage:    pcov
+                    ini-values:  ${{ env.PHP_INI }}
+                    tools:       composer:v2, cs2pr
+
+            -
+                name: Determine composer cache directory on Linux or MacOS
+                if:   matrix.os == 'ubuntu-latest' || matrix.os == 'macos-latest'
+                run:  echo "COMPOSER_CACHE_DIR=$(composer config cache-dir)" >> $GITHUB_ENV
+
+            -
+                name: Determine composer cache directory on Windows
+                if:   matrix.os == 'windows-latest'
+                run:  echo "COMPOSER_CACHE_DIR=~\AppData\Local\Composer" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+            -
+                name: Set coverage args
+                if:   matrix.os == 'ubuntu-latest' && matrix.php == '7.4'
+                run:  echo "PHPUNIT_COVERAGE=1" >> $GITHUB_ENV
+
+            -
+                name: Cache composer dependencies
+                uses: actions/cache@v2
+                with:
+                    path:         ${{ env.COMPOSER_CACHE_DIR }}
+                    key:          php${{ matrix.php }}-composer-${{ hashFiles('**/composer.json') }}
+                    restore-keys: php${{ matrix.php }}-composer-
+
+            -
+                name: Check PHP Version
+                run:  php -v
+
+            -
+                name: Check Composer Version
+                run:  composer -V
+
+            -
+                name: Check PHP Extensions
+                run:  php -m
+
+            -
+                name: Validate composer.json and composer.lock
+                run:  composer validate
+
+            -
+                name: Install dependencies with composer
+                run:  composer update --prefer-dist --no-interaction --no-progress --optimize-autoloader --ansi
+
+            -
+                name: Run tests with phpunit
+                if:   env.PHPUNIT_COVERAGE == 0
+                run:  vendor/bin/phpunit -v --testsuite "all_tests" --group small,medium,large
+
+            -
+                name: Run tests with phpunit and coverage
+                if:   env.PHPUNIT_COVERAGE == 1
+                run:  vendor/bin/phpunit -v --coverage-clover=coverage.clover --testsuite "all_tests" --group small,medium,large
+
+            -
+                name: Static analysis
+                run:  vendor/bin/psalm --shepherd --stats --output-format=checkstyle | cs2pr --graceful-warnings --colorize
+
+            -
+                name: Upload code coverage scrutinizer
+                if:   env.PHPUNIT_COVERAGE == 1
+                run:  |
+                      wget https://scrutinizer-ci.com/ocular.phar
+                      php ocular.phar code-coverage:upload --format=php-clover coverage.clover
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,6 @@
-/vendor
-*.iml
 /.idea
-/composer.lock
+build/
+/vendor
+*.cache
+composer.lock
+psalm.xml
--- a/.php-cs-fixer.php
+++ b/.php-cs-fixer.php
--- a/.phpstorm.meta.php
+++ b/.phpstorm.meta.php
@@ -0,0 +1,134 @@
+<?php
+
+namespace PHPSTORM_META {
+
+    registerArgumentsSet(
+        "bool",
+        true,
+        false
+    );
+
+    registerArgumentsSet(
+        "compression_methods",
+        \PhpZip\Constants\ZipCompressionMethod::STORED,
+        \PhpZip\Constants\ZipCompressionMethod::DEFLATED,
+        \PhpZip\Constants\ZipCompressionMethod::BZIP2
+    );
+    expectedArguments(\PhpZip\ZipFile::addFile(), 2, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFromStream(), 2, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFromString(), 2, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addDir(), 2, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addDirRecursive(), 2, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFilesFromIterator(), 2, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFilesFromIterator(), 2, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFilesFromGlob(), 3, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFilesFromGlobRecursive(), 3, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFilesFromRegex(), 3, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::addFilesFromRegexRecursive(), 3, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\ZipFile::setCompressionMethodEntry(), 1, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\Model\ZipEntry::setCompressionMethod(), 0, argumentsSet("compression_methods"));
+    expectedArguments(\PhpZip\Model\ZipEntry::setMethod(), 0, argumentsSet("compression_methods"));
+
+    registerArgumentsSet(
+        'compression_levels',
+        \PhpZip\Constants\ZipCompressionLevel::MAXIMUM,
+        \PhpZip\Constants\ZipCompressionLevel::NORMAL,
+        \PhpZip\Constants\ZipCompressionLevel::FAST,
+        \PhpZip\Constants\ZipCompressionLevel::SUPER_FAST
+    );
+    expectedArguments(\PhpZip\ZipFile::setCompressionLevel(), 0, argumentsSet("compression_levels"));
+    expectedArguments(\PhpZip\ZipFile::setCompressionLevelEntry(), 1, argumentsSet("compression_levels"));
+    expectedArguments(\PhpZip\Model\ZipEntry::setCompressionLevel(), 0, argumentsSet("compression_levels"));
+
+    registerArgumentsSet(
+        'encryption_methods',
+        \PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_256,
+        \PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_192,
+        \PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_128,
+        \PhpZip\Constants\ZipEncryptionMethod::PKWARE
+    );
+    expectedArguments(\PhpZip\ZipFile::setPassword(), 1, argumentsSet("encryption_methods"));
+    expectedArguments(\PhpZip\ZipFile::setPasswordEntry(), 2, argumentsSet("encryption_methods"));
+    expectedArguments(\PhpZip\Model\ZipEntry::setEncryptionMethod(), 0, argumentsSet("encryption_methods"));
+    expectedArguments(\PhpZip\Model\ZipEntry::setPassword(), 1, argumentsSet("encryption_methods"));
+
+    registerArgumentsSet(
+        'zip_mime_types',
+        null,
+        'application/zip',
+        'application/vnd.android.package-archive',
+        'application/java-archive'
+    );
+    expectedArguments(\PhpZip\ZipFile::outputAsAttachment(), 1, argumentsSet("zip_mime_types"));
+    expectedArguments(\PhpZip\ZipFile::outputAsAttachment(), 2, argumentsSet("bool"));
+
+    expectedArguments(\PhpZip\ZipFile::outputAsResponse(), 2, argumentsSet("zip_mime_types"));
+    expectedArguments(\PhpZip\ZipFile::outputAsResponse(), 3, argumentsSet("bool"));
+
+    expectedArguments(\PhpZip\ZipFile::outputAsPsr7Response(), 2, argumentsSet("zip_mime_types"));
+    expectedArguments(\PhpZip\ZipFile::outputAsPsr7Response(), 3, argumentsSet("bool"));
+
+    expectedArguments(\PhpZip\ZipFile::outputAsSymfonyResponse(), 1, argumentsSet("zip_mime_types"));
+    expectedArguments(\PhpZip\ZipFile::outputAsSymfonyResponse(), 2, argumentsSet("bool"));
+
+    registerArgumentsSet(
+        'dos_charset',
+        \PhpZip\Constants\DosCodePage::CP_LATIN_US,
+        \PhpZip\Constants\DosCodePage::CP_GREEK,
+        \PhpZip\Constants\DosCodePage::CP_BALT_RIM,
+        \PhpZip\Constants\DosCodePage::CP_LATIN1,
+        \PhpZip\Constants\DosCodePage::CP_LATIN2,
+        \PhpZip\Constants\DosCodePage::CP_CYRILLIC,
+        \PhpZip\Constants\DosCodePage::CP_TURKISH,
+        \PhpZip\Constants\DosCodePage::CP_PORTUGUESE,
+        \PhpZip\Constants\DosCodePage::CP_ICELANDIC,
+        \PhpZip\Constants\DosCodePage::CP_HEBREW,
+        \PhpZip\Constants\DosCodePage::CP_CANADA,
+        \PhpZip\Constants\DosCodePage::CP_ARABIC,
+        \PhpZip\Constants\DosCodePage::CP_NORDIC,
+        \PhpZip\Constants\DosCodePage::CP_CYRILLIC_RUSSIAN,
+        \PhpZip\Constants\DosCodePage::CP_GREEK2,
+        \PhpZip\Constants\DosCodePage::CP_THAI
+    );
+    expectedArguments(\PhpZip\Model\ZipEntry::setCharset(), 0, argumentsSet('dos_charset'));
+    expectedArguments(\PhpZip\Constants\DosCodePage::toUTF8(), 1, argumentsSet('dos_charset'));
+    expectedArguments(\PhpZip\Constants\DosCodePage::fromUTF8(), 1, argumentsSet('dos_charset'));
+
+    registerArgumentsSet(
+        "zip_os",
+        \PhpZip\Constants\ZipPlatform::OS_UNIX,
+        \PhpZip\Constants\ZipPlatform::OS_DOS,
+        \PhpZip\Constants\ZipPlatform::OS_MAC_OSX
+    );
+    expectedArguments(\PhpZip\Model\ZipEntry::setCreatedOS(), 0, argumentsSet('zip_os'));
+    expectedArguments(\PhpZip\Model\ZipEntry::setExtractedOS(), 0, argumentsSet('zip_os'));
+    expectedArguments(\PhpZip\Model\ZipEntry::setPlatform(), 0, argumentsSet('zip_os'));
+
+    registerArgumentsSet(
+        "zip_gpbf",
+        \PhpZip\Constants\GeneralPurposeBitFlag::ENCRYPTION |
+        \PhpZip\Constants\GeneralPurposeBitFlag::DATA_DESCRIPTOR |
+        \PhpZip\Constants\GeneralPurposeBitFlag::COMPRESSION_FLAG1 |
+        \PhpZip\Constants\GeneralPurposeBitFlag::COMPRESSION_FLAG2 |
+        \PhpZip\Constants\GeneralPurposeBitFlag::UTF8
+    );
+    expectedArguments(\PhpZip\Model\ZipEntry::setGeneralPurposeBitFlags(), 0, argumentsSet('zip_gpbf'));
+
+    registerArgumentsSet(
+        "winzip_aes_vendor_version",
+        \PhpZip\Model\Extra\Fields\WinZipAesExtraField::VERSION_AE1,
+        \PhpZip\Model\Extra\Fields\WinZipAesExtraField::VERSION_AE2
+    );
+    registerArgumentsSet(
+        "winzip_aes_key_strength",
+        \PhpZip\Model\Extra\Fields\WinZipAesExtraField::KEY_STRENGTH_256BIT,
+        \PhpZip\Model\Extra\Fields\WinZipAesExtraField::KEY_STRENGTH_128BIT,
+        \PhpZip\Model\Extra\Fields\WinZipAesExtraField::KEY_STRENGTH_192BIT
+    );
+    expectedArguments(\PhpZip\Model\Extra\Fields\WinZipAesExtraField::__construct(), 0, argumentsSet('winzip_aes_vendor_version'));
+    expectedArguments(\PhpZip\Model\Extra\Fields\WinZipAesExtraField::__construct(), 1, argumentsSet('winzip_aes_key_strength'));
+    expectedArguments(\PhpZip\Model\Extra\Fields\WinZipAesExtraField::__construct(), 2, argumentsSet('compression_methods'));
+    expectedArguments(\PhpZip\Model\Extra\Fields\WinZipAesExtraField::setVendorVersion(), 0, argumentsSet('winzip_aes_vendor_version'));
+    expectedArguments(\PhpZip\Model\Extra\Fields\WinZipAesExtraField::setKeyStrength(), 0, argumentsSet('winzip_aes_key_strength'));
+    expectedArguments(\PhpZip\Model\Extra\Fields\WinZipAesExtraField::setCompressionMethod(), 0, argumentsSet('compression_methods'));
+}
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,24 +0,0 @@
-language: php
-php:
-  - '5.5'
-  - '5.6'
-  - '7.0'
-  - '7.1'
-  - nightly
-
-# cache vendor dirs
-cache:
-  directories:
-    - vendor
-    - $HOME/.composer/cache
-
-install:
-  - travis_retry composer self-update && composer --version
-  - travis_retry composer install --prefer-dist --no-interaction
-
-before_script:
-  - sudo apt-get install p7zip-full
-
-script:
-  - composer validate --no-check-lock
-  - vendor/bin/phpunit -v -c bootstrap.xml
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +0,0 @@
-## 3.0.3 (2017-11-11)
-Fix bug issue #8 - Error if the file is empty.
-
-## 3.0.0 (2017-03-15)
-Merge `ZipOutputFile` with ZipFile and optimize the zip archive update.
-
-See the update instructions in README.md.
-
-## 2.2.0 (2017-03-02)
-Features:
-  - create output object `ZipOutputFile` from `ZipFile` in method `ZipFile::edit()`.
-  - create output object `ZipOutputFile` from filename in static method `ZipOutputFile::openFromFile(string $filename)`.
--- a/21
+++ b/21
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-2020 Ne-Lexa
+
+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.
--- a/README.RU.md
+++ b/README.RU.md
@@ -0,0 +1,884 @@
+<h1 align="center"><img src="logo.svg" alt="PhpZip" width="250" height="51"></h1>
+
+`PhpZip` - php библиотека для продвинутой работы с ZIP-архивами.
+
+[![Packagist Version](https://img.shields.io/packagist/v/nelexa/zip.svg)](https://packagist.org/packages/nelexa/zip)
+[![Packagist Downloads](https://img.shields.io/packagist/dt/nelexa/zip.svg?color=%23ff007f)](https://packagist.org/packages/nelexa/zip)
+[![Code Coverage](https://scrutinizer-ci.com/g/Ne-Lexa/php-zip/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/Ne-Lexa/php-zip/?branch=master)
+[![Build Status](https://github.com/Ne-Lexa/php-zip/workflows/build/badge.svg)](https://github.com/Ne-Lexa/php-zip/actions)
+[![License](https://img.shields.io/packagist/l/nelexa/zip.svg)](https://github.com/Ne-Lexa/php-zip/blob/master/LICENSE)
+
+
+[English Documentation](README.md)
+
+Содержание
+----------
+- [Функционал](#функционал)
+- [Требования](#требования)
+- [Установка](#установка)
+- [Примеры](#примеры)
+- [Глоссарий](#глоссарий)
+- [Документация](#документация)
+  + [Обзор методов класса `\PhpZip\ZipFile`](#обзор-методов-класса-phpzipzipfile)
+  + [Создание/Открытие ZIP-архива](#созданиеоткрытие-zip-архива)
+  + [Чтение записей из архива](#чтение-записей-из-архива)
+  + [Перебор записей/Итератор](#перебор-записейитератор)
+  + [Получение информации о записях](#получение-информации-о-записях)
+  + [Добавление записей в архив](#добавление-записей-в-архив)
+  + [Удаление записей из архива](#удаление-записей-из-архива)
+  + [Работа с записями и с архивом](#работа-с-записями-и-с-архивом)
+  + [Работа с паролями](#работа-с-паролями)
+  + [Отмена изменений](#отмена-изменений)
+  + [Сохранение файла или вывод в браузер](#сохранение-файла-или-вывод-в-браузер)
+  + [Закрытие архива](#закрытие-архива)
+- [Запуск тестов](#запуск-тестов)
+- [История изменений](#история-изменений)
+- [Обновление версий](#обновление-версий)
+  + [Обновление с версии 3 до версии 4](#обновление-с-версии-3-до-версии-4)
+  + [Обновление с версии 2 до версии 3](#обновление-с-версии-2-до-версии-3)
+
+### Функционал
+- Открытие и разархивирование ZIP-архивов.
+- Создание ZIP-архивов.
+- Модификация ZIP-архивов.
+- Чистый php (не требуется расширение `php-zip` и класс `\ZipArchive`).
+- Поддерживается сохранение архива в файл, вывод архива в браузер или вывод в виде строки, без сохранения в файл.
+- Поддерживаются комментарии архива и комментарии отдельных записей.
+- Получение подробной информации о каждой записи в архиве.
+- Поддерживаются только следующие методы сжатия:
+  + Без сжатия (Stored).
+  + Deflate сжатие.
+  + BZIP2 сжатие при наличии расширения `php-bz2`.
+- Поддержка `ZIP64` (размер файла более 4 GB или количество записей в архиве более 65535).
+- Работа с паролями
+  > **Внимание!**
+  >
+  > Для 32-bit систем, в данный момент не поддерживается метод шифрование `Traditional PKWARE Encryption (ZipCrypto)`. 
+  > Используйте метод шифрования `WinZIP AES Encryption`, когда это возможно.
+  + Установка пароля для чтения архива глобально или для некоторых записей.
+  + Изменение пароля архива, в том числе и для отдельных записей.
+  + Удаление пароля архива глобально или для отдельных записей.
+  + Установка пароля и/или метода шифрования, как для всех, так и для отдельных записей в архиве.
+  + Установка разных паролей и методов шифрования для разных записей.
+  + Удаление пароля для всех или для некоторых записей.
+  + Поддержка методов шифрования `Traditional PKWARE Encryption (ZipCrypto)` и `WinZIP AES Encryption (128, 192 или 256 bit)`.
+  + Установка метода шифрования для всех или для отдельных записей в архиве.
+
+### Требования
+- `PHP` 7.4 или ^8.0 (предпочтительно 64-bit).
+- Опционально php-расширение `bzip2` для поддержки BZIP2 компрессии.
+- Опционально php-расширение `openssl` для `WinZip Aes Encryption` шифрования.
+
+### Установка
+`composer require nelexa/zip`
+
+Последняя стабильная версия: [![Latest Stable Version](https://poser.pugx.org/nelexa/zip/v/stable)](https://packagist.org/packages/nelexa/zip)
+
+### Примеры
+```php
+// создание нового архива
+$zipFile = new \PhpZip\ZipFile();
+try{
+    $zipFile
+        ->addFromString('zip/entry/filename', "Is file content") // добавить запись из строки
+        ->addFile('/path/to/file', 'data/tofile') // добавить запись из файла
+        ->addDir(__DIR__, 'to/path/') // добавить файлы из директории
+        ->saveAsFile($outputFilename) // сохранить архив в файл
+        ->close(); // закрыть архив
+            
+    // открытие архива, извлечение файлов, удаление файлов, добавление файлов, установка пароля и вывод архива в браузер.
+    $zipFile
+        ->openFile($outputFilename) // открыть архив из файла
+        ->extractTo($outputDirExtract) // извлечь файлы в заданную директорию
+        ->deleteFromRegex('~^\.~') // удалить все скрытые (Unix) файлы
+        ->addFromString('dir/file.txt', 'Test file') // добавить новую запись из строки
+        ->setPassword('password') // установить пароль на все записи
+        ->outputAsAttachment('library.jar'); // вывести в браузер без сохранения в файл
+}
+catch(\PhpZip\Exception\ZipException $e){
+    // обработка исключения
+}
+finally{
+    $zipFile->close();
+}
+```
+Другие примеры можно посмотреть в папке `tests/`.
+
+### Глоссарий
+**Запись в ZIP-архиве (Zip Entry)** - файл или папка в ZIP-архиве. У каждой записи в архиве есть определённые свойства, например: имя файла, метод сжатия, метод шифрования, размер файла до сжатия, размер файла после сжатия, CRC32 и другие.
+
+### Документация
+#### Обзор методов класса `\PhpZip\ZipFile`
+- [ZipFile::__construct](#zipfile__construct) - инициализирует ZIP-архив.
+- [ZipFile::addAll](#zipfileaddall) - добавляет все записи из массива.
+- [ZipFile::addDir](#zipfileadddir) - добавляет файлы из директории по указанному пути без вложенных директорий.
+- [ZipFile::addDirRecursive](#zipfileadddirrecursive) - добавляет файлы из директории по указанному пути с вложенными директориями.
+- [ZipFile::addEmptyDir](#zipfileaddemptydir) - добавляет в ZIP-архив новую директорию.
+- [ZipFile::addFile](#zipfileaddfile) - добавляет в ZIP-архив файл по указанному пути.
+- [ZipFile::addSplFile](#zipfileaddsplfile) - добавляет объект `\SplFileInfo` в zip-архив.
+- [ZipFile::addFromFinder](#zipfileaddfromfinder) - добавляет файлы из `Symfony\Component\Finder\Finder` в zip архив.
+- [ZipFile::addFilesFromIterator](#zipfileaddfilesfromiterator) - добавляет файлы из итератора директорий.
+- [ZipFile::addFilesFromGlob](#zipfileaddfilesfromglob) - добавляет файлы из директории в соответствии с glob шаблоном без вложенных директорий.
+- [ZipFile::addFilesFromGlobRecursive](#zipfileaddfilesfromglobrecursive) - добавляет файлы из директории в соответствии с glob шаблоном c вложенными директориями.
+- [ZipFile::addFilesFromRegex](#zipfileaddfilesfromregex) - добавляет файлы из директории в соответствии с регулярным выражением без вложенных директорий.
+- [ZipFile::addFilesFromRegexRecursive](#zipfileaddfilesfromregexrecursive) - добавляет файлы из директории в соответствии с регулярным выражением с вложенными директориями.
+- [ZipFile::addFromStream](#zipfileaddfromstream) - добавляет в ZIP-архив запись из потока.
+- [ZipFile::addFromString](#zipfileaddfromstring) - добавляет файл в ZIP-архив, используя его содержимое в виде строки.
+- [ZipFile::close](#zipfileclose) - закрывает ZIP-архив.
+- [ZipFile::count](#zipfilecount) - возвращает количество записей в архиве.
+- [ZipFile::deleteFromName](#zipfiledeletefromname) - удаляет запись по имени.
+- [ZipFile::deleteFromGlob](#zipfiledeletefromglob) - удаляет записи в соответствии с glob шаблоном.
+- [ZipFile::deleteFromRegex](#zipfiledeletefromregex) - удаляет записи в соответствии с регулярным выражением.
+- [ZipFile::deleteAll](#zipfiledeleteall) - удаляет все записи в ZIP-архиве.
+- [ZipFile::disableEncryption](#zipfiledisableencryption) - отключает шифрования всех записей, находящихся в архиве.
+- [ZipFile::disableEncryptionEntry](#zipfiledisableencryptionentry) - отключает шифрование записи по её имени.
+- [ZipFile::extractTo](#zipfileextractto) - извлекает содержимое архива в заданную директорию.
+- [ZipFile::getArchiveComment](#zipfilegetarchivecomment) - возвращает комментарий ZIP-архива.
+- [ZipFile::getEntryComment](#zipfilegetentrycomment) - возвращает комментарий к записи, используя её имя.
+- [ZipFile::getEntryContent](#zipfilegetentrycontent) - возвращает содержимое записи.
+- [ZipFile::getListFiles](#zipfilegetlistfiles) - возвращает список файлов архива.
+- [ZipFile::hasEntry](#zipfilehasentry) - проверяет, присутствует ли запись в архиве.
+- [ZipFile::isDirectory](#zipfileisdirectory) - проверяет, является ли запись в архиве директорией.
+- [ZipFile::matcher](#zipfilematcher) - выборка записей в архиве для проведения операций над выбранными записями.
+- [ZipFile::openFile](#zipfileopenfile) - открывает ZIP-архив из файла.
+- [ZipFile::openFromString](#zipfileopenfromstring) - открывает ZIP-архив из строки.
+- [ZipFile::openFromStream](#zipfileopenfromstream) - открывает ZIP-архив из потока.
+- [ZipFile::outputAsAttachment](#zipfileoutputasattachment) - выводит ZIP-архив в браузер.
+- [ZipFile::outputAsPsr7Response](#zipfileoutputaspsr7response) - выводит ZIP-архив, как PSR-7 Response.
+- [ZipFile::outputAsSymfonyResponse](#zipfileoutputassymfonyresponse) - выводит ZIP-архив, как Symfony Response.
+- [ZipFile::outputAsString](#zipfileoutputasstring) - выводит ZIP-архив в виде строки.
+- [ZipFile::rename](#zipfilerename) - переименовывает запись по имени.
+- [ZipFile::rewrite](#zipfilerewrite) - сохраняет изменения и заново открывает изменившийся архив.
+- [ZipFile::saveAsFile](#zipfilesaveasfile) - сохраняет архив в файл.
+- [ZipFile::saveAsStream](#zipfilesaveasstream) - записывает архив в поток.
+- [ZipFile::setArchiveComment](#zipfilesetarchivecomment) - устанавливает комментарий к ZIP-архиву.
+- [ZipFile::setCompressionLevel](#zipfilesetcompressionlevel) - устанавливает уровень сжатия для всех файлов, находящихся в архиве.
+- [ZipFile::setCompressionLevelEntry](#zipfilesetcompressionlevelentry) - устанавливает уровень сжатия для определённой записи в архиве.
+- [ZipFile::setCompressionMethodEntry](#zipfilesetcompressionmethodentry) - устанавливает метод сжатия для определённой записи в архиве.
+- [ZipFile::setEntryComment](#zipfilesetentrycomment) - устанавливает комментарий к записи, используя её имя.
+- [ZipFile::setReadPassword](#zipfilesetreadpassword) - устанавливает пароль на чтение открытого запароленного архива для всех зашифрованных записей.
+- [ZipFile::setReadPasswordEntry](#zipfilesetreadpasswordentry) - устанавливает пароль на чтение конкретной зашифрованной записи открытого запароленного архива.
+- [ZipFile::setPassword](#zipfilesetpassword) - устанавливает новый пароль для всех файлов, находящихся в архиве.
+- [ZipFile::setPasswordEntry](#zipfilesetpasswordentry) - устанавливает новый пароль для конкретного файла.
+- [ZipFile::unchangeAll](#zipfileunchangeall) - отменяет все изменения, сделанные в архиве.
+- [ZipFile::unchangeArchiveComment](#zipfileunchangearchivecomment) - отменяет изменения в комментарии к архиву.
+- [ZipFile::unchangeEntry](#zipfileunchangeentry) - отменяет изменения для конкретной записи архива.
+
+#### Создание/Открытие ZIP-архива
+##### ZipFile::__construct
+Инициализирует ZIP-архив.
+```php
+$zipFile = new \PhpZip\ZipFile();
+```
+##### ZipFile::openFile
+Открывает ZIP-архив из файла.
+```php
+$zipFile = new \PhpZip\ZipFile();
+$zipFile->openFile('file.zip');
+```
+##### ZipFile::openFromString
+Открывает ZIP-архив из строки.
+```php
+$zipFile = new \PhpZip\ZipFile();
+$zipFile->openFromString($stringContents);
+```
+##### ZipFile::openFromStream
+Открывает ZIP-архив из потока.
+```php
+$stream = fopen('file.zip', 'rb');
+
+$zipFile = new \PhpZip\ZipFile();
+$zipFile->openFromStream($stream);
+```
+#### Чтение записей из архива
+##### ZipFile::count
+Возвращает количество записей в архиве.
+```php
+$zipFile = new \PhpZip\ZipFile();
+
+$count = count($zipFile);
+// или
+$count = $zipFile->count();
+```
+##### ZipFile::getListFiles
+Возвращает список файлов архива.
+```php
+$zipFile = new \PhpZip\ZipFile();
+$listFiles = $zipFile->getListFiles();
+
+// Пример содержимого массива:
+// array (
+//   0 => 'info.txt',
+//   1 => 'path/to/file.jpg',
+//   2 => 'another path/',
+// )
+```
+##### ZipFile::getEntryContent
+Возвращает содержимое записи.
+```php
+// $entryName = 'path/to/example-entry-name.txt';
+$zipFile = new \PhpZip\ZipFile();
+
+$contents = $zipFile[$entryName];
+// или
+$contents = $zipFile->getEntryContents($entryName);
+```
+##### ZipFile::hasEntry
+Проверяет, присутствует ли запись в архиве.
+```php
+// $entryName = 'path/to/example-entry-name.txt';
+$zipFile = new \PhpZip\ZipFile();
+
+$hasEntry = isset($zipFile[$entryName]);
+// или
+$hasEntry = $zipFile->hasEntry($entryName);
+```
+##### ZipFile::isDirectory
+Проверяет, является ли запись в архиве директорией.
+```php
+// $entryName = 'path/to/';
+$zipFile = new \PhpZip\ZipFile();
+
+$isDirectory = $zipFile->isDirectory($entryName);
+```
+##### ZipFile::extractTo
+Извлекает содержимое архива в заданную директорию.
+Директория должна существовать.
+```php
+$zipFile = new \PhpZip\ZipFile();
+$zipFile->extractTo($directory);
+```
+Можно извлечь только некоторые записи в заданную директорию.
+Директория должна существовать.
+```php
+$extractOnlyFiles = [
+    'filename1', 
+    'filename2', 
+    'dir/dir/dir/'
+];
+$zipFile = new \PhpZip\ZipFile();
+$zipFile->extractTo($toDirectory, $extractOnlyFiles);
+```
+#### Перебор записей/Итератор
+`ZipFile` является итератором.
+Можно перебрать все записи, через цикл `foreach`.
+```php
+foreach($zipFile as $entryName => $contents){
+    echo "Файл: $entryName" . PHP_EOL;
+    echo "Содержимое: $contents" . PHP_EOL;
+    echo '-----------------------------' . PHP_EOL;
+}
+```
+Можно использовать паттерн `Iterator`.
+```php
+$iterator = new \ArrayIterator($zipFile);
+while ($iterator->valid())
+{
+    $entryName = $iterator->key();
+    $contents = $iterator->current();
+
+    echo "Файл: $entryName" . PHP_EOL;
+    echo "Содержимое: $contents" . PHP_EOL;
+    echo '-----------------------------' . PHP_EOL;
+
+    $iterator->next();
+}
+```
+#### Получение информации о записях
+##### ZipFile::getArchiveComment
+Возвращает комментарий ZIP-архива.
+```php
+$commentArchive = $zipFile->getArchiveComment();
+```
+##### ZipFile::getEntryComment
+Возвращает комментарий к записи, используя её имя.
+```php
+$commentEntry = $zipFile->getEntryComment($entryName);
+```
+#### Добавление записей в архив
+
+Все методы добавления записей в ZIP-архив позволяют указать метод сжатия содержимого.
+
+Доступны следующие методы сжатия:
+- `\PhpZip\Constants\ZipCompressionMethod::STORED` - без сжатия
+- `\PhpZip\Constants\ZipCompressionMethod::DEFLATED` - Deflate сжатие
+- `\PhpZip\Constants\ZipCompressionMethod::BZIP2` - Bzip2 сжатие при наличии расширения `ext-bz2`
+
+##### ZipFile::addFile
+Добавляет в ZIP-архив файл по указанному пути из файловой системы.
+```php
+$zipFile = new \PhpZip\ZipFile();
+// $file = '...../file.ext'; 
+$zipFile->addFile($file);
+
+// можно указать имя записи в архиве (если null, то используется последний компонент из имени файла)
+$zipFile->addFile($file, $entryName);
+
+// можно указать метод сжатия
+$zipFile->addFile($file, $entryName, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFile($file, $entryName, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFile($file, $entryName, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addSplFile"
+Добавляет объект `\SplFileInfo` в zip-архив.
+```php
+// $file = '...../file.ext'; 
+// $entryName = 'file2.ext'
+$zipFile = new \PhpZip\ZipFile();
+
+$splFile = new \SplFileInfo('README.md');
+
+$zipFile->addSplFile($splFile);
+$zipFile->addSplFile($splFile, $entryName);
+// or
+$zipFile[$entryName] = new \SplFileInfo($file);
+
+// установить метод сжатия
+$zipFile->addSplFile($splFile, $entryName, $options = [
+    \PhpZip\Constants\ZipOptions::COMPRESSION_METHOD => \PhpZip\Constants\ZipCompressionMethod::DEFLATED,
+]);
+```
+##### ZipFile::addFromFinder"
+Добавляет файлы из [`Symfony\Component\Finder\Finder`](https://symfony.com/doc/current/components/finder.html) в zip архив.
+```php
+$finder = new \Symfony\Component\Finder\Finder();
+$finder
+    ->files()
+    ->name('*.{jpg,jpeg,gif,png}')
+    ->name('/^[0-9a-f]\./')
+    ->contains('/lorem\s+ipsum$/i')
+    ->in('path');
+
+$zipFile = new \PhpZip\ZipFile();
+$zipFile->addFromFinder($finder, $options = [
+    \PhpZip\Constants\ZipOptions::COMPRESSION_METHOD => \PhpZip\Constants\ZipCompressionMethod::DEFLATED,
+    \PhpZip\Constants\ZipOptions::MODIFIED_TIME => new \DateTimeImmutable('-1 day 5 min')
+]);
+```
+##### ZipFile::addFromString
+Добавляет файл в ZIP-архив, используя его содержимое в виде строки.
+```php
+$zipFile = new \PhpZip\ZipFile();
+
+$zipFile[$entryName] = $contents;
+// или
+$zipFile->addFromString($entryName, $contents);
+
+// можно указать метод сжатия
+$zipFile->addFromString($entryName, $contents, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFromString($entryName, $contents, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFromString($entryName, $contents, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addFromStream
+Добавляет в ZIP-архив запись из потока.
+```php
+// $stream = fopen(..., 'rb');
+
+$zipFile->addFromStream($stream, $entryName);
+
+// можно указать метод сжатия
+$zipFile->addFromStream($stream, $entryName, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFromStream($stream, $entryName, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFromStream($stream, $entryName, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addEmptyDir
+Добавляет в ZIP-архив новую (пустую) директорию.
+```php
+// $path = "path/to/";
+
+$zipFile->addEmptyDir($path);
+// или
+$zipFile[$path] = null;
+```
+##### ZipFile::addAll
+Добавляет все записи из массива.
+```php
+$entries = [
+    'file.txt' => 'file contents', // запись из строки данных
+    'empty dir/' => null, // пустой каталог
+    'path/to/file.jpg' => fopen('..../filename', 'rb'), // запись из потока
+    'path/to/file.dat' => new \SplFileInfo('..../filename'), // запись из файла
+];
+
+$zipFile->addAll($entries);
+```
+##### ZipFile::addDir
+Добавляет файлы из директории по указанному пути без вложенных директорий.
+```php
+$zipFile->addDir($dirName);
+
+// можно указать путь в архиве в который необходимо поместить записи
+$localPath = "to/path/";
+$zipFile->addDir($dirName, $localPath);
+
+// можно указать метод сжатия
+$zipFile->addDir($dirName, $localPath, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addDir($dirName, $localPath, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addDir($dirName, $localPath, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addDirRecursive
+Добавляет файлы из директории по указанному пути c вложенными директориями.
+```php
+$zipFile->addDirRecursive($dirName);
+
+// можно указать путь в архиве в который необходимо поместить записи
+$localPath = "to/path/";
+$zipFile->addDirRecursive($dirName, $localPath);
+
+// можно указать метод сжатия
+$zipFile->addDirRecursive($dirName, $localPath, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addDirRecursive($dirName, $localPath, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addDirRecursive($dirName, $localPath, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addFilesFromIterator
+Добавляет файлы из итератора директорий.
+```php
+// $directoryIterator = new \DirectoryIterator($dir); // без вложенных директорий
+// $directoryIterator = new \RecursiveDirectoryIterator($dir); // с вложенными директориями
+
+$zipFile->addFilesFromIterator($directoryIterator);
+
+// можно указать путь в архиве в который необходимо поместить записи
+$localPath = "to/path/";
+$zipFile->addFilesFromIterator($directoryIterator, $localPath);
+// или
+$zipFile[$localPath] = $directoryIterator;
+
+// можно указать метод сжатия
+$zipFile->addFilesFromIterator($directoryIterator, $localPath, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFilesFromIterator($directoryIterator, $localPath, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFilesFromIterator($directoryIterator, $localPath, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+Пример добавления файлов из директории в архив с игнорированием некоторых файлов при помощи итератора директорий.
+```php
+$ignoreFiles = [
+    "file_ignore.txt", 
+    "dir_ignore/sub dir ignore/"
+];
+
+// $directoryIterator = new \DirectoryIterator($dir); // без вложенных директорий
+// $directoryIterator = new \RecursiveDirectoryIterator($dir); // с вложенными директориями
+ 
+// используйте \PhpZip\Util\Iterator\IgnoreFilesFilterIterator для не рекурсивного поиска
+$ignoreIterator = new \PhpZip\Util\Iterator\IgnoreFilesRecursiveFilterIterator(
+    $directoryIterator, 
+    $ignoreFiles
+);
+
+$zipFile->addFilesFromIterator($ignoreIterator);
+```
+##### ZipFile::addFilesFromGlob
+Добавляет файлы из директории в соответствии с [glob шаблоном](https://en.wikipedia.org/wiki/Glob_(programming)) без вложенных директорий.
+```php
+$globPattern = '**.{jpg,jpeg,png,gif}'; // пример glob шаблона -> добавить все .jpg, .jpeg, .png и .gif файлы
+
+$zipFile->addFilesFromGlob($dir, $globPattern);
+
+// можно указать путь в архиве в который необходимо поместить записи
+$localPath = "to/path/";
+$zipFile->addFilesFromGlob($dir, $globPattern, $localPath);
+
+// можно указать метод сжатия
+$zipFile->addFilesFromGlob($dir, $globPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFilesFromGlob($dir, $globPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFilesFromGlob($dir, $globPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addFilesFromGlobRecursive
+Добавляет файлы из директории в соответствии с [glob шаблоном](https://en.wikipedia.org/wiki/Glob_(programming)) c вложенными директориями.
+```php
+$globPattern = '**.{jpg,jpeg,png,gif}'; // пример glob шаблона -> добавить все .jpg, .jpeg, .png и .gif файлы
+
+$zipFile->addFilesFromGlobRecursive($dir, $globPattern);
+
+// можно указать путь в архиве в который необходимо поместить записи
+$localPath = "to/path/";
+$zipFile->addFilesFromGlobRecursive($dir, $globPattern, $localPath);
+
+// можно указать метод сжатия
+$zipFile->addFilesFromGlobRecursive($dir, $globPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFilesFromGlobRecursive($dir, $globPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFilesFromGlobRecursive($dir, $globPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addFilesFromRegex
+Добавляет файлы из директории в соответствии с [регулярным выражением](https://en.wikipedia.org/wiki/Regular_expression) без вложенных директорий.
+```php
+$regexPattern = '/\.(jpe?g|png|gif)$/si'; // пример регулярного выражения -> добавить все .jpg, .jpeg, .png и .gif файлы
+
+$zipFile->addFilesFromRegex($dir, $regexPattern);
+
+// можно указать путь в архиве в который необходимо поместить записи
+$localPath = "to/path/";
+$zipFile->addFilesFromRegex($dir, $regexPattern, $localPath);
+
+// можно указать метод сжатия
+$zipFile->addFilesFromRegex($dir, $regexPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFilesFromRegex($dir, $regexPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFilesFromRegex($dir, $regexPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+##### ZipFile::addFilesFromRegexRecursive
+Добавляет файлы из директории в соответствии с [регулярным выражением](https://en.wikipedia.org/wiki/Regular_expression) с вложенными директориями.
+```php
+$regexPattern = '/\.(jpe?g|png|gif)$/si'; // пример регулярного выражения -> добавить все .jpg, .jpeg, .png и .gif файлы
+
+$zipFile->addFilesFromRegexRecursive($dir, $regexPattern);
+
+// можно указать путь в архиве в который необходимо поместить записи
+$localPath = "to/path/";
+$zipFile->addFilesFromRegexRecursive($dir, $regexPattern, $localPath);
+
+// можно указать метод сжатия
+$zipFile->addFilesFromRegexRecursive($dir, $regexPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::STORED); // Без сжатия
+$zipFile->addFilesFromRegexRecursive($dir, $regexPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::DEFLATED); // Deflate сжатие
+$zipFile->addFilesFromRegexRecursive($dir, $regexPattern, $localPath, \PhpZip\Constants\ZipCompressionMethod::BZIP2); // BZIP2 сжатие
+```
+#### Удаление записей из архива
+##### ZipFile::deleteFromName
+Удаляет запись по имени.
+```php
+$zipFile->deleteFromName($entryName);
+```
+##### ZipFile::deleteFromGlob
+Удаляет записи в соответствии с [glob шаблоном](https://en.wikipedia.org/wiki/Glob_(programming)).
+```php
+$globPattern = '**.{jpg,jpeg,png,gif}'; // пример glob шаблона -> удалить все .jpg, .jpeg, .png и .gif файлы
+
+$zipFile->deleteFromGlob($globPattern);
+```
+##### ZipFile::deleteFromRegex
+Удаляет записи в соответствии с [регулярным выражением](https://en.wikipedia.org/wiki/Regular_expression).
+```php
+$regexPattern = '/\.(jpe?g|png|gif)$/si'; // пример регулярному выражения -> удалить все .jpg, .jpeg, .png и .gif файлы
+
+$zipFile->deleteFromRegex($regexPattern);
+```
+##### ZipFile::deleteAll
+Удаляет все записи в ZIP-архиве.
+```php
+$zipFile->deleteAll();
+```
+#### Работа с записями и с архивом
+##### ZipFile::rename
+Переименовывает запись по имени.
+```php
+$zipFile->rename($oldName, $newName);
+```
+##### ZipFile::setCompressionLevel
+Устанавливает уровень сжатия для всех файлов, находящихся в архиве.
+
+> _Обратите внимание, что действие данного метода не распространяется на записи, добавленные после выполнения этого метода._
+
+По умолчанию используется уровень сжатия 5 (`\PhpZip\Constants\ZipCompressionLevel::NORMAL`) или уровень сжатия, определённый в архиве для Deflate сжатия.
+
+Поддерживаются диапазон значений от 1 (`\PhpZip\Constants\ZipCompressionLevel::SUPER_FAST`) до 9 (`\PhpZip\Constants\ZipCompressionLevel::MAXIMUM`). Чем выше число, тем лучше и дольше сжатие.
+```php
+$zipFile->setCompressionLevel(\PhpZip\Constants\ZipCompressionLevel::MAXIMUM);
+```
+##### ZipFile::setCompressionLevelEntry
+Устанавливает уровень сжатия для определённой записи в архиве.
+
+Поддерживаются диапазон значений от 1 (`\PhpZip\Constants\ZipCompressionLevel::SUPER_FAST`) до 9 (`\PhpZip\Constants\ZipCompressionLevel::MAXIMUM`). Чем выше число, тем лучше и дольше сжатие.
+```php
+$zipFile->setCompressionLevelEntry($entryName, \PhpZip\Constants\ZipCompressionLevel::MAXIMUM);
+```
+##### ZipFile::setCompressionMethodEntry
+Устанавливает метод сжатия для определённой записи в архиве.
+
+Доступны следующие методы сжатия:
+- `\PhpZip\Constants\ZipCompressionMethod::STORED` - без сжатия
+- `\PhpZip\Constants\ZipCompressionMethod::DEFLATED` - Deflate сжатие
+- `\PhpZip\Constants\ZipCompressionMethod::BZIP2` - Bzip2 сжатие при наличии расширения `ext-bz2`
+```php
+$zipFile->setCompressionMethodEntry($entryName, \PhpZip\Constants\ZipCompressionMethod::DEFLATED);
+```
+##### ZipFile::setArchiveComment
+Устанавливает комментарий к ZIP-архиву.
+```php
+$zipFile->setArchiveComment($commentArchive);
+```
+##### ZipFile::setEntryComment
+Устанавливает комментарий к записи, используя её имя.
+```php
+$zipFile->setEntryComment($entryName, $comment);
+```
+##### ZipFile::matcher
+Выборка записей в архиве для проведения операций над выбранными записями.
+```php
+$matcher = $zipFile->matcher();
+```
+Выбор файлов из архива по одному:
+```php
+$matcher
+    ->add('entry name')
+    ->add('another entry');
+```
+Выбор нескольких файлов в архиве:
+```php
+$matcher->add([
+    'entry name',
+    'another entry name',
+    'path/'
+]);
+```
+Выбор файлов по регулярному выражению:
+```php
+$matcher->match('~\.jpe?g$~i');
+```
+Выбор всех файлов в архиве:
+```php
+$matcher->all();
+```
+count() - получает количество выбранных записей:
+```php
+$count = count($matcher);
+// или
+$count = $matcher->count();
+```
+getMatches() - получает список выбранных записей:
+```php
+$entries = $matcher->getMatches();
+// пример содержимого: ['entry name', 'another entry name'];
+```
+invoke() - выполняет пользовательскую функцию над выбранными записями:
+```php
+// пример
+$matcher->invoke(function($entryName) use($zipFile) {
+    $newName = preg_replace('~\.(jpe?g)$~i', '.no_optimize.$1', $entryName);
+    $zipFile->rename($entryName, $newName);
+});
+```
+Функции для работы над выбранными записями:
+```php
+$matcher->delete(); // удалет выбранные записи из ZIP-архива
+$matcher->setPassword($password); // устанавливает новый пароль на выбранные записи
+$matcher->setPassword($password, $encryptionMethod); // устанавливает новый пароль и метод шифрования на выбранные записи
+$matcher->setEncryptionMethod($encryptionMethod); // устанавливает метод шифрования на выбранные записи
+$matcher->disableEncryption(); // отключает шифрование для выбранных записей
+```
+#### Работа с паролями
+
+Реализована поддержка методов шифрования:
+- `\PhpZip\Constants\ZipEncryptionMethod::PKWARE` - Traditional PKWARE encryption
+- `\PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_256` - WinZip AES encryption 256 bit (рекомендуемое)
+- `\PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_192` - WinZip AES encryption 192 bit
+- `\PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_128` - WinZip AES encryption 128 bit
+
+##### ZipFile::setReadPassword
+Устанавливает пароль на чтение открытого запароленного архива для всех зашифрованных записей.
+
+> _Установка пароля не является обязательной для добавления новых записей или удаления существующих, но если вы захотите извлечь контент или изменить метод/уровень сжатия, метод шифрования или изменить пароль, то в этом случае пароль необходимо указать._
+```php
+$zipFile->setReadPassword($password);
+```
+##### ZipFile::setReadPasswordEntry
+Устанавливает пароль на чтение конкретной зашифрованной записи открытого запароленного архива.
+```php
+$zipFile->setReadPasswordEntry($entryName, $password);
+```
+##### ZipFile::setPassword
+Устанавливает новый пароль для всех файлов, находящихся в архиве.
+
+> _Обратите внимание, что действие данного метода не распространяется на записи, добавленные после выполнения этого метода._
+```php
+$zipFile->setPassword($password);
+```
+Можно установить метод шифрования:
+```php
+$encryptionMethod = \PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_256;
+$zipFile->setPassword($password, $encryptionMethod);
+```
+##### ZipFile::setPasswordEntry
+Устанавливает новый пароль для конкретного файла.
+```php
+$zipFile->setPasswordEntry($entryName, $password);
+```
+Можно установить метод шифрования:
+```php
+$encryptionMethod = \PhpZip\Constants\ZipEncryptionMethod::WINZIP_AES_256;
+$zipFile->setPasswordEntry($entryName, $password, $encryptionMethod);
+```
+##### ZipFile::disableEncryption
+Отключает шифрования всех записей, находящихся в архиве.
+
+> _Обратите внимание, что действие данного метода не распространяется на записи, добавленные после выполнения этого метода._
+```php
+$zipFile->disableEncryption();
+```
+##### ZipFile::disableEncryptionEntry
+Отключает шифрование записи по её имени.
+```php
+$zipFile->disableEncryptionEntry($entryName);
+```
+#### Отмена изменений
+##### ZipFile::unchangeAll
+Отменяет все изменения, сделанные в архиве.
+```php
+$zipFile->unchangeAll();
+```
+##### ZipFile::unchangeArchiveComment
+Отменяет изменения в комментарии к архиву.
+```php
+$zipFile->unchangeArchiveComment();
+```
+##### ZipFile::unchangeEntry
+Отменяет изменения для конкретной записи архива.
+```php
+$zipFile->unchangeEntry($entryName);
+```
+#### Сохранение файла или вывод в браузер
+##### ZipFile::saveAsFile
+Сохраняет архив в файл.
+```php
+$zipFile->saveAsFile($filename);
+```
+##### ZipFile::saveAsStream
+Записывает архив в поток.
+```php
+// $fp = fopen($filename, 'w+b');
+
+$zipFile->saveAsStream($fp);
+```
+##### ZipFile::outputAsString
+Выводит ZIP-архив в виде строки.
+```php
+$rawZipArchiveBytes = $zipFile->outputAsString();
+```
+##### ZipFile::outputAsAttachment
+Выводит ZIP-архив в браузер.
+
+При выводе устанавливаются необходимые заголовки, а после вывода завершается работа скрипта.
+```php
+$zipFile->outputAsAttachment($outputFilename);
+```
+Можно установить MIME-тип:
+```php
+$mimeType = 'application/zip';
+$zipFile->outputAsAttachment($outputFilename, $mimeType);
+```
+##### ZipFile::outputAsPsr7Response
+Выводит ZIP-архив, как [PSR-7 Response](http://www.php-fig.org/psr/psr-7/).
+
+Метод вывода может использоваться в любом PSR-7 совместимом фреймворке. 
+```php
+// $response = ....; // instance Psr\Http\Message\ResponseInterface
+$zipFile->outputAsPsr7Response($response, $outputFilename);
+```
+Можно установить MIME-тип:
+```php
+$mimeType = 'application/zip';
+$zipFile->outputAsPsr7Response($response, $outputFilename, $mimeType);
+```
+##### ZipFile::outputAsSymfonyResponse
+Выводит ZIP-архив, как [Symfony Response](https://symfony.com/doc/current/components/http_foundation.html#response).
+
+Метод вывода можно использовать в фреймворке Symfony.
+```php
+$response = $zipFile->outputAsSymfonyResponse($outputFilename);
+```
+Вы можете установить Mime-Type:
+```php
+$mimeType = 'application/zip';
+$response = $zipFile->outputAsSymfonyResponse($outputFilename, $mimeType);
+```
+Пример использования в Symfony Controller:
+```php
+<?php
+
+namespace App\Controller;
+
+use PhpZip\ZipFile;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Annotation\Route;
+
+class DownloadZipController
+{
+    /**
+     * @Route("/downloads/{id}")
+     *
+     * @throws \PhpZip\Exception\ZipException
+     */
+    public function __invoke(string $id): Response
+    {
+        $zipFile = new ZipFile();
+        $zipFile['file'] = 'contents';
+
+        $outputFilename = $id . '.zip';
+        return $zipFile->outputAsSymfonyResponse($outputFilename);
+    }
+}
+```
+##### ZipFile::rewrite
+Сохраняет изменения и заново открывает изменившийся архив.
+```php
+$zipFile->rewrite();
+```
+#### Закрытие архива
+##### ZipFile::close
+Закрывает ZIP-архив.
+```php
+$zipFile->close();
+```
+### Запуск тестов
+Установите зависимости для разработки.
+```bash
+composer install --dev
+```
+Запустите тесты:
+```bash
+vendor/bin/phpunit -v -c phpunit.xml
+```
+### История изменений
+История изменений на [странице релизов](https://github.com/Ne-Lexa/php-zip/releases).
+
+### Обновление версий
+#### Обновление с версии 3 до версии 4
+Обновите мажорную версию в файле `composer.json` до `^4.0`.
+```json
+{
+    "require": {
+        "nelexa/zip": "^4.0"
+    }
+}
+```
+Затем установите обновления с помощью `Composer`:
+```bash
+composer update nelexa/zip
+```
+Обновите ваш код для работы с новой версией:
+- удалены устаревшие метроды
+- удалён zipalign функционал (он будет помещен в отдельный пакет nelexa/apkfile)
+#### Обновление с версии 2 до версии 3
+Обновите мажорную версию в файле `composer.json` до `^3.0`.
+```json
+{
+    "require": {
+        "nelexa/zip": "^3.0"
+    }
+}
+```
+Затем установите обновления с помощью `Composer`:
+```bash
+composer update nelexa/zip
+```
+Обновите ваш код для работы с новой версией:
+- Класс `ZipOutputFile` объединён с `ZipFile` и удалён.
+  + Замените `new \PhpZip\ZipOutputFile()` на `new \PhpZip\ZipFile()`
+- Статичиская инициализация методов стала не статической.
+  + Замените `\PhpZip\ZipFile::openFromFile($filename);` на `(new \PhpZip\ZipFile())->openFile($filename);`
+  + Замените `\PhpZip\ZipOutputFile::openFromFile($filename);` на `(new \PhpZip\ZipFile())->openFile($filename);`
+  + Замените `\PhpZip\ZipFile::openFromString($contents);` на `(new \PhpZip\ZipFile())->openFromString($contents);`
+  + Замените `\PhpZip\ZipFile::openFromStream($stream);` на `(new \PhpZip\ZipFile())->openFromStream($stream);`
+  + Замените `\PhpZip\ZipOutputFile::create()` на `new \PhpZip\ZipFile()`
+  + Замените `\PhpZip\ZipOutputFile::openFromZipFile($zipFile)` на `(new \PhpZip\ZipFile())->openFile($filename);`
+- Переименуйте методы:
+  + `addFromFile` в `addFile`
+  + `setLevel` в `setCompressionLevel`
+  + `ZipFile::setPassword` в `ZipFile::withReadPassword`
+  + `ZipOutputFile::setPassword` в `ZipFile::withNewPassword`
+  + `ZipOutputFile::disableEncryptionAllEntries` в `ZipFile::withoutPassword`
+  + `ZipOutputFile::setComment` в `ZipFile::setArchiveComment`
+  + `ZipFile::getComment` в `ZipFile::getArchiveComment`
+- Изменились сигнатуры для методов `addDir`, `addFilesFromGlob`, `addFilesFromRegex`.
+- Удалены методы:
+  + `getLevel`
+  + `setCompressionMethod`
+  + `setEntryPassword`
--- a/README.md
+++ b/README.md
--- a/bootstrap.php
+++ b/bootstrap.php
@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+if (!defined('PHPUNIT_COMPOSER_INSTALL')) {
+    define('PHPUNIT_COMPOSER_INSTALL', __DIR__ . '/vendor/autoload.php');
+}
--- a/bootstrap.xml
+++ b/bootstrap.xml
@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<phpunit bootstrap="./vendor/autoload.php" colors="true">
-
-    <testsuites>
-        <testsuite name="PhpZip test suite">
-            <directory>./tests</directory>
-        </testsuite>
-    </testsuites>
-
-</phpunit>
--- a/composer.json
+++ b/composer.json
@@ -1,44 +1,64 @@
 {
-  "name": "nelexa/zip",
-  "description": "Zip files CRUD. Open, create, update, extract and get info tool. Supports appending to existing ZIP files, WinZip AES encryption, Traditional PKWARE Encryption, ZipAlign tool, BZIP2 compression, external file attributes and ZIP64 extensions. Alternative ZipArchive. It does not require php-zip extension.",
-  "type": "library",
-  "keywords": [
-    "zip",
-    "unzip",
-    "archive",
-    "extract",
-    "winzip",
-    "zipalign"
-  ],
-  "require-dev": {
-    "phpunit/phpunit": "4.8",
-    "codeclimate/php-test-reporter": "^0.4.4"
-  },
-  "license": "MIT",
-  "authors": [
-    {
-      "name": "Ne-Lexa",
-      "email": "alexey@nelexa.ru",
-      "role": "Developer"
+    "name": "nelexa/zip",
+    "type": "library",
+    "description": "PhpZip is a php-library for extended work with ZIP-archives. Open, create, update, delete, extract and get info tool. Supports appending to existing ZIP files, WinZip AES encryption, Traditional PKWARE Encryption, BZIP2 compression, external file attributes and ZIP64 extensions. Alternative ZipArchive. It does not require php-zip extension.",
+    "keywords": [
+        "zip",
+        "unzip",
+        "archive",
+        "extract",
+        "winzip",
+        "ziparchive"
+    ],
+    "homepage": "https://github.com/Ne-Lexa/php-zip",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Ne-Lexa",
+            "email": "alexey@nelexa.ru",
+            "role": "Developer"
+        }
+    ],
+    "require": {
+        "php": "^7.4 || ^8.0",
+        "ext-zlib": "*",
+        "psr/http-message": "*",
+        "symfony/finder": "*"
+    },
+    "require-dev": {
+        "ext-iconv": "*",
+        "ext-bz2": "*",
+        "ext-openssl": "*",
+        "ext-fileinfo": "*",
+        "ext-xml": "*",
+        "ext-dom": "*",
+        "guzzlehttp/psr7": "^1.6",
+        "phpunit/phpunit": "^9",
+        "symfony/var-dumper": "*",
+        "friendsofphp/php-cs-fixer": "^3.4.0",
+        "vimeo/psalm": "^4.6",
+        "symfony/http-foundation": "*"
+    },
+    "autoload": {
+        "psr-4": {
+            "PhpZip\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "PhpZip\\Tests\\": "tests/"
+        }
+    },
+    "suggest": {
+        "ext-iconv": "Needed to support convert zip entry name to requested character encoding",
+        "ext-openssl": "Needed to support encrypt zip entries or use ext-mcrypt",
+        "ext-bz2": "Needed to support BZIP2 compression",
+        "ext-fileinfo": "Needed to get mime-type file"
+    },
+    "minimum-stability": "stable",
+    "scripts": {
+        "php:fix": "php .php_cs --force",
+        "test": "phpunit --configuration phpunit.xml --do-not-cache-result --colors=always",
+        "test:coverage": "phpunit --configuration phpunit.xml --do-not-cache-result --colors=always --coverage-clover build/logs/clover.xml --coverage-html build/coverage"
    }
-  ],
-  "minimum-stability": "stable",
-  "require": {
-    "php": "^5.5 || ^7.0"
-  },
-  "autoload": {
-    "psr-4": {
-      "PhpZip\\": "src/PhpZip"
-    }
-  },
-  "autoload-dev": {
-    "psr-4": {
-      "PhpZip\\": "tests/PhpZip"
-    }
-  },
-  "suggest": {
-    "ext-openssl": "Needed to support encrypt zip entries or use ext-mcrypt",
-    "ext-mcrypt": "Needed to support encrypt zip entries or use ext-openssl",
-    "ext-bz2": "Needed to support BZIP2 compression"
-  }
 }
--- a/logo.svg
+++ b/logo.svg
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.3/phpunit.xsd" backupGlobals="false" colors="true" bootstrap="bootstrap.php">
+  <coverage>
+    <include>
+      <directory>src</directory>
+    </include>
+  </coverage>
+  <php>
+    <ini name="error_reporting" value="-1"/>
+  </php>
+  <testsuites>
+    <testsuite name="all_tests">
+      <directory>tests</directory>
+    </testsuite>
+    <testsuite name="only_fast_tests">
+      <directory>tests</directory>
+      <exclude>tests/SlowTests</exclude>
+    </testsuite>
+    <testsuite name="only_slow_tests">
+      <directory>tests/SlowTests</directory>
+    </testsuite>
+  </testsuites>
+  <groups>
+    <exclude>
+      <group>large</group>
+    </exclude>
+  </groups>
+</phpunit>
--- a/psalm.xml.dist
+++ b/psalm.xml.dist
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<psalm
+        errorLevel="3"
+        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"
+>
+    <projectFiles>
+        <directory name="src" />
+        <ignoreFiles>
+            <directory name="vendor" />
+            <directory name="tests"/>
+        </ignoreFiles>
+    </projectFiles>
+</psalm>
--- a/src/Constants/DosAttrs.php
+++ b/src/Constants/DosAttrs.php
@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+interface DosAttrs
+{
+    /** @var int DOS File Attribute Read Only */
+    public const DOS_READ_ONLY = 0x01;
+
+    /** @var int DOS File Attribute Hidden */
+    public const DOS_HIDDEN = 0x02;
+
+    /** @var int DOS File Attribute System */
+    public const DOS_SYSTEM = 0x04;
+
+    /** @var int DOS File Attribute Label */
+    public const DOS_LABEL = 0x08;
+
+    /** @var int DOS File Attribute Directory */
+    public const DOS_DIRECTORY = 0x10;
+
+    /** @var int DOS File Attribute Archive */
+    public const DOS_ARCHIVE = 0x20;
+
+    /** @var int DOS File Attribute Link */
+    public const DOS_LINK = 0x40;
+
+    /** @var int DOS File Attribute Execute */
+    public const DOS_EXE = 0x80;
+}
--- a/src/Constants/DosCodePage.php
+++ b/src/Constants/DosCodePage.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+final class DosCodePage
+{
+    public const CP_LATIN_US = 'cp437';
+
+    public const CP_GREEK = 'cp737';
+
+    public const CP_BALT_RIM = 'cp775';
+
+    public const CP_LATIN1 = 'cp850';
+
+    public const CP_LATIN2 = 'cp852';
+
+    public const CP_CYRILLIC = 'cp855';
+
+    public const CP_TURKISH = 'cp857';
+
+    public const CP_PORTUGUESE = 'cp860';
+
+    public const CP_ICELANDIC = 'cp861';
+
+    public const CP_HEBREW = 'cp862';
+
+    public const CP_CANADA = 'cp863';
+
+    public const CP_ARABIC = 'cp864';
+
+    public const CP_NORDIC = 'cp865';
+
+    public const CP_CYRILLIC_RUSSIAN = 'cp866';
+
+    public const CP_GREEK2 = 'cp869';
+
+    public const CP_THAI = 'cp874';
+
+    /** @var string[] */
+    private const CP_CHARSETS = [
+        self::CP_LATIN_US,
+        self::CP_GREEK,
+        self::CP_BALT_RIM,
+        self::CP_LATIN1,
+        self::CP_LATIN2,
+        self::CP_CYRILLIC,
+        self::CP_TURKISH,
+        self::CP_PORTUGUESE,
+        self::CP_ICELANDIC,
+        self::CP_HEBREW,
+        self::CP_CANADA,
+        self::CP_ARABIC,
+        self::CP_NORDIC,
+        self::CP_CYRILLIC_RUSSIAN,
+        self::CP_GREEK2,
+        self::CP_THAI,
+    ];
+
+    /**
+     * @noinspection PhpComposerExtensionStubsInspection
+     */
+    public static function toUTF8(string $str, string $sourceEncoding): string
+    {
+        $s = iconv($sourceEncoding, 'UTF-8', $str);
+
+        if ($s === false) {
+            return $str;
+        }
+
+        return $s;
+    }
+
+    /**
+     * @noinspection PhpComposerExtensionStubsInspection
+     */
+    public static function fromUTF8(string $str, string $destEncoding): string
+    {
+        $s = iconv('UTF-8', $destEncoding, $str);
+
+        if ($s === false) {
+            return $str;
+        }
+
+        return $s;
+    }
+
+    /**
+     * @return string[]
+     */
+    public static function getCodePages(): array
+    {
+        return self::CP_CHARSETS;
+    }
+}
--- a/src/Constants/GeneralPurposeBitFlag.php
+++ b/src/Constants/GeneralPurposeBitFlag.php
@@ -0,0 +1,77 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+interface GeneralPurposeBitFlag
+{
+    /**
+     * General Purpose Bit Flag mask for encrypted data.
+     * Bit 0: If set, indicates that the file is encrypted.
+     */
+    public const ENCRYPTION = 1 << 0;
+
+    /**
+     * Compression Flag Bit 1 for method Deflating.
+     *
+     * Bit 2  Bit 1
+     * 0      0    Normal compression
+     * 0      1    Maximum compression
+     * 1      0    Fast compression
+     * 1      1    Super Fast compression
+     *
+     * @see GeneralPurposeBitFlag::COMPRESSION_FLAG2
+     */
+    public const COMPRESSION_FLAG1 = 1 << 1;
+
+    /**
+     * Compression Flag Bit 2 for method Deflating.
+     *
+     * Bit 2  Bit 1
+     * 0      0    Normal compression
+     * 0      1    Maximum compression
+     * 1      0    Fast compression
+     * 1      1    Super Fast compression
+     *
+     * @see GeneralPurposeBitFlag::COMPRESSION_FLAG1
+     */
+    public const COMPRESSION_FLAG2 = 1 << 2;
+
+    /**
+     * General Purpose Bit Flag mask for data descriptor.
+     *
+     * Bit 3: 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 DATA_DESCRIPTOR = 1 << 3;
+
+    /**
+     * General Purpose Bit Flag mask for strong encryption.
+     *
+     * Bit 6: 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;
+
+    /**
+     * General Purpose Bit Flag mask for UTF-8.
+     *
+     * 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)
+     */
+    public const UTF8 = 1 << 11;
+}
--- a/src/Constants/UnixStat.php
+++ b/src/Constants/UnixStat.php
@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+/**
+ * Unix stat constants.
+ */
+interface UnixStat
+{
+    /** @var int unix file type mask */
+    public const UNX_IFMT = 0170000;
+
+    /** @var int unix regular file */
+    public const UNX_IFREG = 0100000;
+
+    /** @var int unix socket (BSD, not SysV or Amiga) */
+    public const UNX_IFSOCK = 0140000;
+
+    /** @var int unix symbolic link (not SysV, Amiga) */
+    public const UNX_IFLNK = 0120000;
+
+    /** @var int unix block special       (not Amiga) */
+    public const UNX_IFBLK = 0060000;
+
+    /** @var int unix directory */
+    public const UNX_IFDIR = 0040000;
+
+    /** @var int unix character special   (not Amiga) */
+    public const UNX_IFCHR = 0020000;
+
+    /** @var int unix fifo    (BCC, not MSC or Amiga) */
+    public const UNX_IFIFO = 0010000;
+
+    /** @var int unix set user id on execution */
+    public const UNX_ISUID = 04000;
+
+    /** @var int unix set group id on execution */
+    public const UNX_ISGID = 02000;
+
+    /** @var int unix directory permissions control */
+    public const UNX_ISVTX = 01000;
+
+    /** @var int unix record locking enforcement flag */
+    public const UNX_ENFMT = 02000;
+
+    /** @var int unix read, write, execute: owner */
+    public const UNX_IRWXU = 00700;
+
+    /** @var int unix read permission: owner */
+    public const UNX_IRUSR = 00400;
+
+    /** @var int unix write permission: owner */
+    public const UNX_IWUSR = 00200;
+
+    /** @var int unix execute permission: owner */
+    public const UNX_IXUSR = 00100;
+
+    /** @var int unix read, write, execute: group */
+    public const UNX_IRWXG = 00070;
+
+    /** @var int unix read permission: group */
+    public const UNX_IRGRP = 00040;
+
+    /** @var int unix write permission: group */
+    public const UNX_IWGRP = 00020;
+
+    /** @var int unix execute permission: group */
+    public const UNX_IXGRP = 00010;
+
+    /** @var int unix read, write, execute: other */
+    public const UNX_IRWXO = 00007;
+
+    /** @var int unix read permission: other */
+    public const UNX_IROTH = 00004;
+
+    /** @var int unix write permission: other */
+    public const UNX_IWOTH = 00002;
+
+    /** @var int unix execute permission: other */
+    public const UNX_IXOTH = 00001;
+}
--- a/src/Constants/ZipCompressionLevel.php
+++ b/src/Constants/ZipCompressionLevel.php
@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+/**
+ * Compression levels for Deflate and BZIP2.
+ *
+ * {@see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT} Section 4.4.4:
+ *
+ * For Methods 8 and 9 - Deflating
+ * -------------------------------
+ * Bit 2  Bit 1
+ * 0      0    Normal (-en) compression option was used.
+ * 0      1    Maximum (-exx/-ex) compression option was used.
+ * 1      0    Fast (-ef) compression option was used.
+ * 1      1    Super Fast (-es) compression option was used.
+ *
+ * Different programs encode compression level information in different ways:
+ *
+ * Deflate Compress Level  pkzip              zip      7z, WinRAR  WinZip
+ * ----------------------  ----------------   -------  ----------  ------
+ * Super Fast compression  1                                       1
+ * Fast compression        2                  1, 2
+ * Normal Compression      3 - 8 (5 default)  3 - 7    1 - 9
+ * Maximum compression     9                  8, 9                 9
+ */
+interface ZipCompressionLevel
+{
+    /** @var int Compression level for super fast compression. */
+    public const SUPER_FAST = 1;
+
+    /** @var int compression level for fast compression */
+    public const FAST = 2;
+
+    /** @var int compression level for normal compression */
+    public const NORMAL = 5;
+
+    /** @var int compression level for maximum compression */
+    public const MAXIMUM = 9;
+
+    /**
+     * @var int int Minimum compression level
+     *
+     * @internal
+     */
+    public const LEVEL_MIN = self::SUPER_FAST;
+
+    /**
+     * @var int int Maximum compression level
+     *
+     * @internal
+     */
+    public const LEVEL_MAX = self::MAXIMUM;
+}
--- a/src/Constants/ZipCompressionMethod.php
+++ b/src/Constants/ZipCompressionMethod.php
@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+use PhpZip\Exception\ZipUnsupportMethodException;
+
+final class ZipCompressionMethod
+{
+    /** @var int Compression method Store */
+    public const STORED = 0;
+
+    /** @var int Compression method Deflate */
+    public const DEFLATED = 8;
+
+    /** @var int Compression method Bzip2 */
+    public const BZIP2 = 12;
+
+    /** @var int Compression method AES-Encryption */
+    public const WINZIP_AES = 99;
+
+    /** @var array Compression Methods */
+    private const ZIP_COMPRESSION_METHODS = [
+        self::STORED => 'Stored',
+        1 => 'Shrunk',
+        2 => 'Reduced compression factor 1',
+        3 => 'Reduced compression factor 2',
+        4 => 'Reduced compression factor 3',
+        5 => 'Reduced compression factor 4',
+        6 => 'Imploded',
+        7 => 'Reserved for Tokenizing compression algorithm',
+        self::DEFLATED => 'Deflated',
+        9 => 'Enhanced Deflating using Deflate64(tm)',
+        10 => 'PKWARE Data Compression Library Imploding',
+        11 => 'Reserved by PKWARE',
+        self::BZIP2 => 'BZIP2',
+        13 => 'Reserved by PKWARE',
+        14 => 'LZMA',
+        15 => 'Reserved by PKWARE',
+        16 => 'Reserved by PKWARE',
+        17 => 'Reserved by PKWARE',
+        18 => 'File is compressed using IBM TERSE (new)',
+        19 => 'IBM LZ77 z Architecture (PFS)',
+        96 => 'WinZip JPEG Compression',
+        97 => 'WavPack compressed data',
+        98 => 'PPMd version I, Rev 1',
+        self::WINZIP_AES => 'AES Encryption',
+    ];
+
+    public static function getCompressionMethodName(int $value): string
+    {
+        return self::ZIP_COMPRESSION_METHODS[$value] ?? 'Unknown Method';
+    }
+
+    /**
+     * @return int[]
+     */
+    public static function getSupportMethods(): array
+    {
+        static $methods;
+
+        if ($methods === null) {
+            $methods = [
+                self::STORED,
+                self::DEFLATED,
+            ];
+
+            if (\extension_loaded('bz2')) {
+                $methods[] = self::BZIP2;
+            }
+        }
+
+        return $methods;
+    }
+
+    /**
+     * @throws ZipUnsupportMethodException
+     */
+    public static function checkSupport(int $compressionMethod): void
+    {
+        if (!\in_array($compressionMethod, self::getSupportMethods(), true)) {
+            throw new ZipUnsupportMethodException(sprintf(
+                'Compression method %d (%s) is not supported.',
+                $compressionMethod,
+                self::getCompressionMethodName($compressionMethod)
+            ));
+        }
+    }
+}
--- a/src/Constants/ZipConstants.php
+++ b/src/Constants/ZipConstants.php
@@ -0,0 +1,105 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+/**
+ * Zip Constants.
+ */
+interface ZipConstants
+{
+    /** @var int End Of Central Directory Record signature. */
+    public const END_CD = 0x06054B50; // "PK\005\006"
+
+    /** @var int Zip64 End Of Central Directory Record. */
+    public const ZIP64_END_CD = 0x06064B50; // "PK\006\006"
+
+    /** @var int Zip64 End Of Central Directory Locator. */
+    public const ZIP64_END_CD_LOC = 0x07064B50; // "PK\006\007"
+
+    /** @var int Central File Header signature. */
+    public const CENTRAL_FILE_HEADER = 0x02014B50; // "PK\001\002"
+
+    /** @var int Local File Header signature. */
+    public const LOCAL_FILE_HEADER = 0x04034B50; // "PK\003\004"
+
+    /** @var int Data Descriptor signature. */
+    public const DATA_DESCRIPTOR = 0x08074B50; // "PK\007\008"
+
+    /**
+     * @var int value stored in four-byte size and similar fields
+     *          if ZIP64 extensions are used
+     */
+    public const ZIP64_MAGIC = 0xFFFFFFFF;
+
+    /**
+     * Local File Header signature      4
+     * Version Needed To Extract        2
+     * General Purpose Bit Flags        2
+     * Compression Method               2
+     * Last Mod File Time               2
+     * Last Mod File Date               2
+     * CRC-32                           4
+     * Compressed Size                  4
+     * Uncompressed Size                4.
+     *
+     * @var int Local File Header filename position
+     */
+    public const LFH_FILENAME_LENGTH_POS = 26;
+
+    /**
+     * The minimum length of the Local File Header record.
+     *
+     * local file header signature      4
+     * version needed to extract        2
+     * general purpose bit flag         2
+     * compression method               2
+     * last mod file time               2
+     * last mod file date               2
+     * crc-32                           4
+     * compressed size                  4
+     * uncompressed size                4
+     * file name length                 2
+     * extra field length               2
+     */
+    public const LFH_FILENAME_POS = 30;
+
+    /** @var int the length of the Zip64 End Of Central Directory Locator */
+    public const ZIP64_END_CD_LOC_LEN = 20;
+
+    /** @var int the minimum length of the End Of Central Directory Record */
+    public const END_CD_MIN_LEN = 22;
+
+    /**
+     * The minimum length of the Zip64 End Of Central Directory Record.
+     *
+     * zip64 end of central dir
+     * signature                        4
+     * size of zip64 end of central
+     * directory record                 8
+     * version made by                  2
+     * version needed to extract        2
+     * number of this disk              4
+     * number of the disk with the
+     * start of the central directory   4
+     * total number of entries in the
+     * central directory on this disk   8
+     * total number of entries in
+     * the central directory            8
+     * size of the central directory    8
+     * offset of start of central
+     * directory with respect to
+     * the starting disk number         8
+     *
+     * @var int ZIP64 End Of Central Directory length
+     */
+    public const ZIP64_END_OF_CD_LEN = 56;
+}
--- a/src/Constants/ZipEncryptionMethod.php
+++ b/src/Constants/ZipEncryptionMethod.php
@@ -0,0 +1,76 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+use PhpZip\Exception\InvalidArgumentException;
+
+final class ZipEncryptionMethod
+{
+    public const NONE = -1;
+
+    /** @var int Traditional PKWARE encryption. */
+    public const PKWARE = 0;
+
+    /** @var int WinZip AES-256 */
+    public const WINZIP_AES_256 = 1;
+
+    /** @var int WinZip AES-128 */
+    public const WINZIP_AES_128 = 2;
+
+    /** @var int WinZip AES-192 */
+    public const WINZIP_AES_192 = 3;
+
+    /** @var array<int, string> */
+    private const ENCRYPTION_METHODS = [
+        self::NONE => 'no encryption',
+        self::PKWARE => 'Traditional PKWARE encryption',
+        self::WINZIP_AES_128 => 'WinZip AES-128',
+        self::WINZIP_AES_192 => 'WinZip AES-192',
+        self::WINZIP_AES_256 => 'WinZip AES-256',
+    ];
+
+    public static function getEncryptionMethodName(int $value): string
+    {
+        return self::ENCRYPTION_METHODS[$value] ?? 'Unknown Encryption Method';
+    }
+
+    public static function hasEncryptionMethod(int $encryptionMethod): bool
+    {
+        return isset(self::ENCRYPTION_METHODS[$encryptionMethod]);
+    }
+
+    public static function isWinZipAesMethod(int $encryptionMethod): bool
+    {
+        return \in_array(
+            $encryptionMethod,
+            [
+                self::WINZIP_AES_256,
+                self::WINZIP_AES_192,
+                self::WINZIP_AES_128,
+            ],
+            true
+        );
+    }
+
+    /**
+     * @throws InvalidArgumentException
+     */
+    public static function checkSupport(int $encryptionMethod): void
+    {
+        if (!self::hasEncryptionMethod($encryptionMethod)) {
+            throw new InvalidArgumentException(sprintf(
+                'Encryption method %d is not supported.',
+                $encryptionMethod
+            ));
+        }
+    }
+}
--- a/src/Constants/ZipOptions.php
+++ b/src/Constants/ZipOptions.php
@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+use PhpZip\IO\ZipReader;
+use PhpZip\ZipFile;
+
+interface ZipOptions
+{
+    /**
+     * Boolean option for store just file names (skip directory names).
+     *
+     * @see ZipFile::addFromFinder()
+     */
+    public const STORE_ONLY_FILES = 'only_files';
+
+    /**
+     * Uses the specified compression method.
+     *
+     * @see ZipFile::addFromFinder()
+     * @see ZipFile::addSplFile()
+     */
+    public const COMPRESSION_METHOD = 'compression_method';
+
+    /**
+     * Set the specified record modification time.
+     * The value can be {@see \DateTimeInterface}, integer timestamp
+     * or a string of any format.
+     *
+     * @see ZipFile::addFromFinder()
+     * @see ZipFile::addSplFile()
+     */
+    public const MODIFIED_TIME = 'mtime';
+
+    /**
+     * Specifies the encoding of the record name for cases when the UTF-8
+     * usage flag is not set.
+     *
+     * The most commonly used encodings are compiled into the constants
+     * of the {@see DosCodePage} class.
+     *
+     * @see ZipFile::openFile()
+     * @see ZipFile::openFromString()
+     * @see ZipFile::openFromStream()
+     * @see ZipReader::getDefaultOptions()
+     * @see DosCodePage::getCodePages()
+     */
+    public const CHARSET = 'charset';
+
+    /**
+     * Allows ({@see true}) or denies ({@see false}) unpacking unix symlinks.
+     *
+     * This is a potentially dangerous operation for uncontrolled zip files.
+     * By default is ({@see false}).
+     *
+     * @see https://josipfranjkovic.blogspot.com/2014/12/reading-local-files-from-facebooks.html
+     */
+    public const EXTRACT_SYMLINKS = 'extract_symlinks';
+}
--- a/src/Constants/ZipPlatform.php
+++ b/src/Constants/ZipPlatform.php
@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+final class ZipPlatform
+{
+    /** @var int MS-DOS OS */
+    public const OS_DOS = 0;
+
+    /** @var int Unix OS */
+    public const OS_UNIX = 3;
+
+    /** @var int MacOS platform */
+    public const OS_MAC_OSX = 19;
+
+    /** @var array Zip Platforms */
+    private const PLATFORMS = [
+        self::OS_DOS => 'MS-DOS',
+        1 => 'Amiga',
+        2 => 'OpenVMS',
+        self::OS_UNIX => 'Unix',
+        4 => 'VM/CMS',
+        5 => 'Atari ST',
+        6 => 'HPFS (OS/2, NT 3.x)',
+        7 => 'Macintosh',
+        8 => 'Z-System',
+        9 => 'CP/M',
+        10 => 'Windows NTFS or TOPS-20',
+        11 => 'MVS or NTFS',
+        12 => 'VSE or SMS/QDOS',
+        13 => 'Acorn RISC OS',
+        14 => 'VFAT',
+        15 => 'alternate MVS',
+        16 => 'BeOS',
+        17 => 'Tandem',
+        18 => 'OS/400',
+        self::OS_MAC_OSX => 'OS/X (Darwin)',
+        30 => 'AtheOS/Syllable',
+    ];
+
+    public static function getPlatformName(int $platform): string
+    {
+        return self::PLATFORMS[$platform] ?? 'Unknown';
+    }
+}
--- a/src/Constants/ZipVersion.php
+++ b/src/Constants/ZipVersion.php
@@ -0,0 +1,87 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Constants;
+
+/**
+ * Version needed to extract or software version.
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT Section 4.4.3
+ */
+interface ZipVersion
+{
+    /** @var int 1.0 - Default value */
+    public const v10_DEFAULT_MIN = 10;
+
+    /** @var int 1.1 - File is a volume label */
+    public const v11_FILE_VOLUME_LABEL = 11;
+
+    /**
+     * 2.0 - File is a folder (directory)
+     * 2.0 - File is compressed using Deflate compression
+     * 2.0 - File is encrypted using traditional PKWARE encryption.
+     *
+     * @var int
+     */
+    public const v20_DEFLATED_FOLDER_ZIPCRYPTO = 20;
+
+    /** @var int 2.1 - File is compressed using Deflate64(tm) */
+    public const v21_DEFLATED64 = 21;
+
+    /** @var int 2.5 - File is compressed using PKWARE DCL Implode */
+    public const v25_IMPLODED = 25;
+
+    /** @var int 2.7 - File is a patch data set */
+    public const v27_PATCH_DATA = 27;
+
+    /** @var int 4.5 - File uses ZIP64 format extensions */
+    public const v45_ZIP64_EXT = 45;
+
+    /** @var int 4.6 - File is compressed using BZIP2 compression */
+    public const v46_BZIP2 = 46;
+
+    /**
+     * 5.0 - File is encrypted using DES
+     * 5.0 - File is encrypted using 3DES
+     * 5.0 - File is encrypted using original RC2 encryption
+     * 5.0 - File is encrypted using RC4 encryption.
+     *
+     * @var int
+     */
+    public const v50_ENCR_DES_3DES_RC2_ORIG_RC4 = 50;
+
+    /**
+     * 5.1 - File is encrypted using AES encryption
+     * 5.1 - File is encrypted using corrected RC2 encryption**.
+     *
+     * @var int
+     */
+    public const v51_ENCR_AES_RC2_CORRECT = 51;
+
+    /** @var int 5.2 - File is encrypted using corrected RC2-64 encryption** */
+    public const v52_ENCR_RC2_64_CORRECT = 52;
+
+    /** @var int 6.1 - File is encrypted using non-OAEP key wrapping*** */
+    public const v61_ENCR_NON_OAE_KEY_WRAP = 61;
+
+    /** @var int 6.2 - Central directory encryption */
+    public const v62_ENCR_CENTRAL_DIR = 62;
+
+    /**
+     * 6.3 - File is compressed using LZMA
+     * 6.3 - File is compressed using PPMd+
+     * 6.3 - File is encrypted using Blowfish
+     * 6.3 - File is encrypted using Twofish.
+     *
+     * @var int
+     */
+    public const v63_LZMA_PPMD_BLOWFISH_TWOFISH = 63;
+}
--- a/src/Exception/Crc32Exception.php
+++ b/src/Exception/Crc32Exception.php
@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+/**
+ * Thrown to indicate a CRC32 mismatch between the declared value in the
+ * Central File Header and the Data Descriptor or between the declared value
+ * and the computed value from the decompressed data.
+ *
+ * The exception detail message is the name of the ZIP entry.
+ */
+class Crc32Exception extends ZipException
+{
+    /** Expected crc. */
+    private int $expectedCrc;
+
+    /** Actual crc. */
+    private int $actualCrc;
+
+    public function __construct(string $name, int $expected, int $actual)
+    {
+        parent::__construct(
+            sprintf(
+                '%s (expected CRC32 value 0x%x, but is actually 0x%x)',
+                $name,
+                $expected,
+                $actual
+            )
+        );
+        $this->expectedCrc = $expected;
+        $this->actualCrc = $actual;
+    }
+
+    /**
+     * Returns expected crc.
+     */
+    public function getExpectedCrc(): int
+    {
+        return $this->expectedCrc;
+    }
+
+    /**
+     * Returns actual crc.
+     */
+    public function getActualCrc(): int
+    {
+        return $this->actualCrc;
+    }
+}
--- a/src/Exception/InvalidArgumentException.php
+++ b/src/Exception/InvalidArgumentException.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+/**
+ * Thrown to indicate that a method has been passed an illegal or
+ * inappropriate argument.
+ */
+class InvalidArgumentException extends RuntimeException
+{
+}
--- a/src/Exception/RuntimeException.php
+++ b/src/Exception/RuntimeException.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+/**
+ * Runtime exception.
+ * Exception thrown if an error which can only be found on runtime occurs.
+ */
+class RuntimeException extends \RuntimeException
+{
+}
--- a/src/Exception/ZipAuthenticationException.php
+++ b/src/Exception/ZipAuthenticationException.php
@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+/**
+ * Thrown to indicate that an authenticated ZIP entry has been tampered with.
+ */
+class ZipAuthenticationException extends ZipCryptoException
+{
+}
--- a/src/Exception/ZipCryptoException.php
+++ b/src/Exception/ZipCryptoException.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+/**
+ * Thrown if there is an issue when reading or writing an encrypted ZIP file
+ * or entry.
+ */
+class ZipCryptoException extends ZipException
+{
+}
--- a/src/Exception/ZipEntryNotFoundException.php
+++ b/src/Exception/ZipEntryNotFoundException.php
@@ -0,0 +1,40 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Thrown if entry not found.
+ */
+class ZipEntryNotFoundException extends ZipException
+{
+    private string $entryName;
+
+    /**
+     * @param ZipEntry|string $entryName
+     */
+    public function __construct($entryName)
+    {
+        $entryName = $entryName instanceof ZipEntry ? $entryName->getName() : $entryName;
+        parent::__construct(sprintf(
+            'Zip Entry "%s" was not found in the archive.',
+            $entryName
+        ));
+        $this->entryName = $entryName;
+    }
+
+    public function getEntryName(): string
+    {
+        return $this->entryName;
+    }
+}
--- a/src/Exception/ZipException.php
+++ b/src/Exception/ZipException.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+/**
+ * Signals that a Zip exception of some sort has occurred.
+ *
+ * @see \Exception
+ */
+class ZipException extends \Exception
+{
+}
--- a/src/Exception/ZipUnsupportMethodException.php
+++ b/src/Exception/ZipUnsupportMethodException.php
@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Exception;
+
+class ZipUnsupportMethodException extends ZipException
+{
+}
--- a/src/IO/Filter/Cipher/Pkware/PKCryptContext.php
+++ b/src/IO/Filter/Cipher/Pkware/PKCryptContext.php
@@ -0,0 +1,389 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Filter\Cipher\Pkware;
+
+use PhpZip\Exception\RuntimeException;
+use PhpZip\Exception\ZipAuthenticationException;
+use PhpZip\Util\MathUtil;
+
+/**
+ * Traditional PKWARE Encryption Engine.
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
+ */
+class PKCryptContext
+{
+    /** @var int Encryption header size */
+    public const STD_DEC_HDR_SIZE = 12;
+
+    /**
+     * Crc table.
+     *
+     * @var int[]|array
+     */
+    private const CRC_TABLE = [
+        0x00000000,
+        0x77073096,
+        0xEE0E612C,
+        0x990951BA,
+        0x076DC419,
+        0x706AF48F,
+        0xE963A535,
+        0x9E6495A3,
+        0x0EDB8832,
+        0x79DCB8A4,
+        0xE0D5E91E,
+        0x97D2D988,
+        0x09B64C2B,
+        0x7EB17CBD,
+        0xE7B82D07,
+        0x90BF1D91,
+        0x1DB71064,
+        0x6AB020F2,
+        0xF3B97148,
+        0x84BE41DE,
+        0x1ADAD47D,
+        0x6DDDE4EB,
+        0xF4D4B551,
+        0x83D385C7,
+        0x136C9856,
+        0x646BA8C0,
+        0xFD62F97A,
+        0x8A65C9EC,
+        0x14015C4F,
+        0x63066CD9,
+        0xFA0F3D63,
+        0x8D080DF5,
+        0x3B6E20C8,
+        0x4C69105E,
+        0xD56041E4,
+        0xA2677172,
+        0x3C03E4D1,
+        0x4B04D447,
+        0xD20D85FD,
+        0xA50AB56B,
+        0x35B5A8FA,
+        0x42B2986C,
+        0xDBBBC9D6,
+        0xACBCF940,
+        0x32D86CE3,
+        0x45DF5C75,
+        0xDCD60DCF,
+        0xABD13D59,
+        0x26D930AC,
+        0x51DE003A,
+        0xC8D75180,
+        0xBFD06116,
+        0x21B4F4B5,
+        0x56B3C423,
+        0xCFBA9599,
+        0xB8BDA50F,
+        0x2802B89E,
+        0x5F058808,
+        0xC60CD9B2,
+        0xB10BE924,
+        0x2F6F7C87,
+        0x58684C11,
+        0xC1611DAB,
+        0xB6662D3D,
+        0x76DC4190,
+        0x01DB7106,
+        0x98D220BC,
+        0xEFD5102A,
+        0x71B18589,
+        0x06B6B51F,
+        0x9FBFE4A5,
+        0xE8B8D433,
+        0x7807C9A2,
+        0x0F00F934,
+        0x9609A88E,
+        0xE10E9818,
+        0x7F6A0DBB,
+        0x086D3D2D,
+        0x91646C97,
+        0xE6635C01,
+        0x6B6B51F4,
+        0x1C6C6162,
+        0x856530D8,
+        0xF262004E,
+        0x6C0695ED,
+        0x1B01A57B,
+        0x8208F4C1,
+        0xF50FC457,
+        0x65B0D9C6,
+        0x12B7E950,
+        0x8BBEB8EA,
+        0xFCB9887C,
+        0x62DD1DDF,
+        0x15DA2D49,
+        0x8CD37CF3,
+        0xFBD44C65,
+        0x4DB26158,
+        0x3AB551CE,
+        0xA3BC0074,
+        0xD4BB30E2,
+        0x4ADFA541,
+        0x3DD895D7,
+        0xA4D1C46D,
+        0xD3D6F4FB,
+        0x4369E96A,
+        0x346ED9FC,
+        0xAD678846,
+        0xDA60B8D0,
+        0x44042D73,
+        0x33031DE5,
+        0xAA0A4C5F,
+        0xDD0D7CC9,
+        0x5005713C,
+        0x270241AA,
+        0xBE0B1010,
+        0xC90C2086,
+        0x5768B525,
+        0x206F85B3,
+        0xB966D409,
+        0xCE61E49F,
+        0x5EDEF90E,
+        0x29D9C998,
+        0xB0D09822,
+        0xC7D7A8B4,
+        0x59B33D17,
+        0x2EB40D81,
+        0xB7BD5C3B,
+        0xC0BA6CAD,
+        0xEDB88320,
+        0x9ABFB3B6,
+        0x03B6E20C,
+        0x74B1D29A,
+        0xEAD54739,
+        0x9DD277AF,
+        0x04DB2615,
+        0x73DC1683,
+        0xE3630B12,
+        0x94643B84,
+        0x0D6D6A3E,
+        0x7A6A5AA8,
+        0xE40ECF0B,
+        0x9309FF9D,
+        0x0A00AE27,
+        0x7D079EB1,
+        0xF00F9344,
+        0x8708A3D2,
+        0x1E01F268,
+        0x6906C2FE,
+        0xF762575D,
+        0x806567CB,
+        0x196C3671,
+        0x6E6B06E7,
+        0xFED41B76,
+        0x89D32BE0,
+        0x10DA7A5A,
+        0x67DD4ACC,
+        0xF9B9DF6F,
+        0x8EBEEFF9,
+        0x17B7BE43,
+        0x60B08ED5,
+        0xD6D6A3E8,
+        0xA1D1937E,
+        0x38D8C2C4,
+        0x4FDFF252,
+        0xD1BB67F1,
+        0xA6BC5767,
+        0x3FB506DD,
+        0x48B2364B,
+        0xD80D2BDA,
+        0xAF0A1B4C,
+        0x36034AF6,
+        0x41047A60,
+        0xDF60EFC3,
+        0xA867DF55,
+        0x316E8EEF,
+        0x4669BE79,
+        0xCB61B38C,
+        0xBC66831A,
+        0x256FD2A0,
+        0x5268E236,
+        0xCC0C7795,
+        0xBB0B4703,
+        0x220216B9,
+        0x5505262F,
+        0xC5BA3BBE,
+        0xB2BD0B28,
+        0x2BB45A92,
+        0x5CB36A04,
+        0xC2D7FFA7,
+        0xB5D0CF31,
+        0x2CD99E8B,
+        0x5BDEAE1D,
+        0x9B64C2B0,
+        0xEC63F226,
+        0x756AA39C,
+        0x026D930A,
+        0x9C0906A9,
+        0xEB0E363F,
+        0x72076785,
+        0x05005713,
+        0x95BF4A82,
+        0xE2B87A14,
+        0x7BB12BAE,
+        0x0CB61B38,
+        0x92D28E9B,
+        0xE5D5BE0D,
+        0x7CDCEFB7,
+        0x0BDBDF21,
+        0x86D3D2D4,
+        0xF1D4E242,
+        0x68DDB3F8,
+        0x1FDA836E,
+        0x81BE16CD,
+        0xF6B9265B,
+        0x6FB077E1,
+        0x18B74777,
+        0x88085AE6,
+        0xFF0F6A70,
+        0x66063BCA,
+        0x11010B5C,
+        0x8F659EFF,
+        0xF862AE69,
+        0x616BFFD3,
+        0x166CCF45,
+        0xA00AE278,
+        0xD70DD2EE,
+        0x4E048354,
+        0x3903B3C2,
+        0xA7672661,
+        0xD06016F7,
+        0x4969474D,
+        0x3E6E77DB,
+        0xAED16A4A,
+        0xD9D65ADC,
+        0x40DF0B66,
+        0x37D83BF0,
+        0xA9BCAE53,
+        0xDEBB9EC5,
+        0x47B2CF7F,
+        0x30B5FFE9,
+        0xBDBDF21C,
+        0xCABAC28A,
+        0x53B39330,
+        0x24B4A3A6,
+        0xBAD03605,
+        0xCDD70693,
+        0x54DE5729,
+        0x23D967BF,
+        0xB3667A2E,
+        0xC4614AB8,
+        0x5D681B02,
+        0x2A6F2B94,
+        0xB40BBE37,
+        0xC30C8EA1,
+        0x5A05DF1B,
+        0x2D02EF8D,
+    ];
+
+    /** @var array encryption keys */
+    private array $keys;
+
+    public function __construct(string $password)
+    {
+        if (\PHP_INT_SIZE === 4) {
+            throw new RuntimeException('Traditional PKWARE Encryption is not supported in 32-bit PHP.');
+        }
+
+        $this->keys = [
+            305419896,
+            591751049,
+            878082192,
+        ];
+
+        foreach (unpack('C*', $password) as $byte) {
+            $this->updateKeys($byte);
+        }
+    }
+
+    /**
+     * @throws ZipAuthenticationException
+     */
+    public function checkHeader(string $header, int $checkByte): void
+    {
+        $byte = 0;
+
+        foreach (unpack('C*', $header) as $byte) {
+            $byte = ($byte ^ $this->decryptByte()) & 0xFF;
+            $this->updateKeys($byte);
+        }
+
+        if ($byte !== $checkByte) {
+            throw new ZipAuthenticationException('Invalid password');
+        }
+    }
+
+    public function decryptString(string $content): string
+    {
+        $decryptContent = '';
+
+        foreach (unpack('C*', $content) as $byte) {
+            $byte = ($byte ^ $this->decryptByte()) & 0xFF;
+            $this->updateKeys($byte);
+            $decryptContent .= \chr($byte);
+        }
+
+        return $decryptContent;
+    }
+
+    /**
+     * Decrypt byte.
+     */
+    private function decryptByte(): int
+    {
+        $temp = $this->keys[2] | 2;
+
+        return (($temp * ($temp ^ 1)) >> 8) & 0xFFFFFF;
+    }
+
+    /**
+     * Update keys.
+     */
+    private function updateKeys(int $charAt): void
+    {
+        $this->keys[0] = $this->crc32($this->keys[0], $charAt);
+        $this->keys[1] += ($this->keys[0] & 0xFF);
+        $this->keys[1] = MathUtil::toSignedInt32($this->keys[1] * 134775813 + 1);
+        $this->keys[2] = MathUtil::toSignedInt32($this->crc32($this->keys[2], ($this->keys[1] >> 24) & 0xFF));
+    }
+
+    /**
+     * Update crc.
+     */
+    private function crc32(int $oldCrc, int $charAt): int
+    {
+        return (($oldCrc >> 8) & 0xFFFFFF) ^ self::CRC_TABLE[($oldCrc ^ $charAt) & 0xFF];
+    }
+
+    public function encryptString(string $content): string
+    {
+        $encryptContent = '';
+
+        foreach (unpack('C*', $content) as $val) {
+            $encryptContent .= pack('c', $this->encryptByte($val));
+        }
+
+        return $encryptContent;
+    }
+
+    private function encryptByte(int $byte): int
+    {
+        $tempVal = $byte ^ $this->decryptByte() & 0xFF;
+        $this->updateKeys($byte);
+
+        return $tempVal;
+    }
+}
--- a/src/IO/Filter/Cipher/Pkware/PKDecryptionStreamFilter.php
+++ b/src/IO/Filter/Cipher/Pkware/PKDecryptionStreamFilter.php
@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Filter\Cipher\Pkware;
+
+use PhpZip\Exception\ZipAuthenticationException;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Decryption PKWARE Traditional Encryption.
+ */
+class PKDecryptionStreamFilter extends \php_user_filter
+{
+    public const FILTER_NAME = 'phpzip.decryption.pkware';
+
+    private int $checkByte = 0;
+
+    private int $readLength = 0;
+
+    private int $size = 0;
+
+    private bool $readHeader = false;
+
+    private PKCryptContext $context;
+
+    public static function register(): bool
+    {
+        return stream_filter_register(self::FILTER_NAME, __CLASS__);
+    }
+
+    /**
+     * @see https://php.net/manual/en/php-user-filter.oncreate.php
+     */
+    public function onCreate(): bool
+    {
+        if (!isset($this->params['entry'])) {
+            return false;
+        }
+
+        if (!($this->params['entry'] instanceof ZipEntry)) {
+            throw new \RuntimeException('ZipEntry expected');
+        }
+        /** @var ZipEntry $entry */
+        $entry = $this->params['entry'];
+        $password = $entry->getPassword();
+
+        if ($password === null) {
+            return false;
+        }
+
+        $this->size = $entry->getCompressedSize();
+
+        // init context
+        $this->context = new PKCryptContext($password);
+
+        // init check byte
+        if ($entry->isDataDescriptorEnabled()) {
+            $this->checkByte = ($entry->getDosTime() >> 8) & 0xFF;
+        } else {
+            $this->checkByte = ($entry->getCrc() >> 24) & 0xFF;
+        }
+
+        $this->readLength = 0;
+        $this->readHeader = false;
+
+        return true;
+    }
+
+    /**
+     * Decryption filter.
+     *
+     * @todo USE FFI in php 7.4
+     * @noinspection PhpDocSignatureInspection
+     *
+     * @param mixed $in
+     * @param mixed $out
+     * @param mixed $consumed
+     * @param mixed $closing
+     *
+     * @throws ZipAuthenticationException
+     */
+    public function filter($in, $out, &$consumed, $closing): int
+    {
+        while ($bucket = stream_bucket_make_writeable($in)) {
+            $buffer = $bucket->data;
+            $this->readLength += $bucket->datalen;
+
+            if ($this->readLength > $this->size) {
+                $buffer = substr($buffer, 0, $this->size - $this->readLength);
+            }
+
+            if (!$this->readHeader) {
+                $header = substr($buffer, 0, PKCryptContext::STD_DEC_HDR_SIZE);
+                $this->context->checkHeader($header, $this->checkByte);
+
+                $buffer = substr($buffer, PKCryptContext::STD_DEC_HDR_SIZE);
+                $this->readHeader = true;
+            }
+
+            $bucket->data = $this->context->decryptString($buffer);
+
+            $consumed += $bucket->datalen;
+            stream_bucket_append($out, $bucket);
+        }
+
+        return \PSFS_PASS_ON;
+    }
+}
--- a/src/IO/Filter/Cipher/Pkware/PKEncryptionStreamFilter.php
+++ b/src/IO/Filter/Cipher/Pkware/PKEncryptionStreamFilter.php
@@ -0,0 +1,127 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Filter\Cipher\Pkware;
+
+use PhpZip\Exception\RuntimeException;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Encryption PKWARE Traditional Encryption.
+ */
+class PKEncryptionStreamFilter extends \php_user_filter
+{
+    public const FILTER_NAME = 'phpzip.encryption.pkware';
+
+    private int $size;
+
+    private string $headerBytes;
+
+    private int $writeLength;
+
+    private bool $writeHeader;
+
+    private PKCryptContext $context;
+
+    public static function register(): bool
+    {
+        return stream_filter_register(self::FILTER_NAME, __CLASS__);
+    }
+
+    /**
+     * @see https://php.net/manual/en/php-user-filter.oncreate.php
+     */
+    public function onCreate(): bool
+    {
+        if (\PHP_INT_SIZE === 4) {
+            throw new RuntimeException('Traditional PKWARE Encryption is not supported in 32-bit PHP.');
+        }
+
+        if (!isset($this->params['entry'], $this->params['size'])) {
+            return false;
+        }
+
+        if (!($this->params['entry'] instanceof ZipEntry)) {
+            throw new \RuntimeException('ZipEntry expected');
+        }
+        /** @var ZipEntry $entry */
+        $entry = $this->params['entry'];
+        $password = $entry->getPassword();
+
+        if ($password === null) {
+            return false;
+        }
+
+        $this->size = (int) $this->params['size'];
+
+        // init keys
+        $this->context = new PKCryptContext($password);
+
+        $crc = $entry->isDataDescriptorRequired() || $entry->getCrc() === ZipEntry::UNKNOWN
+            ? ($entry->getDosTime() & 0x0000FFFF) << 16
+            : $entry->getCrc();
+
+        try {
+            $headerBytes = random_bytes(PKCryptContext::STD_DEC_HDR_SIZE);
+        } catch (\Exception $e) {
+            throw new \RuntimeException('Oops, our server is bust and cannot generate any random data.', 1, $e);
+        }
+
+        $headerBytes[PKCryptContext::STD_DEC_HDR_SIZE - 1] = pack('c', ($crc >> 24) & 0xFF);
+        $headerBytes[PKCryptContext::STD_DEC_HDR_SIZE - 2] = pack('c', ($crc >> 16) & 0xFF);
+
+        $this->headerBytes = $headerBytes;
+        $this->writeLength = 0;
+        $this->writeHeader = false;
+
+        return true;
+    }
+
+    /**
+     * Encryption filter.
+     *
+     * @todo USE FFI in php 7.4
+     *
+     * @noinspection PhpDocSignatureInspection
+     *
+     * @param mixed $in
+     * @param mixed $out
+     * @param mixed $consumed
+     * @param mixed $closing
+     */
+    public function filter($in, $out, &$consumed, $closing): int
+    {
+        while ($bucket = stream_bucket_make_writeable($in)) {
+            $buffer = $bucket->data;
+            $this->writeLength += $bucket->datalen;
+
+            if ($this->writeLength > $this->size) {
+                $buffer = substr($buffer, 0, $this->size - $this->writeLength);
+            }
+
+            $data = '';
+
+            if (!$this->writeHeader) {
+                $data .= $this->context->encryptString($this->headerBytes);
+                $this->writeHeader = true;
+            }
+
+            $data .= $this->context->encryptString($buffer);
+
+            $bucket->data = $data;
+
+            $consumed += $bucket->datalen;
+            stream_bucket_append($out, $bucket);
+        }
+
+        return \PSFS_PASS_ON;
+    }
+}
--- a/src/IO/Filter/Cipher/WinZipAes/WinZipAesContext.php
+++ b/src/IO/Filter/Cipher/WinZipAes/WinZipAesContext.php
@@ -0,0 +1,141 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Filter\Cipher\WinZipAes;
+
+use PhpZip\Exception\RuntimeException;
+use PhpZip\Exception\ZipAuthenticationException;
+use PhpZip\Util\CryptoUtil;
+
+/**
+ * WinZip Aes Encryption.
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT APPENDIX E
+ * @see https://www.winzip.com/win/en/aes_info.html
+ *
+ * @internal
+ */
+class WinZipAesContext
+{
+    /** @var int AES Block size */
+    public const BLOCK_SIZE = self::IV_SIZE;
+
+    /** @var int Footer size */
+    public const FOOTER_SIZE = 10;
+
+    /** @var int The iteration count for the derived keys of the cipher, KLAC and MAC. */
+    public const ITERATION_COUNT = 1000;
+
+    /** @var int Password verifier size */
+    public const PASSWORD_VERIFIER_SIZE = 2;
+
+    /** @var int IV size */
+    public const IV_SIZE = 16;
+
+    private string $iv;
+
+    private string $key;
+
+    private \HashContext $hmacContext;
+
+    private string $passwordVerifier;
+
+    public function __construct(int $encryptionStrengthBits, string $password, string $salt)
+    {
+        if ($password === '') {
+            throw new RuntimeException('$password is empty');
+        }
+
+        if (empty($salt)) {
+            throw new RuntimeException('$salt is empty');
+        }
+
+        // WinZip 99-character limit https://sourceforge.net/p/p7zip/discussion/383044/thread/c859a2f0/
+        $password = substr($password, 0, 99);
+
+        $this->iv = str_repeat("\0", self::IV_SIZE);
+        $keyStrengthBytes = (int) ($encryptionStrengthBits / 8);
+        $hashLength = $keyStrengthBytes * 2 + self::PASSWORD_VERIFIER_SIZE * 8;
+
+        $hash = hash_pbkdf2(
+            'sha1',
+            $password,
+            $salt,
+            self::ITERATION_COUNT,
+            $hashLength,
+            true
+        );
+
+        $this->key = substr($hash, 0, $keyStrengthBytes);
+        $sha1Mac = substr($hash, $keyStrengthBytes, $keyStrengthBytes);
+        $this->hmacContext = hash_init('sha1', \HASH_HMAC, $sha1Mac);
+        $this->passwordVerifier = substr($hash, 2 * $keyStrengthBytes, self::PASSWORD_VERIFIER_SIZE);
+    }
+
+    public function getPasswordVerifier(): string
+    {
+        return $this->passwordVerifier;
+    }
+
+    public function updateIv(): void
+    {
+        for ($ivCharIndex = 0; $ivCharIndex < self::IV_SIZE; $ivCharIndex++) {
+            $ivByte = \ord($this->iv[$ivCharIndex]);
+
+            if (++$ivByte === 256) {
+                // overflow, set this one to 0, increment next
+                $this->iv[$ivCharIndex] = "\0";
+            } else {
+                // no overflow, just write incremented number back and abort
+                $this->iv[$ivCharIndex] = \chr($ivByte);
+
+                break;
+            }
+        }
+    }
+
+    public function decryption(string $data): string
+    {
+        hash_update($this->hmacContext, $data);
+
+        return CryptoUtil::decryptAesCtr($data, $this->key, $this->iv);
+    }
+
+    public function encrypt(string $data): string
+    {
+        $encryptionData = CryptoUtil::encryptAesCtr($data, $this->key, $this->iv);
+        hash_update($this->hmacContext, $encryptionData);
+
+        return $encryptionData;
+    }
+
+    /**
+     * @throws ZipAuthenticationException
+     */
+    public function checkAuthCode(string $authCode): void
+    {
+        $hmac = $this->getHmac();
+
+        // check authenticationCode
+        if (strcmp($hmac, $authCode) !== 0) {
+            throw new ZipAuthenticationException('Authenticated WinZip AES entry content has been tampered with.');
+        }
+    }
+
+    public function getHmac(): string
+    {
+        return substr(
+            hash_final($this->hmacContext, true),
+            0,
+            self::FOOTER_SIZE
+        );
+    }
+}
--- a/src/IO/Filter/Cipher/WinZipAes/WinZipAesDecryptionStreamFilter.php
+++ b/src/IO/Filter/Cipher/WinZipAes/WinZipAesDecryptionStreamFilter.php
@@ -0,0 +1,184 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Filter\Cipher\WinZipAes;
+
+use PhpZip\Exception\RuntimeException;
+use PhpZip\Exception\ZipAuthenticationException;
+use PhpZip\Model\Extra\Fields\WinZipAesExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Decrypt WinZip AES stream.
+ */
+class WinZipAesDecryptionStreamFilter extends \php_user_filter
+{
+    public const FILTER_NAME = 'phpzip.decryption.winzipaes';
+
+    private string $buffer;
+
+    private ?string $authenticationCode = null;
+
+    private int $encBlockPosition = 0;
+
+    private int $encBlockLength = 0;
+
+    private int $readLength = 0;
+
+    private ZipEntry $entry;
+
+    private ?WinZipAesContext $context = null;
+
+    public static function register(): bool
+    {
+        return stream_filter_register(self::FILTER_NAME, __CLASS__);
+    }
+
+    /**
+     * @noinspection DuplicatedCode
+     */
+    public function onCreate(): bool
+    {
+        if (!isset($this->params['entry'])) {
+            return false;
+        }
+
+        if (!($this->params['entry'] instanceof ZipEntry)) {
+            throw new \RuntimeException('ZipEntry expected');
+        }
+        $this->entry = $this->params['entry'];
+
+        if (
+            $this->entry->getPassword() === null
+            || !$this->entry->isEncrypted()
+            || !$this->entry->hasExtraField(WinZipAesExtraField::HEADER_ID)
+        ) {
+            return false;
+        }
+
+        $this->buffer = '';
+
+        return true;
+    }
+
+    /**
+     * @noinspection PhpDocSignatureInspection
+     *
+     * @param mixed $in
+     * @param mixed $out
+     * @param mixed $consumed
+     * @param mixed $closing
+     *
+     * @throws ZipAuthenticationException
+     */
+    public function filter($in, $out, &$consumed, $closing): int
+    {
+        while ($bucket = stream_bucket_make_writeable($in)) {
+            $this->buffer .= $bucket->data;
+            $this->readLength += $bucket->datalen;
+
+            if ($this->readLength > $this->entry->getCompressedSize()) {
+                $this->buffer = substr($this->buffer, 0, $this->entry->getCompressedSize() - $this->readLength);
+            }
+
+            // read header
+            if ($this->context === null) {
+                /**
+                 * @var WinZipAesExtraField|null $winZipExtra
+                 */
+                $winZipExtra = $this->entry->getExtraField(WinZipAesExtraField::HEADER_ID);
+
+                if ($winZipExtra === null) {
+                    throw new RuntimeException('$winZipExtra is null');
+                }
+                $saltSize = $winZipExtra->getSaltSize();
+                $headerSize = $saltSize + WinZipAesContext::PASSWORD_VERIFIER_SIZE;
+
+                if (\strlen($this->buffer) < $headerSize) {
+                    return \PSFS_FEED_ME;
+                }
+
+                $salt = substr($this->buffer, 0, $saltSize);
+                $passwordVerifier = substr($this->buffer, $saltSize, WinZipAesContext::PASSWORD_VERIFIER_SIZE);
+                $password = $this->entry->getPassword();
+
+                if ($password === null) {
+                    throw new RuntimeException('$password is null');
+                }
+                $this->context = new WinZipAesContext($winZipExtra->getEncryptionStrength(), $password, $salt);
+                unset($password);
+
+                // Verify password.
+                if ($passwordVerifier !== $this->context->getPasswordVerifier()) {
+                    throw new ZipAuthenticationException('Invalid password');
+                }
+
+                $this->encBlockPosition = 0;
+                $this->encBlockLength = $this->entry->getCompressedSize() - $headerSize - WinZipAesContext::FOOTER_SIZE;
+
+                $this->buffer = substr($this->buffer, $headerSize);
+            }
+
+            // encrypt data
+            $plainText = '';
+            $offset = 0;
+            $len = \strlen($this->buffer);
+            $remaining = $this->encBlockLength - $this->encBlockPosition;
+
+            if ($remaining >= WinZipAesContext::BLOCK_SIZE && $len < WinZipAesContext::BLOCK_SIZE) {
+                return \PSFS_FEED_ME;
+            }
+            $limit = min($len, $remaining);
+
+            if ($remaining > $limit && ($limit % WinZipAesContext::BLOCK_SIZE) !== 0) {
+                $limit -= ($limit % WinZipAesContext::BLOCK_SIZE);
+            }
+
+            while ($offset < $limit) {
+                $this->context->updateIv();
+                $length = min(WinZipAesContext::BLOCK_SIZE, $limit - $offset);
+                $data = substr($this->buffer, 0, $length);
+                $plainText .= $this->context->decryption($data);
+                $offset += $length;
+                $this->buffer = substr($this->buffer, $length);
+            }
+            $this->encBlockPosition += $offset;
+
+            if (
+                $this->encBlockPosition === $this->encBlockLength
+                && \strlen($this->buffer) === WinZipAesContext::FOOTER_SIZE
+            ) {
+                $this->authenticationCode = $this->buffer;
+                $this->buffer = '';
+            }
+
+            $bucket->data = $plainText;
+            $consumed += $bucket->datalen;
+            stream_bucket_append($out, $bucket);
+        }
+
+        return \PSFS_PASS_ON;
+    }
+
+    /**
+     * @see http://php.net/manual/en/php-user-filter.onclose.php
+     *
+     * @throws ZipAuthenticationException
+     */
+    public function onClose(): void
+    {
+        $this->buffer = '';
+
+        if ($this->context !== null && $this->authenticationCode !== null) {
+            $this->context->checkAuthCode($this->authenticationCode);
+        }
+    }
+}
--- a/src/IO/Filter/Cipher/WinZipAes/WinZipAesEncryptionStreamFilter.php
+++ b/src/IO/Filter/Cipher/WinZipAes/WinZipAesEncryptionStreamFilter.php
@@ -0,0 +1,150 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Filter\Cipher\WinZipAes;
+
+use PhpZip\Exception\RuntimeException;
+use PhpZip\Model\Extra\Fields\WinZipAesExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Encrypt WinZip AES stream.
+ */
+class WinZipAesEncryptionStreamFilter extends \php_user_filter
+{
+    public const FILTER_NAME = 'phpzip.encryption.winzipaes';
+
+    private string $buffer;
+
+    private int $remaining = 0;
+
+    private ZipEntry $entry;
+
+    private int $size;
+
+    private ?WinZipAesContext $context = null;
+
+    public static function register(): bool
+    {
+        return stream_filter_register(self::FILTER_NAME, __CLASS__);
+    }
+
+    /**
+     * @noinspection DuplicatedCode
+     */
+    public function onCreate(): bool
+    {
+        if (!isset($this->params['entry'])) {
+            return false;
+        }
+
+        if (!($this->params['entry'] instanceof ZipEntry)) {
+            throw new \RuntimeException('ZipEntry expected');
+        }
+        $this->entry = $this->params['entry'];
+
+        if (
+            $this->entry->getPassword() === null
+            || !$this->entry->isEncrypted()
+            || !$this->entry->hasExtraField(WinZipAesExtraField::HEADER_ID)
+        ) {
+            return false;
+        }
+
+        $this->size = (int) $this->params['size'];
+        $this->context = null;
+        $this->buffer = '';
+
+        return true;
+    }
+
+    public function filter($in, $out, &$consumed, $closing): int
+    {
+        while ($bucket = stream_bucket_make_writeable($in)) {
+            $this->buffer .= $bucket->data;
+            $this->remaining += $bucket->datalen;
+
+            if ($this->remaining > $this->size) {
+                $this->buffer = substr($this->buffer, 0, $this->size - $this->remaining);
+                $this->remaining = $this->size;
+            }
+
+            $encryptionText = '';
+
+            // write header
+            if ($this->context === null) {
+                /**
+                 * @var WinZipAesExtraField|null $winZipExtra
+                 */
+                $winZipExtra = $this->entry->getExtraField(WinZipAesExtraField::HEADER_ID);
+
+                if ($winZipExtra === null) {
+                    throw new RuntimeException('$winZipExtra is null');
+                }
+                /** @psalm-var positive-int $saltSize */
+                $saltSize = $winZipExtra->getSaltSize();
+
+                try {
+                    $salt = random_bytes($saltSize);
+                } catch (\Exception $e) {
+                    throw new \RuntimeException('Oops, our server is bust and cannot generate any random data.', 1, $e);
+                }
+                $password = $this->entry->getPassword();
+
+                if ($password === null) {
+                    throw new RuntimeException('$password is null');
+                }
+                $this->context = new WinZipAesContext(
+                    $winZipExtra->getEncryptionStrength(),
+                    $password,
+                    $salt
+                );
+
+                $encryptionText .= $salt . $this->context->getPasswordVerifier();
+            }
+
+            // encrypt data
+            $offset = 0;
+            $len = \strlen($this->buffer);
+            $remaining = $this->remaining - $this->size;
+
+            if ($remaining >= WinZipAesContext::BLOCK_SIZE && $len < WinZipAesContext::BLOCK_SIZE) {
+                return \PSFS_FEED_ME;
+            }
+            $limit = max($len, $remaining);
+
+            if ($remaining > $limit && ($limit % WinZipAesContext::BLOCK_SIZE) !== 0) {
+                $limit -= ($limit % WinZipAesContext::BLOCK_SIZE);
+            }
+
+            while ($offset < $limit) {
+                $this->context->updateIv();
+                $length = min(WinZipAesContext::BLOCK_SIZE, $limit - $offset);
+                $encryptionText .= $this->context->encrypt(
+                    substr($this->buffer, 0, $length)
+                );
+                $offset += $length;
+                $this->buffer = substr($this->buffer, $length);
+            }
+
+            if ($remaining === 0) {
+                $encryptionText .= $this->context->getHmac();
+            }
+
+            $bucket->data = $encryptionText;
+            $consumed += $bucket->datalen;
+
+            stream_bucket_append($out, $bucket);
+        }
+
+        return \PSFS_PASS_ON;
+    }
+}
--- a/src/IO/Stream/ResponseStream.php
+++ b/src/IO/Stream/ResponseStream.php
@@ -0,0 +1,290 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Stream;
+
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * Implement PSR Message Stream.
+ */
+class ResponseStream implements StreamInterface
+{
+    /** @var array */
+    private const READ_WRITE_MAP = [
+        'read' => [
+            'r' => true,
+            'w+' => true,
+            'r+' => true,
+            'x+' => true,
+            'c+' => true,
+            'rb' => true,
+            'w+b' => true,
+            'r+b' => true,
+            'x+b' => true,
+            'c+b' => true,
+            'rt' => true,
+            'w+t' => true,
+            'r+t' => true,
+            'x+t' => true,
+            'c+t' => true,
+            'a+' => true,
+        ],
+        'write' => [
+            'w' => true,
+            'w+' => true,
+            'rw' => true,
+            'r+' => true,
+            'x+' => true,
+            'c+' => true,
+            'wb' => true,
+            'w+b' => true,
+            'r+b' => true,
+            'x+b' => true,
+            'c+b' => true,
+            'w+t' => true,
+            'r+t' => true,
+            'x+t' => true,
+            'c+t' => true,
+            'a' => true,
+            'a+' => true,
+        ],
+    ];
+
+    /** @var resource|null */
+    private $stream;
+
+    private ?int $size = null;
+
+    private bool $seekable;
+
+    private bool $readable;
+
+    private bool $writable;
+
+    private ?string $uri;
+
+    /**
+     * @param resource $stream stream resource to wrap
+     *
+     * @throws \InvalidArgumentException if the stream is not a stream resource
+     */
+    public function __construct($stream)
+    {
+        if (!\is_resource($stream)) {
+            throw new \InvalidArgumentException('Stream must be a resource');
+        }
+        $this->stream = $stream;
+        $meta = stream_get_meta_data($this->stream);
+        $this->seekable = $meta['seekable'];
+        $this->readable = isset(self::READ_WRITE_MAP['read'][$meta['mode']]);
+        $this->writable = isset(self::READ_WRITE_MAP['write'][$meta['mode']]);
+        $this->uri = $this->getMetadata('uri');
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @noinspection PhpMissingReturnTypeInspection
+     */
+    public function getMetadata($key = null)
+    {
+        if ($this->stream === null) {
+            return $key ? null : [];
+        }
+        $meta = stream_get_meta_data($this->stream);
+
+        return $meta[$key] ?? null;
+    }
+
+    /**
+     * Reads all data from the stream into a string, from the beginning to end.
+     *
+     * This method MUST attempt to seek to the beginning of the stream before
+     * reading data and read the stream until the end is reached.
+     *
+     * Warning: This could attempt to load a large amount of data into memory.
+     *
+     * This method MUST NOT raise an exception in order to conform with PHP's
+     * string casting operations.
+     *
+     * @see http://php.net/manual/en/language.oop5.magic.php#object.tostring
+     */
+    public function __toString(): string
+    {
+        if (!$this->stream) {
+            return '';
+        }
+        $this->rewind();
+
+        return (string) stream_get_contents($this->stream);
+    }
+
+    /**
+     * Seek to the beginning of the stream.
+     *
+     * If the stream is not seekable, this method will raise an exception;
+     * otherwise, it will perform a seek(0).
+     *
+     * @throws \RuntimeException on failure
+     *
+     * @see http://www.php.net/manual/en/function.fseek.php
+     * @see seek()
+     */
+    public function rewind(): void
+    {
+        $this->stream !== null && $this->seekable && rewind($this->stream);
+    }
+
+    /**
+     * Get the size of the stream if known.
+     *
+     * @return int|null returns the size in bytes if known, or null if unknown
+     */
+    public function getSize(): ?int
+    {
+        if ($this->size !== null) {
+            return $this->size;
+        }
+
+        if (!$this->stream) {
+            return null;
+        }
+        // Clear the stat cache if the stream has a URI
+        if ($this->uri !== null) {
+            clearstatcache(true, $this->uri);
+        }
+        $stats = fstat($this->stream);
+
+        if (isset($stats['size'])) {
+            $this->size = $stats['size'];
+
+            return $this->size;
+        }
+
+        return null;
+    }
+
+    public function tell()
+    {
+        return $this->stream ? ftell($this->stream) : false;
+    }
+
+    /**
+     * Returns true if the stream is at the end of the stream.
+     */
+    public function eof(): bool
+    {
+        return !$this->stream || feof($this->stream);
+    }
+
+    /**
+     * Returns whether or not the stream is seekable.
+     */
+    public function isSeekable(): bool
+    {
+        return $this->seekable;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function seek($offset, $whence = \SEEK_SET): void
+    {
+        $this->stream !== null && $this->seekable && fseek($this->stream, $offset, $whence);
+    }
+
+    /**
+     * Returns whether or not the stream is writable.
+     */
+    public function isWritable(): bool
+    {
+        return $this->writable;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function write($string)
+    {
+        $this->size = null;
+
+        return $this->stream !== null && $this->writable ? fwrite($this->stream, $string) : false;
+    }
+
+    /**
+     * Returns whether or not the stream is readable.
+     */
+    public function isReadable(): bool
+    {
+        return $this->readable;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function read($length): string
+    {
+        return $this->stream !== null && $this->readable ? fread($this->stream, $length) : '';
+    }
+
+    /**
+     * Returns the remaining contents in a string.
+     *
+     * @throws \RuntimeException if unable to read or an error occurs while
+     *                           reading
+     */
+    public function getContents(): string
+    {
+        return $this->stream ? stream_get_contents($this->stream) : '';
+    }
+
+    /**
+     * Closes the stream when the destructed.
+     */
+    public function __destruct()
+    {
+        $this->close();
+    }
+
+    /**
+     * Closes the stream and any underlying resources.
+     *
+     * @psalm-suppress InvalidPropertyAssignmentValue
+     */
+    public function close(): void
+    {
+        if (\is_resource($this->stream)) {
+            fclose($this->stream);
+        }
+        $this->detach();
+    }
+
+    /**
+     * Separates any underlying resources from the stream.
+     *
+     * After the stream has been detached, the stream is in an unusable state.
+     *
+     * @return resource|null Underlying PHP stream, if any
+     */
+    public function detach()
+    {
+        $result = $this->stream;
+        $this->stream = null;
+        $this->size = null;
+        $this->uri = null;
+        $this->readable = false;
+        $this->writable = false;
+        $this->seekable = false;
+
+        return $result;
+    }
+}
--- a/src/IO/Stream/ZipEntryStreamWrapper.php
+++ b/src/IO/Stream/ZipEntryStreamWrapper.php
@@ -0,0 +1,309 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO\Stream;
+
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * The class provides stream reuse functionality.
+ *
+ * Stream will not be closed at {@see fclose}.
+ *
+ * @see https://www.php.net/streamwrapper
+ */
+final class ZipEntryStreamWrapper
+{
+    /** @var string the registered protocol */
+    public const PROTOCOL = 'zipentry';
+
+    /** @var resource */
+    public $context;
+
+    /** @var resource */
+    private $fp;
+
+    public static function register(): bool
+    {
+        $protocol = self::PROTOCOL;
+
+        if (!\in_array($protocol, stream_get_wrappers(), true)) {
+            if (!stream_wrapper_register($protocol, self::class)) {
+                throw new \RuntimeException("Failed to register '{$protocol}://' protocol");
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public static function unregister(): void
+    {
+        stream_wrapper_unregister(self::PROTOCOL);
+    }
+
+    /**
+     * @return resource
+     */
+    public static function wrap(ZipEntry $entry)
+    {
+        self::register();
+
+        $context = stream_context_create(
+            [
+                self::PROTOCOL => [
+                    'entry' => $entry,
+                ],
+            ]
+        );
+
+        $uri = self::PROTOCOL . '://' . $entry->getName();
+        $fp = fopen($uri, 'r+b', false, $context);
+
+        if ($fp === false) {
+            throw new \RuntimeException('Error open ' . $uri);
+        }
+
+        return $fp;
+    }
+
+    /**
+     * Opens file or URL.
+     *
+     * This method is called immediately after the wrapper is
+     * initialized (f.e. by {@see fopen()} and {@see file_get_contents()}).
+     *
+     * @param string      $path        specifies the URL that was passed to
+     *                                 the original function
+     * @param string      $mode        the mode used to open the file, as detailed
+     *                                 for {@see fopen()}
+     * @param int         $options     Holds additional flags set by the streams
+     *                                 API. It can hold one or more of the
+     *                                 following values OR'd together.
+     * @param string|null $opened_path if the path is opened successfully, and
+     *                                 STREAM_USE_PATH is set in options,
+     *                                 opened_path should be set to the
+     *                                 full path of the file/resource that
+     *                                 was actually opened
+     *
+     * @throws ZipException
+     *
+     * @see https://www.php.net/streamwrapper.stream-open
+     */
+    public function stream_open(string $path, string $mode, int $options, ?string &$opened_path): bool
+    {
+        if ($this->context === null) {
+            throw new \RuntimeException('stream context is null');
+        }
+        $streamOptions = stream_context_get_options($this->context);
+
+        if (!isset($streamOptions[self::PROTOCOL]['entry'])) {
+            throw new \RuntimeException('no stream option ["' . self::PROTOCOL . '"]["entry"]');
+        }
+        $zipEntry = $streamOptions[self::PROTOCOL]['entry'];
+
+        if (!$zipEntry instanceof ZipEntry) {
+            throw new \RuntimeException('invalid stream context');
+        }
+
+        $zipData = $zipEntry->getData();
+
+        if ($zipData === null) {
+            throw new ZipException(sprintf('No data for zip entry "%s"', $zipEntry->getName()));
+        }
+        $this->fp = $zipData->getDataAsStream();
+
+        return $this->fp !== false;
+    }
+
+    /**
+     * Read from stream.
+     *
+     * This method is called in response to {@see fread()} and {@see fgets()}.
+     *
+     * Note: Remember to update the read/write position of the stream
+     * (by the number of bytes that were successfully read).
+     *
+     * @param int $count how many bytes of data from the current
+     *                   position should be returned
+     *
+     * @return false|string If there are less than count bytes available,
+     *                      return as many as are available. If no more data
+     *                      is available, return either FALSE or
+     *                      an empty string.
+     *
+     * @see https://www.php.net/streamwrapper.stream-read
+     */
+    public function stream_read(int $count)
+    {
+        return fread($this->fp, $count);
+    }
+
+    /**
+     * Seeks to specific location in a stream.
+     *
+     * This method is called in response to {@see fseek()}.
+     * The read/write position of the stream should be updated according
+     * to the offset and whence.
+     *
+     * @param int $offset the stream offset to seek to
+     * @param int $whence Possible values:
+     *                    {@see \SEEK_SET} - Set position equal to offset bytes.
+     *                    {@see \SEEK_CUR} - Set position to current location plus offset.
+     *                    {@see \SEEK_END} - Set position to end-of-file plus offset.
+     *
+     * @return bool return TRUE if the position was updated, FALSE otherwise
+     *
+     * @see https://www.php.net/streamwrapper.stream-seek
+     */
+    public function stream_seek(int $offset, int $whence = \SEEK_SET): bool
+    {
+        return fseek($this->fp, $offset, $whence) === 0;
+    }
+
+    /**
+     * Retrieve the current position of a stream.
+     *
+     * This method is called in response to {@see fseek()} to determine
+     * the current position.
+     *
+     * @return int should return the current position of the stream
+     *
+     * @see https://www.php.net/streamwrapper.stream-tell
+     */
+    public function stream_tell(): int
+    {
+        $pos = ftell($this->fp);
+
+        if ($pos === false) {
+            throw new \RuntimeException('Cannot get stream position.');
+        }
+
+        return $pos;
+    }
+
+    /**
+     * Tests for end-of-file on a file pointer.
+     *
+     * This method is called in response to {@see feof()}.
+     *
+     * @return bool should return TRUE if the read/write position is at
+     *              the end of the stream and if no more data is available
+     *              to be read, or FALSE otherwise
+     *
+     * @see https://www.php.net/streamwrapper.stream-eof
+     */
+    public function stream_eof(): bool
+    {
+        return feof($this->fp);
+    }
+
+    /**
+     * Retrieve information about a file resource.
+     *
+     * This method is called in response to {@see fstat()}.
+     *
+     * @see https://www.php.net/streamwrapper.stream-stat
+     * @see https://www.php.net/stat
+     * @see https://www.php.net/fstat
+     */
+    public function stream_stat(): array
+    {
+        return fstat($this->fp);
+    }
+
+    /**
+     * Flushes the output.
+     *
+     * This method is called in response to {@see fflush()} and when the
+     * stream is being closed while any unflushed data has been written to
+     * it before.
+     * If you have cached data in your stream but not yet stored it into
+     * the underlying storage, you should do so now.
+     *
+     * @return bool should return TRUE if the cached data was successfully
+     *              stored (or if there was no data to store), or FALSE
+     *              if the data could not be stored
+     *
+     * @see https://www.php.net/streamwrapper.stream-flush
+     */
+    public function stream_flush(): bool
+    {
+        return fflush($this->fp);
+    }
+
+    /**
+     * Truncate stream.
+     *
+     * Will respond to truncation, e.g., through {@see ftruncate()}.
+     *
+     * @param int $newSize the new size
+     *
+     * @return bool returns TRUE on success or FALSE on failure
+     *
+     * @see https://www.php.net/streamwrapper.stream-truncate
+     */
+    public function stream_truncate(int $newSize): bool
+    {
+        return ftruncate($this->fp, $newSize);
+    }
+
+    /**
+     * Write to stream.
+     *
+     * This method is called in response to {@see fwrite().}
+     *
+     * Note: Remember to update the current position of the stream by
+     * number of bytes that were successfully written.
+     *
+     * @param string $data should be stored into the underlying stream
+     *
+     * @return int should return the number of bytes that were successfully stored, or 0 if none could be stored
+     *
+     * @see https://www.php.net/streamwrapper.stream-write
+     */
+    public function stream_write(string $data): int
+    {
+        $bytes = fwrite($this->fp, $data);
+
+        return $bytes === false ? 0 : $bytes;
+    }
+
+    /**
+     * Retrieve the underlaying resource.
+     *
+     * This method is called in response to {@see stream_select()}.
+     *
+     * @param int $cast_as can be {@see STREAM_CAST_FOR_SELECT} when {@see stream_select()}
+     *                     is callingstream_cast() or {@see STREAM_CAST_AS_STREAM} when
+     *                     stream_cast() is called for other uses
+     *
+     * @return resource
+     */
+    public function stream_cast(int $cast_as)
+    {
+        return $this->fp;
+    }
+
+    /**
+     * Close a resource.
+     *
+     * This method is called in response to {@see fclose()}.
+     * All resources that were locked, or allocated, by the wrapper should be released.
+     *
+     * @see https://www.php.net/streamwrapper.stream-close
+     */
+    public function stream_close(): void
+    {
+    }
+}
--- a/src/IO/ZipReader.php
+++ b/src/IO/ZipReader.php
@@ -0,0 +1,883 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO;
+
+use PhpZip\Constants\DosCodePage;
+use PhpZip\Constants\GeneralPurposeBitFlag;
+use PhpZip\Constants\ZipCompressionMethod;
+use PhpZip\Constants\ZipConstants;
+use PhpZip\Constants\ZipEncryptionMethod;
+use PhpZip\Constants\ZipOptions;
+use PhpZip\Exception\Crc32Exception;
+use PhpZip\Exception\InvalidArgumentException;
+use PhpZip\Exception\ZipException;
+use PhpZip\IO\Filter\Cipher\Pkware\PKDecryptionStreamFilter;
+use PhpZip\IO\Filter\Cipher\WinZipAes\WinZipAesDecryptionStreamFilter;
+use PhpZip\Model\Data\ZipSourceFileData;
+use PhpZip\Model\EndOfCentralDirectory;
+use PhpZip\Model\Extra\ExtraFieldsCollection;
+use PhpZip\Model\Extra\Fields\UnicodePathExtraField;
+use PhpZip\Model\Extra\Fields\UnrecognizedExtraField;
+use PhpZip\Model\Extra\Fields\WinZipAesExtraField;
+use PhpZip\Model\Extra\Fields\Zip64ExtraField;
+use PhpZip\Model\Extra\ZipExtraDriver;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ImmutableZipContainer;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Zip reader.
+ */
+class ZipReader
+{
+    /** @var int file size */
+    protected int $size;
+
+    /** @var resource */
+    protected $inStream;
+
+    protected array $options;
+
+    /**
+     * @param resource $inStream
+     */
+    public function __construct($inStream, array $options = [])
+    {
+        if (!\is_resource($inStream)) {
+            throw new InvalidArgumentException('Stream must be a resource');
+        }
+        $type = get_resource_type($inStream);
+
+        if ($type !== 'stream') {
+            throw new InvalidArgumentException("Invalid resource type {$type}.");
+        }
+        $meta = stream_get_meta_data($inStream);
+
+        $wrapperType = $meta['wrapper_type'] ?? 'Unknown';
+        $supportStreamWrapperTypes = ['plainfile', 'PHP', 'user-space'];
+
+        if (!\in_array($wrapperType, $supportStreamWrapperTypes, true)) {
+            throw new InvalidArgumentException(
+                'The stream wrapper type "' . $wrapperType . '" is not supported. Support: ' . implode(
+                    ', ',
+                    $supportStreamWrapperTypes
+                )
+            );
+        }
+
+        if (
+            $wrapperType === 'plainfile'
+            && (
+                $meta['stream_type'] === 'dir'
+                || (isset($meta['uri']) && is_dir($meta['uri']))
+            )
+        ) {
+            throw new InvalidArgumentException('Directory stream not supported');
+        }
+
+        $seekable = $meta['seekable'];
+
+        if (!$seekable) {
+            throw new InvalidArgumentException('Resource does not support seekable.');
+        }
+        $this->size = fstat($inStream)['size'];
+        $this->inStream = $inStream;
+
+        /** @noinspection AdditionOperationOnArraysInspection */
+        $options += $this->getDefaultOptions();
+        $this->options = $options;
+    }
+
+    protected function getDefaultOptions(): array
+    {
+        return [
+            ZipOptions::CHARSET => null,
+        ];
+    }
+
+    /**
+     * @throws ZipException
+     */
+    public function read(): ImmutableZipContainer
+    {
+        if ($this->size < ZipConstants::END_CD_MIN_LEN) {
+            throw new ZipException('Corrupt zip file');
+        }
+
+        $endOfCentralDirectory = $this->readEndOfCentralDirectory();
+        $entries = $this->readCentralDirectory($endOfCentralDirectory);
+
+        return new ImmutableZipContainer($entries, $endOfCentralDirectory->getComment());
+    }
+
+    public function getStreamMetaData(): array
+    {
+        return stream_get_meta_data($this->inStream);
+    }
+
+    /**
+     * Read End of central directory record.
+     *
+     * end of central dir signature    4 bytes  (0x06054b50)
+     * number of this disk             2 bytes
+     * number of the disk with the
+     * start of the central directory  2 bytes
+     * total number of entries in the
+     * central directory on this disk  2 bytes
+     * total number of entries in
+     * the central directory           2 bytes
+     * size of the central directory   4 bytes
+     * offset of start of central
+     * directory with respect to
+     * the starting disk number        4 bytes
+     * .ZIP file comment length        2 bytes
+     * .ZIP file comment       (variable size)
+     *
+     * @throws ZipException
+     */
+    protected function readEndOfCentralDirectory(): EndOfCentralDirectory
+    {
+        if (!$this->findEndOfCentralDirectory()) {
+            throw new ZipException('Invalid zip file. The end of the central directory could not be found.');
+        }
+
+        $positionECD = ftell($this->inStream) - 4;
+        $sizeECD = $this->size - ftell($this->inStream);
+        $buffer = fread($this->inStream, $sizeECD);
+
+        [
+            'diskNo' => $diskNo,
+            'cdDiskNo' => $cdDiskNo,
+            'cdEntriesDisk' => $cdEntriesDisk,
+            'cdEntries' => $cdEntries,
+            'cdSize' => $cdSize,
+            'cdPos' => $cdPos,
+            'commentLength' => $commentLength,
+        ] = unpack(
+            'vdiskNo/vcdDiskNo/vcdEntriesDisk/'
+            . 'vcdEntries/VcdSize/VcdPos/vcommentLength',
+            substr($buffer, 0, 18)
+        );
+
+        if (
+            $diskNo !== 0
+            || $cdDiskNo !== 0
+            || $cdEntriesDisk !== $cdEntries
+        ) {
+            throw new ZipException(
+                'ZIP file spanning/splitting is not supported!'
+            );
+        }
+        $comment = null;
+
+        if ($commentLength > 0) {
+            // .ZIP file comment       (variable sizeECD)
+            $comment = substr($buffer, 18, $commentLength);
+        }
+
+        // Check for ZIP64 End Of Central Directory Locator exists.
+        $zip64ECDLocatorPosition = $positionECD - ZipConstants::ZIP64_END_CD_LOC_LEN;
+        fseek($this->inStream, $zip64ECDLocatorPosition);
+        // zip64 end of central dir locator
+        // signature                       4 bytes  (0x07064b50)
+        if (
+            $zip64ECDLocatorPosition > 0
+            && unpack('V', fread($this->inStream, 4))[1] === ZipConstants::ZIP64_END_CD_LOC
+        ) {
+            if (!$this->isZip64Support()) {
+                throw new ZipException('ZIP64 not supported this archive.');
+            }
+
+            $positionECD = $this->findZip64ECDPosition();
+            $endCentralDirectory = $this->readZip64EndOfCentralDirectory($positionECD);
+            $endCentralDirectory->setComment($comment);
+        } else {
+            $endCentralDirectory = new EndOfCentralDirectory(
+                $cdEntries,
+                $cdPos,
+                $cdSize,
+                false,
+                $comment
+            );
+        }
+
+        return $endCentralDirectory;
+    }
+
+    protected function findEndOfCentralDirectory(): bool
+    {
+        $max = $this->size - ZipConstants::END_CD_MIN_LEN;
+        $min = $max >= 0xFFFF ? $max - 0xFFFF : 0;
+        // Search for End of central directory record.
+        for ($position = $max; $position >= $min; $position--) {
+            fseek($this->inStream, $position);
+            // end of central dir signature    4 bytes  (0x06054b50)
+            if (unpack('V', fread($this->inStream, 4))[1] !== ZipConstants::END_CD) {
+                continue;
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Read Zip64 end of central directory locator and returns
+     * Zip64 end of central directory position.
+     *
+     * number of the disk with the
+     * start of the zip64 end of
+     * central directory               4 bytes
+     * relative offset of the zip64
+     * end of central directory record 8 bytes
+     * total number of disks           4 bytes
+     *
+     * @throws ZipException
+     *
+     * @return int Zip64 End Of Central Directory position
+     */
+    protected function findZip64ECDPosition(): int
+    {
+        [
+            'diskNo' => $diskNo,
+            'zip64ECDPos' => $zip64ECDPos,
+            'totalDisks' => $totalDisks,
+        ] = unpack('VdiskNo/Pzip64ECDPos/VtotalDisks', fread($this->inStream, 16));
+
+        if ($diskNo !== 0 || $totalDisks > 1) {
+            throw new ZipException('ZIP file spanning/splitting is not supported!');
+        }
+
+        return $zip64ECDPos;
+    }
+
+    /**
+     * Read zip64 end of central directory locator and zip64 end
+     * of central directory record.
+     *
+     * zip64 end of central dir
+     * signature                       4 bytes  (0x06064b50)
+     * size of zip64 end of central
+     * directory record                8 bytes
+     * version made by                 2 bytes
+     * version needed to extract       2 bytes
+     * number of this disk             4 bytes
+     * number of the disk with the
+     * start of the central directory  4 bytes
+     * total number of entries in the
+     * central directory on this disk  8 bytes
+     * total number of entries in the
+     * central directory               8 bytes
+     * size of the central directory   8 bytes
+     * offset of start of central
+     * directory with respect to
+     * the starting disk number        8 bytes
+     * zip64 extensible data sector    (variable size)
+     *
+     * @throws ZipException
+     */
+    protected function readZip64EndOfCentralDirectory(int $zip64ECDPosition): EndOfCentralDirectory
+    {
+        fseek($this->inStream, $zip64ECDPosition);
+
+        $buffer = fread($this->inStream, ZipConstants::ZIP64_END_OF_CD_LEN);
+
+        if (unpack('V', $buffer)[1] !== ZipConstants::ZIP64_END_CD) {
+            throw new ZipException('Expected ZIP64 End Of Central Directory Record!');
+        }
+
+        [
+//            'size' => $size,
+//            'versionMadeBy' => $versionMadeBy,
+//            'extractVersion' => $extractVersion,
+            'diskNo' => $diskNo,
+            'cdDiskNo' => $cdDiskNo,
+            'cdEntriesDisk' => $cdEntriesDisk,
+            'entryCount' => $entryCount,
+            'cdSize' => $cdSize,
+            'cdPos' => $cdPos,
+        ] = unpack(
+//            'Psize/vversionMadeBy/vextractVersion/'.
+            'VdiskNo/VcdDiskNo/PcdEntriesDisk/PentryCount/PcdSize/PcdPos',
+            substr($buffer, 16, 40)
+        );
+
+//        $platform = ZipPlatform::fromValue(($versionMadeBy & 0xFF00) >> 8);
+//        $softwareVersion = $versionMadeBy & 0x00FF;
+
+        if ($diskNo !== 0 || $cdDiskNo !== 0 || $entryCount !== $cdEntriesDisk) {
+            throw new ZipException('ZIP file spanning/splitting is not supported!');
+        }
+
+        if ($entryCount < 0 || $entryCount > 0x7FFFFFFF) {
+            throw new ZipException('Total Number Of Entries In The Central Directory out of range!');
+        }
+
+        // skip zip64 extensible data sector (variable sizeEndCD)
+
+        return new EndOfCentralDirectory(
+            $entryCount,
+            $cdPos,
+            $cdSize,
+            true
+        );
+    }
+
+    /**
+     * Reads the central directory from the given seekable byte channel
+     * and populates the internal tables with ZipEntry instances.
+     *
+     * The ZipEntry's will know all data that can be obtained from the
+     * central directory alone, but not the data that requires the local
+     * file header or additional data to be read.
+     *
+     * @throws ZipException
+     *
+     * @return ZipEntry[]
+     */
+    protected function readCentralDirectory(EndOfCentralDirectory $endCD): array
+    {
+        $entries = [];
+
+        $cdOffset = $endCD->getCdOffset();
+        fseek($this->inStream, $cdOffset);
+
+        if (!($cdStream = fopen('php://temp', 'w+b'))) {
+            // @codeCoverageIgnoreStart
+            throw new ZipException('A temporary resource cannot be opened for writing.');
+            // @codeCoverageIgnoreEnd
+        }
+        stream_copy_to_stream($this->inStream, $cdStream, $endCD->getCdSize());
+        rewind($cdStream);
+        for ($numEntries = $endCD->getEntryCount(); $numEntries > 0; $numEntries--) {
+            $zipEntry = $this->readZipEntry($cdStream);
+
+            $entryName = $zipEntry->getName();
+
+            /** @var UnicodePathExtraField|null $unicodePathExtraField */
+            $unicodePathExtraField = $zipEntry->getExtraField(UnicodePathExtraField::HEADER_ID);
+
+            if ($unicodePathExtraField !== null && $unicodePathExtraField->getCrc32() === crc32($entryName)) {
+                $unicodePath = $unicodePathExtraField->getUnicodeValue();
+
+                if ($unicodePath !== '') {
+                    $unicodePath = str_replace('\\', '/', $unicodePath);
+
+                    if (substr_count($entryName, '/') === substr_count($unicodePath, '/')) {
+                        $entryName = $unicodePath;
+                    }
+                }
+            }
+
+            $entries[$entryName] = $zipEntry;
+        }
+
+        return $entries;
+    }
+
+    /**
+     * Read central directory entry.
+     *
+     * central file header signature   4 bytes  (0x02014b50)
+     * version made by                 2 bytes
+     * version needed to extract       2 bytes
+     * general purpose bit flag        2 bytes
+     * compression method              2 bytes
+     * last mod file time              2 bytes
+     * last mod file date              2 bytes
+     * crc-32                          4 bytes
+     * compressed size                 4 bytes
+     * uncompressed size               4 bytes
+     * file name length                2 bytes
+     * extra field length              2 bytes
+     * file comment length             2 bytes
+     * disk number start               2 bytes
+     * internal file attributes        2 bytes
+     * external file attributes        4 bytes
+     * relative offset of local header 4 bytes
+     *
+     * file name (variable size)
+     * extra field (variable size)
+     * file comment (variable size)
+     *
+     * @param resource $stream
+     *
+     * @throws ZipException
+     */
+    protected function readZipEntry($stream): ZipEntry
+    {
+        if (unpack('V', fread($stream, 4))[1] !== ZipConstants::CENTRAL_FILE_HEADER) {
+            throw new ZipException('Corrupt zip file. Cannot read zip entry.');
+        }
+
+        [
+            'versionMadeBy' => $versionMadeBy,
+            'versionNeededToExtract' => $versionNeededToExtract,
+            'generalPurposeBitFlags' => $generalPurposeBitFlags,
+            'compressionMethod' => $compressionMethod,
+            'lastModFile' => $dosTime,
+            'crc' => $crc,
+            'compressedSize' => $compressedSize,
+            'uncompressedSize' => $uncompressedSize,
+            'fileNameLength' => $fileNameLength,
+            'extraFieldLength' => $extraFieldLength,
+            'fileCommentLength' => $fileCommentLength,
+            'diskNumberStart' => $diskNumberStart,
+            'internalFileAttributes' => $internalFileAttributes,
+            'externalFileAttributes' => $externalFileAttributes,
+            'offsetLocalHeader' => $offsetLocalHeader,
+        ] = unpack(
+            'vversionMadeBy/vversionNeededToExtract/'
+            . 'vgeneralPurposeBitFlags/vcompressionMethod/'
+            . 'VlastModFile/Vcrc/VcompressedSize/'
+            . 'VuncompressedSize/vfileNameLength/vextraFieldLength/'
+            . 'vfileCommentLength/vdiskNumberStart/vinternalFileAttributes/'
+            . 'VexternalFileAttributes/VoffsetLocalHeader',
+            fread($stream, 42)
+        );
+
+        if ($diskNumberStart !== 0) {
+            throw new ZipException('ZIP file spanning/splitting is not supported!');
+        }
+
+        $isUtf8 = ($generalPurposeBitFlags & GeneralPurposeBitFlag::UTF8) !== 0;
+
+        $name = fread($stream, $fileNameLength);
+
+        $createdOS = ($versionMadeBy & 0xFF00) >> 8;
+        $softwareVersion = $versionMadeBy & 0x00FF;
+
+        $extractedOS = ($versionNeededToExtract & 0xFF00) >> 8;
+        $extractVersion = $versionNeededToExtract & 0x00FF;
+        $comment = null;
+
+        if ($fileCommentLength > 0) {
+            $comment = fread($stream, $fileCommentLength);
+        }
+
+        // decode code page names
+        $fallbackCharset = null;
+
+        if (!$isUtf8 && isset($this->options[ZipOptions::CHARSET])) {
+            $charset = $this->options[ZipOptions::CHARSET];
+
+            $fallbackCharset = $charset;
+            $name = DosCodePage::toUTF8($name, $charset);
+
+            if ($comment !== null) {
+                $comment = DosCodePage::toUTF8($comment, $charset);
+            }
+        }
+
+        $zipEntry = ZipEntry::create(
+            $name,
+            $createdOS,
+            $extractedOS,
+            $softwareVersion,
+            $extractVersion,
+            $compressionMethod,
+            $generalPurposeBitFlags,
+            $dosTime,
+            $crc,
+            $compressedSize,
+            $uncompressedSize,
+            $internalFileAttributes,
+            $externalFileAttributes,
+            $offsetLocalHeader,
+            $comment,
+            $fallbackCharset
+        );
+
+        if ($extraFieldLength > 0) {
+            $this->parseExtraFields(
+                fread($stream, $extraFieldLength),
+                $zipEntry
+            );
+
+            /** @var Zip64ExtraField|null $extraZip64 */
+            $extraZip64 = $zipEntry->getCdExtraField(Zip64ExtraField::HEADER_ID);
+
+            if ($extraZip64 !== null) {
+                $this->handleZip64Extra($extraZip64, $zipEntry);
+            }
+        }
+
+        $this->loadLocalExtraFields($zipEntry);
+        $this->handleExtraEncryptionFields($zipEntry);
+        $this->handleExtraFields($zipEntry);
+
+        return $zipEntry;
+    }
+
+    protected function parseExtraFields(string $buffer, ZipEntry $zipEntry, bool $local = false): ExtraFieldsCollection
+    {
+        $collection = $local
+            ? $zipEntry->getLocalExtraFields()
+            : $zipEntry->getCdExtraFields();
+
+        if (!empty($buffer)) {
+            $pos = 0;
+            $endPos = \strlen($buffer);
+
+            while ($endPos - $pos >= 4) {
+                [
+                    'headerId' => $headerId,
+                    'dataSize' => $dataSize,
+                ] = unpack('vheaderId/vdataSize', substr($buffer, $pos, 4));
+                $pos += 4;
+
+                if ($endPos - $pos - $dataSize < 0) {
+                    break;
+                }
+                $bufferData = substr($buffer, $pos, $dataSize);
+
+                /** @var string|ZipExtraField|null $className */
+                $className = ZipExtraDriver::getClassNameOrNull($headerId);
+
+                try {
+                    if ($className !== null) {
+                        try {
+                            $extraField = $local
+                                ? $className::unpackLocalFileData($bufferData, $zipEntry)
+                                : $className::unpackCentralDirData($bufferData, $zipEntry);
+                        } catch (\Throwable $e) {
+                            // skip errors while parsing invalid data
+                            continue;
+                        }
+                    } else {
+                        $extraField = new UnrecognizedExtraField($headerId, $bufferData);
+                    }
+                    $collection->add($extraField);
+                } finally {
+                    $pos += $dataSize;
+                }
+            }
+        }
+
+        return $collection;
+    }
+
+    protected function handleZip64Extra(Zip64ExtraField $extraZip64, ZipEntry $zipEntry): void
+    {
+        $uncompressedSize = $extraZip64->getUncompressedSize();
+        $compressedSize = $extraZip64->getCompressedSize();
+        $localHeaderOffset = $extraZip64->getLocalHeaderOffset();
+
+        if ($uncompressedSize !== null) {
+            $zipEntry->setUncompressedSize($uncompressedSize);
+        }
+
+        if ($compressedSize !== null) {
+            $zipEntry->setCompressedSize($compressedSize);
+        }
+
+        if ($localHeaderOffset !== null) {
+            $zipEntry->setLocalHeaderOffset($localHeaderOffset);
+        }
+    }
+
+    /**
+     * Read Local File Header.
+     *
+     * local file header signature     4 bytes  (0x04034b50)
+     * version needed to extract       2 bytes
+     * general purpose bit flag        2 bytes
+     * compression method              2 bytes
+     * last mod file time              2 bytes
+     * last mod file date              2 bytes
+     * crc-32                          4 bytes
+     * compressed size                 4 bytes
+     * uncompressed size               4 bytes
+     * file name length                2 bytes
+     * extra field length              2 bytes
+     * file name (variable size)
+     * extra field (variable size)
+     *
+     * @throws ZipException
+     */
+    protected function loadLocalExtraFields(ZipEntry $entry): void
+    {
+        $offsetLocalHeader = $entry->getLocalHeaderOffset();
+
+        fseek($this->inStream, $offsetLocalHeader);
+
+        if (unpack('V', fread($this->inStream, 4))[1] !== ZipConstants::LOCAL_FILE_HEADER) {
+            throw new ZipException(sprintf('%s (expected Local File Header)', $entry->getName()));
+        }
+
+        fseek($this->inStream, $offsetLocalHeader + ZipConstants::LFH_FILENAME_LENGTH_POS);
+        [
+            'fileNameLength' => $fileNameLength,
+            'extraFieldLength' => $extraFieldLength,
+        ] = unpack('vfileNameLength/vextraFieldLength', fread($this->inStream, 4));
+        $offsetData = ftell($this->inStream) + $fileNameLength + $extraFieldLength;
+        fseek($this->inStream, $fileNameLength, \SEEK_CUR);
+
+        if ($extraFieldLength > 0) {
+            $this->parseExtraFields(
+                fread($this->inStream, $extraFieldLength),
+                $entry,
+                true
+            );
+        }
+
+        $zipData = new ZipSourceFileData($this, $entry, $offsetData);
+        $entry->setData($zipData);
+    }
+
+    /**
+     * @throws ZipException
+     */
+    private function handleExtraEncryptionFields(ZipEntry $zipEntry): void
+    {
+        if ($zipEntry->isEncrypted()) {
+            if ($zipEntry->getCompressionMethod() === ZipCompressionMethod::WINZIP_AES) {
+                /** @var WinZipAesExtraField|null $extraField */
+                $extraField = $zipEntry->getExtraField(WinZipAesExtraField::HEADER_ID);
+
+                if ($extraField === null) {
+                    throw new ZipException(
+                        sprintf(
+                            'Extra field 0x%04x (WinZip-AES Encryption) expected for compression method %d',
+                            WinZipAesExtraField::HEADER_ID,
+                            $zipEntry->getCompressionMethod()
+                        )
+                    );
+                }
+                $zipEntry->setCompressionMethod($extraField->getCompressionMethod());
+                $zipEntry->setEncryptionMethod($extraField->getEncryptionMethod());
+            } else {
+                $zipEntry->setEncryptionMethod(ZipEncryptionMethod::PKWARE);
+            }
+        }
+    }
+
+    /**
+     * Handle extra data in zip records.
+     *
+     * This is a special method in which you can process ExtraField
+     * and make changes to ZipEntry.
+     */
+    protected function handleExtraFields(ZipEntry $zipEntry): void
+    {
+    }
+
+    /**
+     * @throws ZipException
+     * @throws Crc32Exception
+     *
+     * @return resource
+     */
+    public function getEntryStream(ZipSourceFileData $zipFileData)
+    {
+        $outStream = fopen('php://temp', 'w+b');
+        $this->copyUncompressedDataToStream($zipFileData, $outStream);
+        rewind($outStream);
+
+        return $outStream;
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws Crc32Exception
+     * @throws ZipException
+     */
+    public function copyUncompressedDataToStream(ZipSourceFileData $zipFileData, $outStream): void
+    {
+        if (!\is_resource($outStream)) {
+            throw new InvalidArgumentException('outStream is not resource');
+        }
+
+        $entry = $zipFileData->getSourceEntry();
+
+//        if ($entry->isDirectory()) {
+//            throw new InvalidArgumentException('Streams not supported for directories');
+//        }
+
+        if ($entry->isStrongEncryption()) {
+            throw new ZipException('Not support encryption zip.');
+        }
+
+        $compressionMethod = $entry->getCompressionMethod();
+
+        fseek($this->inStream, $zipFileData->getOffset());
+
+        $filters = [];
+
+        $skipCheckCrc = false;
+        $isEncrypted = $entry->isEncrypted();
+
+        if ($isEncrypted) {
+            if ($entry->getPassword() === null) {
+                throw new ZipException('Can not password from entry ' . $entry->getName());
+            }
+
+            if (ZipEncryptionMethod::isWinZipAesMethod($entry->getEncryptionMethod())) {
+                /** @var WinZipAesExtraField|null $winZipAesExtra */
+                $winZipAesExtra = $entry->getExtraField(WinZipAesExtraField::HEADER_ID);
+
+                if ($winZipAesExtra === null) {
+                    throw new ZipException(
+                        sprintf('WinZip AES must contain the extra field %s', WinZipAesExtraField::HEADER_ID)
+                    );
+                }
+                $compressionMethod = $winZipAesExtra->getCompressionMethod();
+
+                WinZipAesDecryptionStreamFilter::register();
+                $cipherFilterName = WinZipAesDecryptionStreamFilter::FILTER_NAME;
+
+                if ($winZipAesExtra->isV2()) {
+                    $skipCheckCrc = true;
+                }
+            } else {
+                PKDecryptionStreamFilter::register();
+                $cipherFilterName = PKDecryptionStreamFilter::FILTER_NAME;
+            }
+            $encContextFilter = stream_filter_append(
+                $this->inStream,
+                $cipherFilterName,
+                \STREAM_FILTER_READ,
+                [
+                    'entry' => $entry,
+                ]
+            );
+
+            if (!$encContextFilter) {
+                throw new \RuntimeException('Not apply filter ' . $cipherFilterName);
+            }
+            $filters[] = $encContextFilter;
+        }
+
+        // hack, see https://groups.google.com/forum/#!topic/alt.comp.lang.php/37_JZeW63uc
+        $pos = ftell($this->inStream);
+        rewind($this->inStream);
+        fseek($this->inStream, $pos);
+
+        $contextDecompress = null;
+        switch ($compressionMethod) {
+            case ZipCompressionMethod::STORED:
+                // file without compression, do nothing
+                break;
+
+            case ZipCompressionMethod::DEFLATED:
+                if (!($contextDecompress = stream_filter_append(
+                    $this->inStream,
+                    'zlib.inflate',
+                    \STREAM_FILTER_READ
+                ))) {
+                    throw new \RuntimeException('Could not append filter "zlib.inflate" to stream');
+                }
+                $filters[] = $contextDecompress;
+
+                break;
+
+            case ZipCompressionMethod::BZIP2:
+                if (!($contextDecompress = stream_filter_append(
+                    $this->inStream,
+                    'bzip2.decompress',
+                    \STREAM_FILTER_READ
+                ))) {
+                    throw new \RuntimeException('Could not append filter "bzip2.decompress" to stream');
+                }
+                $filters[] = $contextDecompress;
+
+                break;
+
+            default:
+                throw new ZipException(
+                    sprintf(
+                        '%s (compression method %d (%s) is not supported)',
+                        $entry->getName(),
+                        $compressionMethod,
+                        ZipCompressionMethod::getCompressionMethodName($compressionMethod)
+                    )
+                );
+        }
+
+        $limit = $zipFileData->getUncompressedSize();
+
+        $offset = 0;
+        $chunkSize = 8192;
+
+        try {
+            if ($skipCheckCrc) {
+                while ($offset < $limit) {
+                    $length = min($chunkSize, $limit - $offset);
+                    $buffer = fread($this->inStream, $length);
+
+                    if ($buffer === false) {
+                        throw new ZipException(sprintf('Error reading the contents of entry "%s".', $entry->getName()));
+                    }
+                    fwrite($outStream, $buffer);
+                    $offset += $length;
+                }
+            } else {
+                $contextHash = hash_init('crc32b');
+
+                while ($offset < $limit) {
+                    $length = min($chunkSize, $limit - $offset);
+                    $buffer = fread($this->inStream, $length);
+
+                    if ($buffer === false) {
+                        throw new ZipException(sprintf('Error reading the contents of entry "%s".', $entry->getName()));
+                    }
+                    fwrite($outStream, $buffer);
+                    hash_update($contextHash, $buffer);
+                    $offset += $length;
+                }
+
+                $expectedCrc = (int) hexdec(hash_final($contextHash));
+
+                if ($expectedCrc !== $entry->getCrc()) {
+                    throw new Crc32Exception($entry->getName(), $expectedCrc, $entry->getCrc());
+                }
+            }
+        } finally {
+            for ($i = \count($filters); $i > 0; $i--) {
+                stream_filter_remove($filters[$i - 1]);
+            }
+        }
+    }
+
+    /**
+     * @param resource $outStream
+     */
+    public function copyCompressedDataToStream(ZipSourceFileData $zipData, $outStream): void
+    {
+        if ($zipData->getCompressedSize() > 0) {
+            fseek($this->inStream, $zipData->getOffset());
+            stream_copy_to_stream($this->inStream, $outStream, $zipData->getCompressedSize());
+        }
+    }
+
+    protected function isZip64Support(): bool
+    {
+        return \PHP_INT_SIZE === 8; // true for 64bit system
+    }
+
+    /**
+     * @psalm-suppress InvalidPropertyAssignmentValue
+     */
+    public function close(): void
+    {
+        if (\is_resource($this->inStream)) {
+            fclose($this->inStream);
+        }
+    }
+
+    public function __destruct()
+    {
+        $this->close();
+    }
+}
--- a/src/IO/ZipWriter.php
+++ b/src/IO/ZipWriter.php
@@ -0,0 +1,791 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\IO;
+
+use PhpZip\Constants\DosCodePage;
+use PhpZip\Constants\ZipCompressionMethod;
+use PhpZip\Constants\ZipConstants;
+use PhpZip\Constants\ZipEncryptionMethod;
+use PhpZip\Constants\ZipPlatform;
+use PhpZip\Constants\ZipVersion;
+use PhpZip\Exception\ZipException;
+use PhpZip\Exception\ZipUnsupportMethodException;
+use PhpZip\IO\Filter\Cipher\Pkware\PKEncryptionStreamFilter;
+use PhpZip\IO\Filter\Cipher\WinZipAes\WinZipAesEncryptionStreamFilter;
+use PhpZip\Model\Data\ZipSourceFileData;
+use PhpZip\Model\Extra\Fields\WinZipAesExtraField;
+use PhpZip\Model\Extra\Fields\Zip64ExtraField;
+use PhpZip\Model\ZipContainer;
+use PhpZip\Model\ZipEntry;
+
+class ZipWriter
+{
+    /** @var int Chunk read size */
+    public const CHUNK_SIZE = 8192;
+
+    protected ZipContainer $zipContainer;
+
+    public function __construct(ZipContainer $container)
+    {
+        // we clone the container so that the changes made to
+        // it do not affect the data in the ZipFile class
+        $this->zipContainer = clone $container;
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    public function write($outStream): void
+    {
+        if (!\is_resource($outStream)) {
+            throw new \InvalidArgumentException('$outStream must be resource');
+        }
+        $this->beforeWrite();
+        $this->writeLocalBlock($outStream);
+        $cdOffset = ftell($outStream);
+        $this->writeCentralDirectoryBlock($outStream);
+        $cdSize = ftell($outStream) - $cdOffset;
+        $this->writeEndOfCentralDirectoryBlock($outStream, $cdOffset, $cdSize);
+    }
+
+    protected function beforeWrite(): void
+    {
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    protected function writeLocalBlock($outStream): void
+    {
+        $zipEntries = $this->zipContainer->getEntries();
+
+        foreach ($zipEntries as $zipEntry) {
+            $this->writeLocalHeader($outStream, $zipEntry);
+            $this->writeData($outStream, $zipEntry);
+
+            if ($zipEntry->isDataDescriptorEnabled()) {
+                $this->writeDataDescriptor($outStream, $zipEntry);
+            }
+        }
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    protected function writeLocalHeader($outStream, ZipEntry $entry): void
+    {
+        $relativeOffset = ftell($outStream);
+        $entry->setLocalHeaderOffset($relativeOffset);
+
+        if ($entry->isEncrypted() && $entry->getEncryptionMethod() === ZipEncryptionMethod::PKWARE) {
+            $entry->enableDataDescriptor(true);
+        }
+
+        $dd = $entry->isDataDescriptorRequired()
+            || $entry->isDataDescriptorEnabled();
+
+        $compressedSize = $entry->getCompressedSize();
+        $uncompressedSize = $entry->getUncompressedSize();
+
+        $entry->getLocalExtraFields()->remove(Zip64ExtraField::HEADER_ID);
+
+        if ($compressedSize > ZipConstants::ZIP64_MAGIC || $uncompressedSize > ZipConstants::ZIP64_MAGIC) {
+            $entry->getLocalExtraFields()->add(
+                new Zip64ExtraField($uncompressedSize, $compressedSize)
+            );
+
+            $compressedSize = ZipConstants::ZIP64_MAGIC;
+            $uncompressedSize = ZipConstants::ZIP64_MAGIC;
+        }
+
+        $compressionMethod = $entry->getCompressionMethod();
+        $crc = $entry->getCrc();
+
+        if ($entry->isEncrypted() && ZipEncryptionMethod::isWinZipAesMethod($entry->getEncryptionMethod())) {
+            /** @var WinZipAesExtraField|null $winZipAesExtra */
+            $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);
+
+            if ($winZipAesExtra === null) {
+                $winZipAesExtra = WinZipAesExtraField::create($entry);
+            }
+
+            if ($winZipAesExtra->isV2()) {
+                $crc = 0;
+            }
+            $compressionMethod = ZipCompressionMethod::WINZIP_AES;
+        }
+
+        $extra = $this->getExtraFieldsContents($entry, true);
+        $name = $entry->getName();
+        $dosCharset = $entry->getCharset();
+
+        if ($dosCharset !== null && !$entry->isUtf8Flag()) {
+            $name = DosCodePage::fromUTF8($name, $dosCharset);
+        }
+
+        $nameLength = \strlen($name);
+        $extraLength = \strlen($extra);
+
+        $size = $nameLength + $extraLength;
+
+        if ($size > 0xFFFF) {
+            throw new ZipException(
+                sprintf(
+                    '%s (the total size of %s bytes for the name, extra fields and comment exceeds the maximum size of %d bytes)',
+                    $entry->getName(),
+                    $size,
+                    0xFFFF
+                )
+            );
+        }
+
+        $extractedBy = ($entry->getExtractedOS() << 8) | $entry->getExtractVersion();
+
+        fwrite(
+            $outStream,
+            pack(
+                'VvvvVVVVvv',
+                // local file header signature     4 bytes  (0x04034b50)
+                ZipConstants::LOCAL_FILE_HEADER,
+                // version needed to extract       2 bytes
+                $extractedBy,
+                // general purpose bit flag        2 bytes
+                $entry->getGeneralPurposeBitFlags(),
+                // compression method              2 bytes
+                $compressionMethod,
+                // last mod file time              2 bytes
+                // last mod file date              2 bytes
+                $entry->getDosTime(),
+                // crc-32                          4 bytes
+                $dd ? 0 : $crc,
+                // compressed size                 4 bytes
+                $dd ? 0 : $compressedSize,
+                // uncompressed size               4 bytes
+                $dd ? 0 : $uncompressedSize,
+                // file name length                2 bytes
+                $nameLength,
+                // extra field length              2 bytes
+                $extraLength
+            )
+        );
+
+        if ($nameLength > 0) {
+            fwrite($outStream, $name);
+        }
+
+        if ($extraLength > 0) {
+            fwrite($outStream, $extra);
+        }
+    }
+
+    /**
+     * Merges the local file data fields of the given ZipExtraFields.
+     *
+     * @throws ZipException
+     */
+    protected function getExtraFieldsContents(ZipEntry $entry, bool $local): string
+    {
+        $collection = $local
+            ? $entry->getLocalExtraFields()
+            : $entry->getCdExtraFields();
+        $extraData = '';
+
+        foreach ($collection as $extraField) {
+            if ($local) {
+                $data = $extraField->packLocalFileData();
+            } else {
+                $data = $extraField->packCentralDirData();
+            }
+            $extraData .= pack(
+                'vv',
+                $extraField->getHeaderId(),
+                \strlen($data)
+            );
+            $extraData .= $data;
+        }
+
+        $size = \strlen($extraData);
+
+        if ($size > 0xFFFF) {
+            throw new ZipException(
+                sprintf(
+                    'Size extra out of range: %d. Extra data: %s',
+                    $size,
+                    $extraData
+                )
+            );
+        }
+
+        return $extraData;
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    protected function writeData($outStream, ZipEntry $entry): void
+    {
+        $zipData = $entry->getData();
+
+        if ($zipData === null) {
+            if ($entry->isDirectory()) {
+                return;
+            }
+
+            throw new ZipException(sprintf('No zip data for entry "%s"', $entry->getName()));
+        }
+
+        // data write variants:
+        // --------------------
+        // * data of source zip file -> copy compressed data
+        // * store - simple write
+        // * store and encryption - apply encryption filter and simple write
+        // * deflate or bzip2 - apply compression filter and simple write
+        // * (deflate or bzip2) and encryption - create temp stream and apply
+        //     compression filter to it, then apply encryption filter to root
+        //     stream and write temp stream data.
+        //     (PHP cannot apply the filter for encryption after the compression
+        //     filter, so a temporary stream is created for the compressed data)
+
+        if ($zipData instanceof ZipSourceFileData && !$zipData->hasRecompressData($entry)) {
+            // data of source zip file -> copy compressed data
+            $zipData->copyCompressedDataToStream($outStream);
+
+            return;
+        }
+
+        $entryStream = $zipData->getDataAsStream();
+
+        if (stream_get_meta_data($entryStream)['seekable']) {
+            rewind($entryStream);
+        }
+
+        $uncompressedSize = $entry->getUncompressedSize();
+
+        $posBeforeWrite = ftell($outStream);
+        $compressionMethod = $entry->getCompressionMethod();
+
+        if ($entry->isEncrypted()) {
+            if ($compressionMethod === ZipCompressionMethod::STORED) {
+                $contextFilter = $this->appendEncryptionFilter($outStream, $entry, $uncompressedSize);
+                $checksum = $this->writeAndCountChecksum($entryStream, $outStream, $uncompressedSize);
+            } else {
+                $compressStream = fopen('php://temp', 'w+b');
+                $contextFilter = $this->appendCompressionFilter($compressStream, $entry);
+                $checksum = $this->writeAndCountChecksum($entryStream, $compressStream, $uncompressedSize);
+
+                if ($contextFilter !== null) {
+                    stream_filter_remove($contextFilter);
+                    $contextFilter = null;
+                }
+
+                rewind($compressStream);
+
+                $compressedSize = fstat($compressStream)['size'];
+                $contextFilter = $this->appendEncryptionFilter($outStream, $entry, $compressedSize);
+
+                stream_copy_to_stream($compressStream, $outStream);
+            }
+        } else {
+            $contextFilter = $this->appendCompressionFilter($outStream, $entry);
+            $checksum = $this->writeAndCountChecksum($entryStream, $outStream, $uncompressedSize);
+        }
+
+        if ($contextFilter !== null) {
+            stream_filter_remove($contextFilter);
+            $contextFilter = null;
+        }
+
+        // my hack {@see https://bugs.php.net/bug.php?id=49874}
+        fseek($outStream, 0, \SEEK_END);
+        $compressedSize = ftell($outStream) - $posBeforeWrite;
+
+        $entry->setCompressedSize($compressedSize);
+        $entry->setCrc($checksum);
+
+        if (!$entry->isDataDescriptorEnabled()) {
+            if ($uncompressedSize > ZipConstants::ZIP64_MAGIC || $compressedSize > ZipConstants::ZIP64_MAGIC) {
+                /** @var Zip64ExtraField|null $zip64ExtraLocal */
+                $zip64ExtraLocal = $entry->getLocalExtraField(Zip64ExtraField::HEADER_ID);
+
+                // if there is a zip64 extra record, then update it;
+                // if not, write data to data descriptor
+                if ($zip64ExtraLocal !== null) {
+                    $zip64ExtraLocal->setCompressedSize($compressedSize);
+                    $zip64ExtraLocal->setUncompressedSize($uncompressedSize);
+
+                    $posExtra = $entry->getLocalHeaderOffset() + ZipConstants::LFH_FILENAME_POS + \strlen($entry->getName());
+                    fseek($outStream, $posExtra);
+                    fwrite($outStream, $this->getExtraFieldsContents($entry, true));
+                } else {
+                    $posGPBF = $entry->getLocalHeaderOffset() + 6;
+                    $entry->enableDataDescriptor(true);
+                    fseek($outStream, $posGPBF);
+                    fwrite(
+                        $outStream,
+                        pack(
+                            'v',
+                            // general purpose bit flag        2 bytes
+                            $entry->getGeneralPurposeBitFlags()
+                        )
+                    );
+                }
+
+                $compressedSize = ZipConstants::ZIP64_MAGIC;
+                $uncompressedSize = ZipConstants::ZIP64_MAGIC;
+            }
+
+            $posChecksum = $entry->getLocalHeaderOffset() + 14;
+
+            /** @var WinZipAesExtraField|null $winZipAesExtra */
+            $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);
+
+            if ($winZipAesExtra !== null && $winZipAesExtra->isV2()) {
+                $checksum = 0;
+            }
+
+            fseek($outStream, $posChecksum);
+            fwrite(
+                $outStream,
+                pack(
+                    'VVV',
+                    // crc-32                          4 bytes
+                    $checksum,
+                    // compressed size                 4 bytes
+                    $compressedSize,
+                    // uncompressed size               4 bytes
+                    $uncompressedSize
+                )
+            );
+            fseek($outStream, 0, \SEEK_END);
+        }
+    }
+
+    /**
+     * @param resource $inStream
+     * @param resource $outStream
+     */
+    private function writeAndCountChecksum($inStream, $outStream, int $size): int
+    {
+        $contextHash = hash_init('crc32b');
+        $offset = 0;
+
+        while ($offset < $size) {
+            $read = min(self::CHUNK_SIZE, $size - $offset);
+            $buffer = fread($inStream, $read);
+            fwrite($outStream, $buffer);
+            hash_update($contextHash, $buffer);
+            $offset += $read;
+        }
+
+        return (int) hexdec(hash_final($contextHash));
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipUnsupportMethodException
+     *
+     * @return resource|null
+     */
+    protected function appendCompressionFilter($outStream, ZipEntry $entry)
+    {
+        $contextCompress = null;
+        switch ($entry->getCompressionMethod()) {
+            case ZipCompressionMethod::DEFLATED:
+                if (!($contextCompress = stream_filter_append(
+                    $outStream,
+                    'zlib.deflate',
+                    \STREAM_FILTER_WRITE,
+                    ['level' => $entry->getCompressionLevel()]
+                ))) {
+                    throw new \RuntimeException('Could not append filter "zlib.deflate" to out stream');
+                }
+                break;
+
+            case ZipCompressionMethod::BZIP2:
+                if (!($contextCompress = stream_filter_append(
+                    $outStream,
+                    'bzip2.compress',
+                    \STREAM_FILTER_WRITE,
+                    ['blocks' => $entry->getCompressionLevel(), 'work' => 0]
+                ))) {
+                    throw new \RuntimeException('Could not append filter "bzip2.compress" to out stream');
+                }
+                break;
+
+            case ZipCompressionMethod::STORED:
+                // file without compression, do nothing
+                break;
+
+            default:
+                throw new ZipUnsupportMethodException(
+                    sprintf(
+                        '%s (compression method %d (%s) is not supported)',
+                        $entry->getName(),
+                        $entry->getCompressionMethod(),
+                        ZipCompressionMethod::getCompressionMethodName($entry->getCompressionMethod())
+                    )
+                );
+        }
+
+        return $contextCompress;
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @return resource|null
+     */
+    protected function appendEncryptionFilter($outStream, ZipEntry $entry, int $size)
+    {
+        $encContextFilter = null;
+
+        if ($entry->isEncrypted()) {
+            if ($entry->getEncryptionMethod() === ZipEncryptionMethod::PKWARE) {
+                PKEncryptionStreamFilter::register();
+                $cipherFilterName = PKEncryptionStreamFilter::FILTER_NAME;
+            } else {
+                WinZipAesEncryptionStreamFilter::register();
+                $cipherFilterName = WinZipAesEncryptionStreamFilter::FILTER_NAME;
+            }
+            $encContextFilter = stream_filter_append(
+                $outStream,
+                $cipherFilterName,
+                \STREAM_FILTER_WRITE,
+                [
+                    'entry' => $entry,
+                    'size' => $size,
+                ]
+            );
+
+            if (!$encContextFilter) {
+                throw new \RuntimeException('Not apply filter ' . $cipherFilterName);
+            }
+        }
+
+        return $encContextFilter;
+    }
+
+    /**
+     * @param resource $outStream
+     */
+    protected function writeDataDescriptor($outStream, ZipEntry $entry): void
+    {
+        $crc = $entry->getCrc();
+
+        /** @var WinZipAesExtraField|null $winZipAesExtra */
+        $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);
+
+        if ($winZipAesExtra !== null && $winZipAesExtra->isV2()) {
+            $crc = 0;
+        }
+
+        fwrite(
+            $outStream,
+            pack(
+                'VV',
+                // data descriptor signature       4 bytes  (0x08074b50)
+                ZipConstants::DATA_DESCRIPTOR,
+                // crc-32                          4 bytes
+                $crc
+            )
+        );
+
+        if (
+            $entry->isZip64ExtensionsRequired()
+            || $entry->getLocalExtraFields()->has(Zip64ExtraField::HEADER_ID)
+        ) {
+            $dd = pack(
+                'PP',
+                // compressed size                 8 bytes
+                $entry->getCompressedSize(),
+                // uncompressed size               8 bytes
+                $entry->getUncompressedSize()
+            );
+        } else {
+            $dd = pack(
+                'VV',
+                // compressed size                 4 bytes
+                $entry->getCompressedSize(),
+                // uncompressed size               4 bytes
+                $entry->getUncompressedSize()
+            );
+        }
+
+        fwrite($outStream, $dd);
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    protected function writeCentralDirectoryBlock($outStream): void
+    {
+        foreach ($this->zipContainer->getEntries() as $outputEntry) {
+            $this->writeCentralDirectoryHeader($outStream, $outputEntry);
+        }
+    }
+
+    /**
+     * Writes a Central File Header record.
+     *
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    protected function writeCentralDirectoryHeader($outStream, ZipEntry $entry): void
+    {
+        $compressedSize = $entry->getCompressedSize();
+        $uncompressedSize = $entry->getUncompressedSize();
+        $localHeaderOffset = $entry->getLocalHeaderOffset();
+
+        $entry->getCdExtraFields()->remove(Zip64ExtraField::HEADER_ID);
+
+        if (
+            $localHeaderOffset > ZipConstants::ZIP64_MAGIC
+            || $compressedSize > ZipConstants::ZIP64_MAGIC
+            || $uncompressedSize > ZipConstants::ZIP64_MAGIC
+        ) {
+            $zip64ExtraField = new Zip64ExtraField();
+
+            if ($uncompressedSize >= ZipConstants::ZIP64_MAGIC) {
+                $zip64ExtraField->setUncompressedSize($uncompressedSize);
+                $uncompressedSize = ZipConstants::ZIP64_MAGIC;
+            }
+
+            if ($compressedSize >= ZipConstants::ZIP64_MAGIC) {
+                $zip64ExtraField->setCompressedSize($compressedSize);
+                $compressedSize = ZipConstants::ZIP64_MAGIC;
+            }
+
+            if ($localHeaderOffset >= ZipConstants::ZIP64_MAGIC) {
+                $zip64ExtraField->setLocalHeaderOffset($localHeaderOffset);
+                $localHeaderOffset = ZipConstants::ZIP64_MAGIC;
+            }
+
+            $entry->getCdExtraFields()->add($zip64ExtraField);
+        }
+
+        $extra = $this->getExtraFieldsContents($entry, false);
+        $extraLength = \strlen($extra);
+
+        $name = $entry->getName();
+        $comment = $entry->getComment();
+
+        $dosCharset = $entry->getCharset();
+
+        if ($dosCharset !== null && !$entry->isUtf8Flag()) {
+            $name = DosCodePage::fromUTF8($name, $dosCharset);
+
+            if ($comment) {
+                $comment = DosCodePage::fromUTF8($comment, $dosCharset);
+            }
+        }
+
+        $commentLength = \strlen($comment);
+
+        $compressionMethod = $entry->getCompressionMethod();
+        $crc = $entry->getCrc();
+
+        /** @var WinZipAesExtraField|null $winZipAesExtra */
+        $winZipAesExtra = $entry->getLocalExtraField(WinZipAesExtraField::HEADER_ID);
+
+        if ($winZipAesExtra !== null) {
+            if ($winZipAesExtra->isV2()) {
+                $crc = 0;
+            }
+            $compressionMethod = ZipCompressionMethod::WINZIP_AES;
+        }
+
+        fwrite(
+            $outStream,
+            pack(
+                'VvvvvVVVVvvvvvVV',
+                // central file header signature   4 bytes  (0x02014b50)
+                ZipConstants::CENTRAL_FILE_HEADER,
+                // version made by                 2 bytes
+                ($entry->getCreatedOS() << 8) | $entry->getSoftwareVersion(),
+                // version needed to extract       2 bytes
+                ($entry->getExtractedOS() << 8) | $entry->getExtractVersion(),
+                // general purpose bit flag        2 bytes
+                $entry->getGeneralPurposeBitFlags(),
+                // compression method              2 bytes
+                $compressionMethod,
+                // last mod file datetime          4 bytes
+                $entry->getDosTime(),
+                // crc-32                          4 bytes
+                $crc,
+                // compressed size                 4 bytes
+                $compressedSize,
+                // uncompressed size               4 bytes
+                $uncompressedSize,
+                // file name length                2 bytes
+                \strlen($name),
+                // extra field length              2 bytes
+                $extraLength,
+                // file comment length             2 bytes
+                $commentLength,
+                // disk number start               2 bytes
+                0,
+                // internal file attributes        2 bytes
+                $entry->getInternalAttributes(),
+                // external file attributes        4 bytes
+                $entry->getExternalAttributes(),
+                // relative offset of local header 4 bytes
+                $localHeaderOffset
+            )
+        );
+
+        // file name (variable size)
+        fwrite($outStream, $name);
+
+        if ($extraLength > 0) {
+            // extra field (variable size)
+            fwrite($outStream, $extra);
+        }
+
+        if ($commentLength > 0) {
+            // file comment (variable size)
+            fwrite($outStream, $comment);
+        }
+    }
+
+    /**
+     * @param resource $outStream
+     */
+    protected function writeEndOfCentralDirectoryBlock(
+        $outStream,
+        int $centralDirectoryOffset,
+        int $centralDirectorySize
+    ): void {
+        $cdEntriesCount = \count($this->zipContainer);
+
+        $cdEntriesZip64 = $cdEntriesCount > 0xFFFF;
+        $cdSizeZip64 = $centralDirectorySize > ZipConstants::ZIP64_MAGIC;
+        $cdOffsetZip64 = $centralDirectoryOffset > ZipConstants::ZIP64_MAGIC;
+
+        $zip64Required = $cdEntriesZip64
+            || $cdSizeZip64
+            || $cdOffsetZip64;
+
+        if ($zip64Required) {
+            $zip64EndOfCentralDirectoryOffset = ftell($outStream);
+
+            // find max software version, version needed to extract and most common platform
+            [$softwareVersion, $versionNeededToExtract] = array_reduce(
+                $this->zipContainer->getEntries(),
+                static function (array $carry, ZipEntry $entry) {
+                    $carry[0] = max($carry[0], $entry->getSoftwareVersion() & 0xFF);
+                    $carry[1] = max($carry[1], $entry->getExtractVersion() & 0xFF);
+
+                    return $carry;
+                },
+                [ZipVersion::v10_DEFAULT_MIN, ZipVersion::v45_ZIP64_EXT]
+            );
+
+            $createdOS = $extractedOS = ZipPlatform::OS_DOS;
+            $versionMadeBy = ($createdOS << 8) | max($softwareVersion, ZipVersion::v45_ZIP64_EXT);
+            $versionExtractedBy = ($extractedOS << 8) | max($versionNeededToExtract, ZipVersion::v45_ZIP64_EXT);
+
+            // write zip64 end of central directory signature
+            fwrite(
+                $outStream,
+                pack(
+                    'VPvvVVPPPPVVPV',
+                    // signature                       4 bytes  (0x06064b50)
+                    ZipConstants::ZIP64_END_CD,
+                    // size of zip64 end of central
+                    // directory record                8 bytes
+                    ZipConstants::ZIP64_END_OF_CD_LEN - 12,
+                    // version made by                 2 bytes
+                    $versionMadeBy & 0xFFFF,
+                    // version needed to extract       2 bytes
+                    $versionExtractedBy & 0xFFFF,
+                    // number of this disk             4 bytes
+                    0,
+                    // number of the disk with the
+                    // start of the central directory  4 bytes
+                    0,
+                    // total number of entries in the
+                    // central directory on this disk  8 bytes
+                    $cdEntriesCount,
+                    // total number of entries in the
+                    // central directory               8 bytes
+                    $cdEntriesCount,
+                    // size of the central directory   8 bytes
+                    $centralDirectorySize,
+                    // offset of start of central
+                    // directory with respect to
+                    // the starting disk number        8 bytes
+                    $centralDirectoryOffset,
+                    // zip64 end of central dir locator
+                    // signature                       4 bytes  (0x07064b50)
+                    ZipConstants::ZIP64_END_CD_LOC,
+                    // number of the disk with the
+                    // start of the zip64 end of
+                    // central directory               4 bytes
+                    0,
+                    // relative offset of the zip64
+                    // end of central directory record 8 bytes
+                    $zip64EndOfCentralDirectoryOffset,
+                    // total number of disks           4 bytes
+                    1
+                )
+            );
+        }
+
+        $comment = $this->zipContainer->getArchiveComment();
+        $commentLength = $comment !== null ? \strlen($comment) : 0;
+
+        fwrite(
+            $outStream,
+            pack(
+                'VvvvvVVv',
+                // end of central dir signature    4 bytes  (0x06054b50)
+                ZipConstants::END_CD,
+                // number of this disk             2 bytes
+                0,
+                // number of the disk with the
+                // start of the central directory  2 bytes
+                0,
+                // total number of entries in the
+                // central directory on this disk  2 bytes
+                $cdEntriesZip64 ? 0xFFFF : $cdEntriesCount,
+                // total number of entries in
+                // the central directory           2 bytes
+                $cdEntriesZip64 ? 0xFFFF : $cdEntriesCount,
+                // size of the central directory   4 bytes
+                $cdSizeZip64 ? ZipConstants::ZIP64_MAGIC : $centralDirectorySize,
+                // offset of start of central
+                // directory with respect to
+                // the starting disk number        4 bytes
+                $cdOffsetZip64 ? ZipConstants::ZIP64_MAGIC : $centralDirectoryOffset,
+                // .ZIP file comment length        2 bytes
+                $commentLength
+            )
+        );
+
+        if ($comment !== null && $commentLength > 0) {
+            // .ZIP file comment       (variable size)
+            fwrite($outStream, $comment);
+        }
+    }
+}
--- a/src/Model/Data/ZipFileData.php
+++ b/src/Model/Data/ZipFileData.php
@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Data;
+
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\ZipData;
+use PhpZip\Model\ZipEntry;
+
+class ZipFileData implements ZipData
+{
+    private \SplFileInfo $file;
+
+    /**
+     * @throws ZipException
+     */
+    public function __construct(ZipEntry $zipEntry, \SplFileInfo $fileInfo)
+    {
+        if (!$fileInfo->isFile()) {
+            throw new ZipException('$fileInfo is not a file.');
+        }
+
+        if (!$fileInfo->isReadable()) {
+            throw new ZipException('$fileInfo is not readable.');
+        }
+
+        $this->file = $fileInfo;
+        $zipEntry->setUncompressedSize($fileInfo->getSize());
+    }
+
+    /**
+     * @throws ZipException
+     *
+     * @return resource returns stream data
+     */
+    public function getDataAsStream()
+    {
+        if (!$this->file->isReadable()) {
+            throw new ZipException(sprintf('The %s file is no longer readable.', $this->file->getPathname()));
+        }
+
+        return fopen($this->file->getPathname(), 'rb');
+    }
+
+    /**
+     * @throws ZipException
+     *
+     * @return string returns data as string
+     */
+    public function getDataAsString(): string
+    {
+        if (!$this->file->isReadable()) {
+            throw new ZipException(sprintf('The %s file is no longer readable.', $this->file->getPathname()));
+        }
+
+        return file_get_contents($this->file->getPathname());
+    }
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    public function copyDataToStream($outStream): void
+    {
+        $stream = $this->getDataAsStream();
+        stream_copy_to_stream($stream, $outStream);
+        fclose($stream);
+    }
+}
--- a/src/Model/Data/ZipNewData.php
+++ b/src/Model/Data/ZipNewData.php
@@ -0,0 +1,138 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Data;
+
+use PhpZip\Model\ZipData;
+use PhpZip\Model\ZipEntry;
+use PhpZip\ZipFile;
+
+/**
+ * The class contains a streaming resource with new content added to the ZIP archive.
+ */
+class ZipNewData implements ZipData
+{
+    /**
+     * A static variable allows closing the stream in the destructor
+     * only if it is its sole holder.
+     *
+     * @var array<int, int> array of resource ids and the number of class clones
+     */
+    private static array $guardClonedStream = [];
+
+    private ZipEntry $zipEntry;
+
+    /** @var resource */
+    private $stream;
+
+    /**
+     * @param string|resource $data Raw string data or resource
+     * @noinspection PhpMissingParamTypeInspection
+     */
+    public function __construct(ZipEntry $zipEntry, $data)
+    {
+        $this->zipEntry = $zipEntry;
+
+        if (\is_string($data)) {
+            $zipEntry->setUncompressedSize(\strlen($data));
+
+            if (!($handle = fopen('php://temp', 'w+b'))) {
+                // @codeCoverageIgnoreStart
+                throw new \RuntimeException('A temporary resource cannot be opened for writing.');
+                // @codeCoverageIgnoreEnd
+            }
+            fwrite($handle, $data);
+            rewind($handle);
+            $this->stream = $handle;
+        } elseif (\is_resource($data)) {
+            $this->stream = $data;
+        }
+
+        $resourceId = (int) $this->stream;
+        self::$guardClonedStream[$resourceId]
+            = isset(self::$guardClonedStream[$resourceId])
+                ? self::$guardClonedStream[$resourceId] + 1
+                : 0;
+    }
+
+    /**
+     * @return resource returns stream data
+     */
+    public function getDataAsStream()
+    {
+        if (!\is_resource($this->stream)) {
+            throw new \LogicException(sprintf('Resource has been closed (entry=%s).', $this->zipEntry->getName()));
+        }
+
+        return $this->stream;
+    }
+
+    /**
+     * @return string returns data as string
+     */
+    public function getDataAsString(): string
+    {
+        $stream = $this->getDataAsStream();
+        $pos = ftell($stream);
+
+        try {
+            rewind($stream);
+
+            return stream_get_contents($stream);
+        } finally {
+            fseek($stream, $pos);
+        }
+    }
+
+    /**
+     * @param resource $outStream
+     */
+    public function copyDataToStream($outStream): void
+    {
+        $stream = $this->getDataAsStream();
+        rewind($stream);
+        stream_copy_to_stream($stream, $outStream);
+    }
+
+    /**
+     * @see https://php.net/manual/en/language.oop5.cloning.php
+     */
+    public function __clone()
+    {
+        $resourceId = (int) $this->stream;
+        self::$guardClonedStream[$resourceId]
+            = isset(self::$guardClonedStream[$resourceId])
+                ? self::$guardClonedStream[$resourceId] + 1
+                : 1;
+    }
+
+    /**
+     * The stream will be closed when closing the zip archive.
+     *
+     * The method implements protection against closing the stream of the cloned object.
+     *
+     * @see ZipFile::close()
+     */
+    public function __destruct()
+    {
+        $resourceId = (int) $this->stream;
+
+        if (isset(self::$guardClonedStream[$resourceId]) && self::$guardClonedStream[$resourceId] > 0) {
+            self::$guardClonedStream[$resourceId]--;
+
+            return;
+        }
+
+        if (\is_resource($this->stream)) {
+            fclose($this->stream);
+        }
+    }
+}
--- a/src/Model/Data/ZipSourceFileData.php
+++ b/src/Model/Data/ZipSourceFileData.php
@@ -0,0 +1,146 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Data;
+
+use PhpZip\Exception\Crc32Exception;
+use PhpZip\Exception\ZipException;
+use PhpZip\IO\ZipReader;
+use PhpZip\Model\ZipData;
+use PhpZip\Model\ZipEntry;
+
+class ZipSourceFileData implements ZipData
+{
+    private ZipReader $zipReader;
+
+    /** @var resource|null */
+    private $stream;
+
+    private ZipEntry $sourceEntry;
+
+    private int $offset;
+
+    private int $uncompressedSize;
+
+    private int $compressedSize;
+
+    public function __construct(ZipReader $zipReader, ZipEntry $zipEntry, int $offsetData)
+    {
+        $this->zipReader = $zipReader;
+        $this->offset = $offsetData;
+        $this->sourceEntry = $zipEntry;
+        $this->compressedSize = $zipEntry->getCompressedSize();
+        $this->uncompressedSize = $zipEntry->getUncompressedSize();
+    }
+
+    public function hasRecompressData(ZipEntry $entry): bool
+    {
+        return $this->sourceEntry->getCompressionLevel() !== $entry->getCompressionLevel()
+            || $this->sourceEntry->getCompressionMethod() !== $entry->getCompressionMethod()
+            || $this->sourceEntry->isEncrypted() !== $entry->isEncrypted()
+            || $this->sourceEntry->getEncryptionMethod() !== $entry->getEncryptionMethod()
+            || $this->sourceEntry->getPassword() !== $entry->getPassword()
+            || $this->sourceEntry->getCompressedSize() !== $entry->getCompressedSize()
+            || $this->sourceEntry->getUncompressedSize() !== $entry->getUncompressedSize()
+            || $this->sourceEntry->getCrc() !== $entry->getCrc();
+    }
+
+    /**
+     * @throws ZipException
+     *
+     * @return resource returns stream data
+     */
+    public function getDataAsStream()
+    {
+        if (!\is_resource($this->stream)) {
+            $this->stream = $this->zipReader->getEntryStream($this);
+        }
+
+        return $this->stream;
+    }
+
+    /**
+     * @throws ZipException
+     *
+     * @return string returns data as string
+     */
+    public function getDataAsString(): string
+    {
+        $autoClosable = $this->stream === null;
+
+        $stream = $this->getDataAsStream();
+        $pos = ftell($stream);
+
+        try {
+            rewind($stream);
+
+            return stream_get_contents($stream);
+        } finally {
+            if ($autoClosable) {
+                fclose($stream);
+                $this->stream = null;
+            } else {
+                fseek($stream, $pos);
+            }
+        }
+    }
+
+    /**
+     * @param resource $outStream Output stream
+     *
+     * @throws ZipException
+     * @throws Crc32Exception
+     */
+    public function copyDataToStream($outStream): void
+    {
+        if (\is_resource($this->stream)) {
+            rewind($this->stream);
+            stream_copy_to_stream($this->stream, $outStream);
+        } else {
+            $this->zipReader->copyUncompressedDataToStream($this, $outStream);
+        }
+    }
+
+    /**
+     * @param resource $outputStream Output stream
+     */
+    public function copyCompressedDataToStream($outputStream): void
+    {
+        $this->zipReader->copyCompressedDataToStream($this, $outputStream);
+    }
+
+    public function getSourceEntry(): ZipEntry
+    {
+        return $this->sourceEntry;
+    }
+
+    public function getCompressedSize(): int
+    {
+        return $this->compressedSize;
+    }
+
+    public function getUncompressedSize(): int
+    {
+        return $this->uncompressedSize;
+    }
+
+    public function getOffset(): int
+    {
+        return $this->offset;
+    }
+
+    public function __destruct()
+    {
+        if (\is_resource($this->stream)) {
+            fclose($this->stream);
+        }
+    }
+}
--- a/src/Model/EndOfCentralDirectory.php
+++ b/src/Model/EndOfCentralDirectory.php
@@ -0,0 +1,71 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model;
+
+/**
+ * End of Central Directory.
+ */
+class EndOfCentralDirectory
+{
+    /** @var int Count files. */
+    private int $entryCount;
+
+    /** @var int Central Directory Offset. */
+    private int $cdOffset;
+
+    private int $cdSize;
+
+    /** @var string|null The archive comment. */
+    private ?string $comment;
+
+    /** @var bool Zip64 extension */
+    private bool $zip64;
+
+    public function __construct(int $entryCount, int $cdOffset, int $cdSize, bool $zip64, ?string $comment = null)
+    {
+        $this->entryCount = $entryCount;
+        $this->cdOffset = $cdOffset;
+        $this->cdSize = $cdSize;
+        $this->zip64 = $zip64;
+        $this->comment = $comment;
+    }
+
+    public function setComment(?string $comment): void
+    {
+        $this->comment = $comment;
+    }
+
+    public function getEntryCount(): int
+    {
+        return $this->entryCount;
+    }
+
+    public function getCdOffset(): int
+    {
+        return $this->cdOffset;
+    }
+
+    public function getCdSize(): int
+    {
+        return $this->cdSize;
+    }
+
+    public function getComment(): ?string
+    {
+        return $this->comment;
+    }
+
+    public function isZip64(): bool
+    {
+        return $this->zip64;
+    }
+}
--- a/src/Model/Extra/ExtraFieldsCollection.php
+++ b/src/Model/Extra/ExtraFieldsCollection.php
@@ -0,0 +1,271 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra;
+
+/**
+ * Represents a collection of Extra Fields as they may
+ * be present at several locations in ZIP files.
+ */
+class ExtraFieldsCollection implements \ArrayAccess, \Countable, \Iterator
+{
+    /**
+     * The map of Extra Fields.
+     * Maps from Header ID to Extra Field.
+     * Must not be null, but may be empty if no Extra Fields are used.
+     * The map is sorted by Header IDs in ascending order.
+     *
+     * @var ZipExtraField[]
+     */
+    protected array $collection = [];
+
+    /**
+     * Returns the number of Extra Fields in this collection.
+     */
+    public function count(): int
+    {
+        return \count($this->collection);
+    }
+
+    /**
+     * Returns the Extra Field with the given Header ID or null
+     * if no such Extra Field exists.
+     *
+     * @param int $headerId the requested Header ID
+     *
+     * @return ZipExtraField|null the Extra Field with the given Header ID or
+     *                            if no such Extra Field exists
+     */
+    public function get(int $headerId): ?ZipExtraField
+    {
+        $this->validateHeaderId($headerId);
+
+        return $this->collection[$headerId] ?? null;
+    }
+
+    private function validateHeaderId(int $headerId): void
+    {
+        if ($headerId < 0 || $headerId > 0xFFFF) {
+            throw new \InvalidArgumentException('$headerId out of range');
+        }
+    }
+
+    /**
+     * Stores the given Extra Field in this collection.
+     *
+     * @param ZipExtraField $extraField the Extra Field to store in this collection
+     *
+     * @return ZipExtraField the Extra Field previously associated with the Header ID of
+     *                       of the given Extra Field or null if no such Extra Field existed
+     */
+    public function add(ZipExtraField $extraField): ZipExtraField
+    {
+        $headerId = $extraField->getHeaderId();
+
+        $this->validateHeaderId($headerId);
+        $this->collection[$headerId] = $extraField;
+
+        return $extraField;
+    }
+
+    /**
+     * @param ZipExtraField[] $extraFields
+     */
+    public function addAll(array $extraFields): void
+    {
+        foreach ($extraFields as $extraField) {
+            $this->add($extraField);
+        }
+    }
+
+    /**
+     * @param ExtraFieldsCollection $collection
+     */
+    public function addCollection(self $collection): void
+    {
+        $this->addAll($collection->collection);
+    }
+
+    /**
+     * @return ZipExtraField[]
+     */
+    public function getAll(): array
+    {
+        return $this->collection;
+    }
+
+    /**
+     * Returns Extra Field exists.
+     *
+     * @param int $headerId the requested Header ID
+     */
+    public function has(int $headerId): bool
+    {
+        return isset($this->collection[$headerId]);
+    }
+
+    /**
+     * Removes the Extra Field with the given Header ID.
+     *
+     * @param int $headerId the requested Header ID
+     *
+     * @return ZipExtraField|null the Extra Field with the given Header ID or null
+     *                            if no such Extra Field exists
+     */
+    public function remove(int $headerId): ?ZipExtraField
+    {
+        $this->validateHeaderId($headerId);
+
+        if (isset($this->collection[$headerId])) {
+            $ef = $this->collection[$headerId];
+            unset($this->collection[$headerId]);
+
+            return $ef;
+        }
+
+        return null;
+    }
+
+    /**
+     * Whether a offset exists.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetexists.php
+     *
+     * @param mixed $offset an offset to check for
+     *
+     * @return bool true on success or false on failure
+     */
+    public function offsetExists($offset): bool
+    {
+        return isset($this->collection[(int) $offset]);
+    }
+
+    /**
+     * Offset to retrieve.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetget.php
+     *
+     * @param mixed $offset the offset to retrieve
+     */
+    public function offsetGet($offset): ?ZipExtraField
+    {
+        return $this->collection[(int) $offset] ?? null;
+    }
+
+    /**
+     * Offset to set.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetset.php
+     *
+     * @param mixed $offset the offset to assign the value to
+     * @param mixed $value  the value to set
+     */
+    public function offsetSet($offset, $value): void
+    {
+        if (!$value instanceof ZipExtraField) {
+            throw new \InvalidArgumentException('value is not instanceof ' . ZipExtraField::class);
+        }
+        $this->add($value);
+    }
+
+    /**
+     * Offset to unset.
+     *
+     * @see http://php.net/manual/en/arrayaccess.offsetunset.php
+     *
+     * @param mixed $offset the offset to unset
+     */
+    public function offsetUnset($offset): void
+    {
+        $this->remove($offset);
+    }
+
+    /**
+     * Return the current element.
+     *
+     * @see http://php.net/manual/en/iterator.current.php
+     */
+    public function current(): ZipExtraField
+    {
+        return current($this->collection);
+    }
+
+    /**
+     * Move forward to next element.
+     *
+     * @see http://php.net/manual/en/iterator.next.php
+     */
+    public function next(): void
+    {
+        next($this->collection);
+    }
+
+    /**
+     * Return the key of the current element.
+     *
+     * @see http://php.net/manual/en/iterator.key.php
+     *
+     * @return int scalar on success, or null on failure
+     */
+    public function key(): int
+    {
+        return key($this->collection);
+    }
+
+    /**
+     * Checks if current position is valid.
+     *
+     * @see http://php.net/manual/en/iterator.valid.php
+     *
+     * @return bool The return value will be casted to boolean and then evaluated.
+     *              Returns true on success or false on failure.
+     */
+    public function valid(): bool
+    {
+        return key($this->collection) !== null;
+    }
+
+    /**
+     * Rewind the Iterator to the first element.
+     *
+     * @see http://php.net/manual/en/iterator.rewind.php
+     */
+    public function rewind(): void
+    {
+        reset($this->collection);
+    }
+
+    public function clear(): void
+    {
+        $this->collection = [];
+    }
+
+    public function __toString(): string
+    {
+        $formats = [];
+
+        foreach ($this->collection as $key => $value) {
+            $formats[] = (string) $value;
+        }
+
+        return implode("\n", $formats);
+    }
+
+    /**
+     * If clone extra fields.
+     */
+    public function __clone()
+    {
+        foreach ($this->collection as $k => $v) {
+            $this->collection[$k] = clone $v;
+        }
+    }
+}
--- a/src/Model/Extra/Fields/AbstractUnicodeExtraField.php
+++ b/src/Model/Extra/Fields/AbstractUnicodeExtraField.php
@@ -0,0 +1,133 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * A common base class for Unicode extra information extra fields.
+ */
+abstract class AbstractUnicodeExtraField implements ZipExtraField
+{
+    public const DEFAULT_VERSION = 0x01;
+
+    private int $crc32;
+
+    private string $unicodeValue;
+
+    public function __construct(int $crc32, string $unicodeValue)
+    {
+        $this->crc32 = $crc32;
+        $this->unicodeValue = $unicodeValue;
+    }
+
+    /**
+     * @return int the CRC32 checksum of the filename or comment as
+     *             encoded in the central directory of the zip file
+     */
+    public function getCrc32(): int
+    {
+        return $this->crc32;
+    }
+
+    public function setCrc32(int $crc32): void
+    {
+        $this->crc32 = $crc32;
+    }
+
+    public function getUnicodeValue(): string
+    {
+        return $this->unicodeValue;
+    }
+
+    /**
+     * @param string $unicodeValue the UTF-8 encoded name to set
+     */
+    public function setUnicodeValue(string $unicodeValue): void
+    {
+        $this->unicodeValue = $unicodeValue;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException on error
+     *
+     * @return static
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        if (\strlen($buffer) < 5) {
+            throw new ZipException('Unicode path extra data must have at least 5 bytes.');
+        }
+
+        [
+            'version' => $version,
+            'crc32' => $crc32,
+        ] = unpack('Cversion/Vcrc32', $buffer);
+
+        if ($version !== self::DEFAULT_VERSION) {
+            throw new ZipException(sprintf('Unsupported version [%d] for Unicode path extra data.', $version));
+        }
+
+        $unicodeValue = substr($buffer, 5);
+
+        return new static($crc32, $unicodeValue);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException on error
+     *
+     * @return static
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        return pack(
+            'CV',
+            self::DEFAULT_VERSION,
+            $this->crc32
+        )
+            . $this->unicodeValue;
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        return $this->packLocalFileData();
+    }
+}
--- a/src/Model/Extra/Fields/ApkAlignmentExtraField.php
+++ b/src/Model/Extra/Fields/ApkAlignmentExtraField.php
@@ -0,0 +1,156 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Apk Alignment Extra Field.
+ *
+ * @see https://android.googlesource.com/platform/tools/apksig/+/master/src/main/java/com/android/apksig/ApkSigner.java
+ * @see https://developer.android.com/studio/command-line/zipalign
+ */
+final class ApkAlignmentExtraField implements ZipExtraField
+{
+    /**
+     * @var int Extensible data block/field header ID used for storing
+     *          information about alignment of uncompressed entries as
+     *          well as for aligning the entries's data. See ZIP
+     *          appnote.txt section 4.5 Extensible data fields.
+     */
+    public const HEADER_ID = 0xD935;
+
+    /** @var int */
+    public const ALIGNMENT_BYTES = 4;
+
+    /** @var int */
+    public const COMMON_PAGE_ALIGNMENT_BYTES = 4096;
+
+    private int $multiple;
+
+    private int $padding;
+
+    public function __construct(int $multiple, int $padding)
+    {
+        $this->multiple = $multiple;
+        $this->padding = $padding;
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    public function getMultiple(): int
+    {
+        return $this->multiple;
+    }
+
+    public function getPadding(): int
+    {
+        return $this->padding;
+    }
+
+    public function setMultiple(int $multiple): void
+    {
+        $this->multiple = $multiple;
+    }
+
+    public function setPadding(int $padding): void
+    {
+        $this->padding = $padding;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException
+     *
+     * @return ApkAlignmentExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $length = \strlen($buffer);
+
+        if ($length < 2) {
+            // This is APK alignment field.
+            // FORMAT:
+            //  * uint16 alignment multiple (in bytes)
+            //  * remaining bytes -- padding to achieve alignment of data which starts after
+            //    the extra field
+            throw new ZipException(
+                'Minimum 6 bytes of the extensible data block/field used for alignment of uncompressed entries.'
+            );
+        }
+        $multiple = unpack('v', $buffer)[1];
+        $padding = $length - 2;
+
+        return new self($multiple, $padding);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException on error
+     *
+     * @return ApkAlignmentExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        return pack('vx' . $this->padding, $this->multiple);
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        return $this->packLocalFileData();
+    }
+
+    public function __toString(): string
+    {
+        return sprintf(
+            '0x%04x APK Alignment: Multiple=%d Padding=%d',
+            self::HEADER_ID,
+            $this->multiple,
+            $this->padding
+        );
+    }
+}
--- a/src/Model/Extra/Fields/AsiExtraField.php
+++ b/src/Model/Extra/Fields/AsiExtraField.php
@@ -0,0 +1,285 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Constants\UnixStat;
+use PhpZip\Exception\Crc32Exception;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * ASi Unix Extra Field:
+ * ====================.
+ *
+ * The following is the layout of the ASi extra block for Unix.  The
+ * local-header and central-header versions are identical.
+ * (Last Revision 19960916)
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (Unix3) 0x756e        Short       tag for this extra block type ("nu")
+ * TSize         Short       total data size for this block
+ * CRC           Long        CRC-32 of the remaining data
+ * Mode          Short       file permissions
+ * SizDev        Long        symlink'd size OR major/minor dev num
+ * UID           Short       user ID
+ * GID           Short       group ID
+ * (var.)        variable    symbolic link filename
+ *
+ * Mode is the standard Unix st_mode field from struct stat, containing
+ * user/group/other permissions, setuid/setgid and symlink info, etc.
+ *
+ * If Mode indicates that this file is a symbolic link, SizDev is the
+ * size of the file to which the link points.  Otherwise, if the file
+ * is a device, SizDev contains the standard Unix st_rdev field from
+ * struct stat (includes the major and minor numbers of the device).
+ * SizDev is undefined in other cases.
+ *
+ * If Mode indicates that the file is a symbolic link, the final field
+ * will be the name of the file to which the link points.  The file-
+ * name length can be inferred from TSize.
+ *
+ * [Note that TSize may incorrectly refer to the data size not counting
+ * the CRC; i.e., it may be four bytes too small.]
+ *
+ * @see ftp://ftp.info-zip.org/pub/infozip/doc/appnote-iz-latest.zip Info-ZIP version Specification
+ */
+final class AsiExtraField implements ZipExtraField
+{
+    /** @var int Header id */
+    public const HEADER_ID = 0x756E;
+
+    public const USER_GID_PID = 1000;
+
+    /** Bits used for permissions (and sticky bit). */
+    public const PERM_MASK = 07777;
+
+    /** @var int Standard Unix stat(2) file mode. */
+    private int $mode;
+
+    /** @var int User ID. */
+    private int $uid;
+
+    /** @var int Group ID. */
+    private int $gid;
+
+    /**
+     * @var string File this entry points to, if it is a symbolic link.
+     *             Empty string - if entry is not a symbolic link.
+     */
+    private string $link;
+
+    public function __construct(int $mode, int $uid = self::USER_GID_PID, int $gid = self::USER_GID_PID, string $link = '')
+    {
+        $this->mode = $mode;
+        $this->uid = $uid;
+        $this->gid = $gid;
+        $this->link = $link;
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws Crc32Exception
+     *
+     * @return AsiExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $givenChecksum = unpack('V', $buffer)[1];
+        $buffer = substr($buffer, 4);
+        $realChecksum = crc32($buffer);
+
+        if ($givenChecksum !== $realChecksum) {
+            throw new Crc32Exception('Asi Unix Extra Filed Data', $givenChecksum, $realChecksum);
+        }
+
+        [
+            'mode' => $mode,
+            'linkSize' => $linkSize,
+            'uid' => $uid,
+            'gid' => $gid,
+        ] = unpack('vmode/VlinkSize/vuid/vgid', $buffer);
+        $link = '';
+
+        if ($linkSize > 0) {
+            $link = substr($buffer, 10);
+        }
+
+        return new self($mode, $uid, $gid, $link);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws Crc32Exception
+     *
+     * @return AsiExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        $data = pack(
+            'vVvv',
+            $this->mode,
+            \strlen($this->link),
+            $this->uid,
+            $this->gid
+        ) . $this->link;
+
+        return pack('V', crc32($data)) . $data;
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        return $this->packLocalFileData();
+    }
+
+    /**
+     * Name of linked file.
+     *
+     * @return string name of the file this entry links to if it is a
+     *                symbolic link, the empty string otherwise
+     */
+    public function getLink(): string
+    {
+        return $this->link;
+    }
+
+    /**
+     * Indicate that this entry is a symbolic link to the given filename.
+     *
+     * @param string $link name of the file this entry links to, empty
+     *                     string if it is not a symbolic link
+     */
+    public function setLink(string $link): void
+    {
+        $this->link = $link;
+        $this->mode = $this->getPermissionsMode($this->mode);
+    }
+
+    /**
+     * Is this entry a symbolic link?
+     *
+     * @return bool true if this is a symbolic link
+     */
+    public function isLink(): bool
+    {
+        return !empty($this->link);
+    }
+
+    /**
+     * Get the file mode for given permissions with the correct file type.
+     *
+     * @param int $mode the mode
+     *
+     * @return int the type with the mode
+     */
+    private function getPermissionsMode(int $mode): int
+    {
+        $type = 0;
+
+        if ($this->isLink()) {
+            $type = UnixStat::UNX_IFLNK;
+        } elseif (($mode & UnixStat::UNX_IFREG) !== 0) {
+            $type = UnixStat::UNX_IFREG;
+        } elseif (($mode & UnixStat::UNX_IFDIR) !== 0) {
+            $type = UnixStat::UNX_IFDIR;
+        }
+
+        return $type | ($mode & self::PERM_MASK);
+    }
+
+    /**
+     * Is this entry a directory?
+     *
+     * @return bool true if this entry is a directory
+     */
+    public function isDirectory(): bool
+    {
+        return ($this->mode & UnixStat::UNX_IFDIR) !== 0 && !$this->isLink();
+    }
+
+    public function getMode(): int
+    {
+        return $this->mode;
+    }
+
+    public function setMode(int $mode): void
+    {
+        $this->mode = $this->getPermissionsMode($mode);
+    }
+
+    public function getUserId(): int
+    {
+        return $this->uid;
+    }
+
+    public function setUserId(int $uid): void
+    {
+        $this->uid = $uid;
+    }
+
+    public function getGroupId(): int
+    {
+        return $this->gid;
+    }
+
+    public function setGroupId(int $gid): void
+    {
+        $this->gid = $gid;
+    }
+
+    public function __toString(): string
+    {
+        return sprintf(
+            '0x%04x ASI: Mode=%o UID=%d GID=%d Link="%s',
+            self::HEADER_ID,
+            $this->mode,
+            $this->uid,
+            $this->gid,
+            $this->link
+        );
+    }
+}
--- a/src/Model/Extra/Fields/ExtendedTimestampExtraField.php
+++ b/src/Model/Extra/Fields/ExtendedTimestampExtraField.php
@@ -0,0 +1,436 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Extended Timestamp Extra Field:
+ * ==============================.
+ *
+ * The following is the layout of the extended-timestamp extra block.
+ * (Last Revision 19970118)
+ *
+ * Local-header version:
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (time) 0x5455 Short       tag for this extra block type ("UT")
+ * TSize         Short       total data size for this block
+ * Flags         Byte        info bits
+ * (ModTime)     Long        time of last modification (UTC/GMT)
+ * (AcTime)      Long        time of last access (UTC/GMT)
+ * (CrTime)      Long        time of original creation (UTC/GMT)
+ *
+ * Central-header version:
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (time) 0x5455 Short       tag for this extra block type ("UT")
+ * TSize         Short       total data size for this block
+ * Flags         Byte        info bits (refers to local header!)
+ * (ModTime)     Long        time of last modification (UTC/GMT)
+ *
+ * The central-header extra field contains the modification time only,
+ * or no timestamp at all.  TSize is used to flag its presence or
+ * absence.  But note:
+ *
+ * If "Flags" indicates that Modtime is present in the local header
+ * field, it MUST be present in the central header field, too!
+ * This correspondence is required because the modification time
+ * value may be used to support trans-timezone freshening and
+ * updating operations with zip archives.
+ *
+ * The time values are in standard Unix signed-long format, indicating
+ * the number of seconds since 1 January 1970 00:00:00.  The times
+ * are relative to Coordinated Universal Time (UTC), also sometimes
+ * referred to as Greenwich Mean Time (GMT).  To convert to local time,
+ * the software must know the local timezone offset from UTC/GMT.
+ *
+ * The lower three bits of Flags in both headers indicate which time-
+ * stamps are present in the LOCAL extra field:
+ *
+ * bit 0           if set, modification time is present
+ * bit 1           if set, access time is present
+ * bit 2           if set, creation time is present
+ * bits 3-7        reserved for additional timestamps; not set
+ *
+ * Those times that are present will appear in the order indicated, but
+ * any combination of times may be omitted.  (Creation time may be
+ * present without access time, for example.)  TSize should equal
+ * (1 + 4*(number of set bits in Flags)), as the block is currently
+ * defined.  Other timestamps may be added in the future.
+ *
+ * @see ftp://ftp.info-zip.org/pub/infozip/doc/appnote-iz-latest.zip Info-ZIP version Specification
+ */
+final class ExtendedTimestampExtraField implements ZipExtraField
+{
+    /** @var int Header id */
+    public const HEADER_ID = 0x5455;
+
+    /**
+     * @var int the bit set inside the flags by when the last modification time
+     *          is present in this extra field
+     */
+    public const MODIFY_TIME_BIT = 1;
+
+    /**
+     * @var int the bit set inside the flags by when the last access time is
+     *          present in this extra field
+     */
+    public const ACCESS_TIME_BIT = 2;
+
+    /**
+     * @var int the bit set inside the flags by when the original creation time
+     *          is present in this extra field
+     */
+    public const CREATE_TIME_BIT = 4;
+
+    /**
+     * @var int The 3 boolean fields (below) come from this flags byte.  The remaining 5 bits
+     *          are ignored according to the current version of the spec (December 2012).
+     */
+    private int $flags;
+
+    /** @var int|null Modify time */
+    private ?int $modifyTime;
+
+    /** @var int|null Access time */
+    private ?int $accessTime;
+
+    /** @var int|null Create time */
+    private ?int $createTime;
+
+    public function __construct(int $flags, ?int $modifyTime, ?int $accessTime, ?int $createTime)
+    {
+        $this->flags = $flags;
+        $this->modifyTime = $modifyTime;
+        $this->accessTime = $accessTime;
+        $this->createTime = $createTime;
+    }
+
+    /**
+     * @param ?int $modifyTime
+     * @param ?int $accessTime
+     * @param ?int $createTime
+     *
+     * @return ExtendedTimestampExtraField
+     */
+    public static function create(?int $modifyTime, ?int $accessTime, ?int $createTime): self
+    {
+        $flags = 0;
+
+        if ($modifyTime !== null) {
+            $flags |= self::MODIFY_TIME_BIT;
+        }
+
+        if ($accessTime !== null) {
+            $flags |= self::ACCESS_TIME_BIT;
+        }
+
+        if ($createTime !== null) {
+            $flags |= self::CREATE_TIME_BIT;
+        }
+
+        return new self($flags, $modifyTime, $accessTime, $createTime);
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return ExtendedTimestampExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $length = \strlen($buffer);
+        $flags = unpack('C', $buffer)[1];
+        $offset = 1;
+
+        $modifyTime = null;
+        $accessTime = null;
+        $createTime = null;
+
+        if (($flags & self::MODIFY_TIME_BIT) === self::MODIFY_TIME_BIT) {
+            $modifyTime = unpack('V', substr($buffer, $offset, 4))[1];
+            $offset += 4;
+        }
+
+        // Notice the extra length check in case we are parsing the shorter
+        // central data field (for both access and create timestamps).
+        if ((($flags & self::ACCESS_TIME_BIT) === self::ACCESS_TIME_BIT) && $offset + 4 <= $length) {
+            $accessTime = unpack('V', substr($buffer, $offset, 4))[1];
+            $offset += 4;
+        }
+
+        if ((($flags & self::CREATE_TIME_BIT) === self::CREATE_TIME_BIT) && $offset + 4 <= $length) {
+            $createTime = unpack('V', substr($buffer, $offset, 4))[1];
+        }
+
+        return new self($flags, $modifyTime, $accessTime, $createTime);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return ExtendedTimestampExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        $data = '';
+
+        if (($this->flags & self::MODIFY_TIME_BIT) === self::MODIFY_TIME_BIT && $this->modifyTime !== null) {
+            $data .= pack('V', $this->modifyTime);
+        }
+
+        if (($this->flags & self::ACCESS_TIME_BIT) === self::ACCESS_TIME_BIT && $this->accessTime !== null) {
+            $data .= pack('V', $this->accessTime);
+        }
+
+        if (($this->flags & self::CREATE_TIME_BIT) === self::CREATE_TIME_BIT && $this->createTime !== null) {
+            $data .= pack('V', $this->createTime);
+        }
+
+        return pack('C', $this->flags) . $data;
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * Note: even if bit1 and bit2 are set, the Central data will still
+     * not contain access/create fields: only local data ever holds those!
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        $cdLength = 1 + ($this->modifyTime !== null ? 4 : 0);
+
+        return substr($this->packLocalFileData(), 0, $cdLength);
+    }
+
+    /**
+     * Gets flags byte.
+     *
+     * The flags byte tells us which of the three datestamp fields are
+     * present in the data:
+     * bit0 - modify time
+     * bit1 - access time
+     * bit2 - create time
+     *
+     * Only first 3 bits of flags are used according to the
+     * latest version of the spec (December 2012).
+     *
+     * @return int flags byte indicating which of the
+     *             three datestamp fields are present
+     */
+    public function getFlags(): int
+    {
+        return $this->flags;
+    }
+
+    /**
+     * Returns the modify time (seconds since epoch) of this zip entry,
+     * or null if no such timestamp exists in the zip entry.
+     *
+     * @return int|null modify time (seconds since epoch) or null
+     */
+    public function getModifyTime(): ?int
+    {
+        return $this->modifyTime;
+    }
+
+    /**
+     * Returns the access time (seconds since epoch) of this zip entry,
+     * or null if no such timestamp exists in the zip entry.
+     *
+     * @return int|null access time (seconds since epoch) or null
+     */
+    public function getAccessTime(): ?int
+    {
+        return $this->accessTime;
+    }
+
+    /**
+     * Returns the create time (seconds since epoch) of this zip entry,
+     * or null if no such timestamp exists in the zip entry.
+     *
+     * Note: modern linux file systems (e.g., ext2)
+     * do not appear to store a "create time" value, and so
+     * it's usually omitted altogether in the zip extra
+     * field. Perhaps other unix systems track this.
+     *
+     * @return int|null create time (seconds since epoch) or null
+     */
+    public function getCreateTime(): ?int
+    {
+        return $this->createTime;
+    }
+
+    /**
+     * Returns the modify time as a \DateTimeInterface
+     * of this zip entry, or null if no such timestamp exists in the zip entry.
+     * The milliseconds are always zeroed out, since the underlying data
+     * offers only per-second precision.
+     *
+     * @return \DateTimeInterface|null modify time as \DateTimeInterface or null
+     */
+    public function getModifyDateTime(): ?\DateTimeInterface
+    {
+        return self::timestampToDateTime($this->modifyTime);
+    }
+
+    /**
+     * Returns the access time as a \DateTimeInterface
+     * of this zip entry, or null if no such timestamp exists in the zip entry.
+     * The milliseconds are always zeroed out, since the underlying data
+     * offers only per-second precision.
+     *
+     * @return \DateTimeInterface|null access time as \DateTimeInterface or null
+     */
+    public function getAccessDateTime(): ?\DateTimeInterface
+    {
+        return self::timestampToDateTime($this->accessTime);
+    }
+
+    /**
+     * Returns the create time as a a \DateTimeInterface
+     * of this zip entry, or null if no such timestamp exists in the zip entry.
+     * The milliseconds are always zeroed out, since the underlying data
+     * offers only per-second precision.
+     *
+     * Note: modern linux file systems (e.g., ext2)
+     * do not appear to store a "create time" value, and so
+     * it's usually omitted altogether in the zip extra
+     * field.  Perhaps other unix systems track $this->.
+     *
+     * @return \DateTimeInterface|null create time as \DateTimeInterface or null
+     */
+    public function getCreateDateTime(): ?\DateTimeInterface
+    {
+        return self::timestampToDateTime($this->createTime);
+    }
+
+    /**
+     * Sets the modify time (seconds since epoch) of this zip entry
+     * using a integer.
+     *
+     * @param int|null $unixTime unix time of the modify time (seconds per epoch) or null
+     */
+    public function setModifyTime(?int $unixTime): void
+    {
+        $this->modifyTime = $unixTime;
+        $this->updateFlags();
+    }
+
+    private function updateFlags(): void
+    {
+        $flags = 0;
+
+        if ($this->modifyTime !== null) {
+            $flags |= self::MODIFY_TIME_BIT;
+        }
+
+        if ($this->accessTime !== null) {
+            $flags |= self::ACCESS_TIME_BIT;
+        }
+
+        if ($this->createTime !== null) {
+            $flags |= self::CREATE_TIME_BIT;
+        }
+        $this->flags = $flags;
+    }
+
+    /**
+     * Sets the access time (seconds since epoch) of this zip entry
+     * using a integer.
+     *
+     * @param int|null $unixTime Unix time of the access time (seconds per epoch) or null
+     */
+    public function setAccessTime(?int $unixTime): void
+    {
+        $this->accessTime = $unixTime;
+        $this->updateFlags();
+    }
+
+    /**
+     * Sets the create time (seconds since epoch) of this zip entry
+     * using a integer.
+     *
+     * @param int|null $unixTime Unix time of the create time (seconds per epoch) or null
+     */
+    public function setCreateTime(?int $unixTime): void
+    {
+        $this->createTime = $unixTime;
+        $this->updateFlags();
+    }
+
+    private static function timestampToDateTime(?int $timestamp): ?\DateTimeInterface
+    {
+        try {
+            return $timestamp !== null ? new \DateTimeImmutable('@' . $timestamp) : null;
+        } catch (\Exception $e) {
+            return null;
+        }
+    }
+
+    public function __toString(): string
+    {
+        $args = [self::HEADER_ID];
+        $format = '0x%04x ExtendedTimestamp:';
+
+        if ($this->modifyTime !== null) {
+            $format .= ' Modify:[%s]';
+            $args[] = date(\DATE_W3C, $this->modifyTime);
+        }
+
+        if ($this->accessTime !== null) {
+            $format .= ' Access:[%s]';
+            $args[] = date(\DATE_W3C, $this->accessTime);
+        }
+
+        if ($this->createTime !== null) {
+            $format .= ' Create:[%s]';
+            $args[] = date(\DATE_W3C, $this->createTime);
+        }
+
+        return vsprintf($format, $args);
+    }
+}
--- a/src/Model/Extra/Fields/JarMarkerExtraField.php
+++ b/src/Model/Extra/Fields/JarMarkerExtraField.php
@@ -0,0 +1,117 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipContainer;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Jar Marker Extra Field.
+ * An executable Java program can be packaged in a JAR file with all the libraries it uses.
+ * Executable JAR files can easily be distinguished from the files packed in the JAR file
+ * by the extra field in the first file, which is hexadecimal in the 0xCAFE bytes series.
+ * If this extra field is added as the very first extra field of
+ * the archive, Solaris will consider it an executable jar file.
+ */
+final class JarMarkerExtraField implements ZipExtraField
+{
+    /** @var int Header id. */
+    public const HEADER_ID = 0xCAFE;
+
+    public static function setJarMarker(ZipContainer $container): void
+    {
+        $zipEntries = $container->getEntries();
+
+        if (!empty($zipEntries)) {
+            foreach ($zipEntries as $zipEntry) {
+                $zipEntry->removeExtraField(self::HEADER_ID);
+            }
+            // set jar execute bit
+            reset($zipEntries);
+            $zipEntry = current($zipEntries);
+            $zipEntry->getCdExtraFields()[] = new self();
+        }
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        return '';
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        return '';
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException on error
+     *
+     * @return JarMarkerExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        if (!empty($buffer)) {
+            throw new ZipException("JarMarker doesn't expect any data");
+        }
+
+        return new self();
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException on error
+     *
+     * @return JarMarkerExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    public function __toString(): string
+    {
+        return sprintf('0x%04x Jar Marker', self::HEADER_ID);
+    }
+}
--- a/src/Model/Extra/Fields/NewUnixExtraField.php
+++ b/src/Model/Extra/Fields/NewUnixExtraField.php
@@ -0,0 +1,216 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Info-ZIP New Unix Extra Field:
+ * ====================================.
+ *
+ * Currently stores Unix UIDs/GIDs up to 32 bits.
+ * (Last Revision 20080509)
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (UnixN) 0x7875        Short       tag for this extra block type ("ux")
+ * TSize         Short       total data size for this block
+ * Version       1 byte      version of this extra field, currently 1
+ * UIDSize       1 byte      Size of UID field
+ * UID           Variable    UID for this entry
+ * GIDSize       1 byte      Size of GID field
+ * GID           Variable    GID for this entry
+ *
+ * Currently Version is set to the number 1.  If there is a need
+ * to change this field, the version will be incremented.  Changes
+ * may not be backward compatible so this extra field should not be
+ * used if the version is not recognized.
+ *
+ * UIDSize is the size of the UID field in bytes.  This size should
+ * match the size of the UID field on the target OS.
+ *
+ * UID is the UID for this entry in standard little endian format.
+ *
+ * GIDSize is the size of the GID field in bytes.  This size should
+ * match the size of the GID field on the target OS.
+ *
+ * GID is the GID for this entry in standard little endian format.
+ *
+ * If both the old 16-bit Unix extra field (tag 0x7855, Info-ZIP Unix)
+ * and this extra field are present, the values in this extra field
+ * supercede the values in that extra field.
+ */
+final class NewUnixExtraField implements ZipExtraField
+{
+    /** @var int header id */
+    public const HEADER_ID = 0x7875;
+
+    /** ID of the first non-root user created on a unix system. */
+    public const USER_GID_PID = 1000;
+
+    /** @var int version of this extra field, currently 1 */
+    private int $version;
+
+    /** @var int User id */
+    private int $uid;
+
+    /** @var int Group id */
+    private int $gid;
+
+    public function __construct(int $version = 1, int $uid = self::USER_GID_PID, int $gid = self::USER_GID_PID)
+    {
+        $this->version = $version;
+        $this->uid = $uid;
+        $this->gid = $gid;
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException
+     *
+     * @return NewUnixExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $length = \strlen($buffer);
+
+        if ($length < 3) {
+            throw new ZipException(sprintf('X7875_NewUnix length is too short, only %s bytes', $length));
+        }
+        $offset = 0;
+        [
+            'version' => $version,
+            'uidSize' => $uidSize,
+        ] = unpack('Cversion/CuidSize', $buffer);
+        $offset += 2;
+        $gid = self::readSizeIntegerLE(substr($buffer, $offset, $uidSize), $uidSize);
+        $offset += $uidSize;
+        $gidSize = unpack('C', $buffer[$offset])[1];
+        $offset++;
+        $uid = self::readSizeIntegerLE(substr($buffer, $offset, $gidSize), $gidSize);
+
+        return new self($version, $gid, $uid);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException
+     *
+     * @return NewUnixExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        return pack(
+            'CCVCV',
+            $this->version,
+            4, // UIDSize
+            $this->uid,
+            4, // GIDSize
+            $this->gid
+        );
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        return $this->packLocalFileData();
+    }
+
+    /**
+     * @throws ZipException
+     */
+    private static function readSizeIntegerLE(string $data, int $size): int
+    {
+        $format = [
+            1 => 'C', // unsigned byte
+            2 => 'v', // unsigned short LE
+            4 => 'V', // unsigned int LE
+        ];
+
+        if (!isset($format[$size])) {
+            throw new ZipException(sprintf('Invalid size bytes: %d', $size));
+        }
+
+        return unpack($format[$size], $data)[1];
+    }
+
+    public function getUid(): int
+    {
+        return $this->uid;
+    }
+
+    public function setUid(int $uid): void
+    {
+        $this->uid = $uid & 0xFFFFFFFF;
+    }
+
+    public function getGid(): int
+    {
+        return $this->gid;
+    }
+
+    public function setGid(int $gid): void
+    {
+        $this->gid = $gid & 0xFFFFFFFF;
+    }
+
+    public function getVersion(): int
+    {
+        return $this->version;
+    }
+
+    public function __toString(): string
+    {
+        return sprintf(
+            '0x%04x NewUnix: UID=%d GID=%d',
+            self::HEADER_ID,
+            $this->uid,
+            $this->gid
+        );
+    }
+}
--- a/src/Model/Extra/Fields/NtfsExtraField.php
+++ b/src/Model/Extra/Fields/NtfsExtraField.php
@@ -0,0 +1,287 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Exception\InvalidArgumentException;
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * NTFS Extra Field.
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
+ */
+final class NtfsExtraField implements ZipExtraField
+{
+    /** @var int Header id */
+    public const HEADER_ID = 0x000A;
+
+    /** @var int Tag ID */
+    public const TIME_ATTR_TAG = 0x0001;
+
+    /** @var int Attribute size */
+    public const TIME_ATTR_SIZE = 24; // 3 * 8
+
+    /**
+     * @var int A file time is a 64-bit value that represents the number of
+     *          100-nanosecond intervals that have elapsed since 12:00
+     *          A.M. January 1, 1601 Coordinated Universal Time (UTC).
+     *          this is the offset of Windows time 0 to Unix epoch in 100-nanosecond intervals.
+     */
+    public const EPOCH_OFFSET = -116444736000000000;
+
+    /** @var int Modify ntfs time */
+    private int $modifyNtfsTime;
+
+    /** @var int Access ntfs time */
+    private int $accessNtfsTime;
+
+    /** @var int Create ntfs time */
+    private int $createNtfsTime;
+
+    public function __construct(int $modifyNtfsTime, int $accessNtfsTime, int $createNtfsTime)
+    {
+        $this->modifyNtfsTime = $modifyNtfsTime;
+        $this->accessNtfsTime = $accessNtfsTime;
+        $this->createNtfsTime = $createNtfsTime;
+    }
+
+    /**
+     * @return NtfsExtraField
+     */
+    public static function create(
+        \DateTimeInterface $modifyDateTime,
+        \DateTimeInterface $accessDateTime,
+        \DateTimeInterface $createNtfsTime
+    ): self {
+        return new self(
+            self::dateTimeToNtfsTime($modifyDateTime),
+            self::dateTimeToNtfsTime($accessDateTime),
+            self::dateTimeToNtfsTime($createNtfsTime)
+        );
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException
+     *
+     * @return NtfsExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        if (\PHP_INT_SIZE === 4) {
+            throw new ZipException('not supported for php-32bit');
+        }
+
+        $buffer = substr($buffer, 4);
+
+        $modifyTime = 0;
+        $accessTime = 0;
+        $createTime = 0;
+
+        while ($buffer || $buffer !== '') {
+            [
+                'tag' => $tag,
+                'sizeAttr' => $sizeAttr,
+            ] = unpack('vtag/vsizeAttr', $buffer);
+
+            if ($tag === self::TIME_ATTR_TAG && $sizeAttr === self::TIME_ATTR_SIZE) {
+                [
+                    'modifyTime' => $modifyTime,
+                    'accessTime' => $accessTime,
+                    'createTime' => $createTime,
+                ] = unpack('PmodifyTime/PaccessTime/PcreateTime', substr($buffer, 4, 24));
+
+                break;
+            }
+            $buffer = substr($buffer, 4 + $sizeAttr);
+        }
+
+        return new self($modifyTime, $accessTime, $createTime);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @throws ZipException
+     *
+     * @return NtfsExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        return pack(
+            'VvvPPP',
+            0,
+            self::TIME_ATTR_TAG,
+            self::TIME_ATTR_SIZE,
+            $this->modifyNtfsTime,
+            $this->accessNtfsTime,
+            $this->createNtfsTime
+        );
+    }
+
+    public function getModifyNtfsTime(): int
+    {
+        return $this->modifyNtfsTime;
+    }
+
+    public function setModifyNtfsTime(int $modifyNtfsTime): void
+    {
+        $this->modifyNtfsTime = $modifyNtfsTime;
+    }
+
+    public function getAccessNtfsTime(): int
+    {
+        return $this->accessNtfsTime;
+    }
+
+    public function setAccessNtfsTime(int $accessNtfsTime): void
+    {
+        $this->accessNtfsTime = $accessNtfsTime;
+    }
+
+    public function getCreateNtfsTime(): int
+    {
+        return $this->createNtfsTime;
+    }
+
+    public function setCreateNtfsTime(int $createNtfsTime): void
+    {
+        $this->createNtfsTime = $createNtfsTime;
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        return $this->packLocalFileData();
+    }
+
+    public function getModifyDateTime(): \DateTimeInterface
+    {
+        return self::ntfsTimeToDateTime($this->modifyNtfsTime);
+    }
+
+    public function setModifyDateTime(\DateTimeInterface $modifyTime): void
+    {
+        $this->modifyNtfsTime = self::dateTimeToNtfsTime($modifyTime);
+    }
+
+    public function getAccessDateTime(): \DateTimeInterface
+    {
+        return self::ntfsTimeToDateTime($this->accessNtfsTime);
+    }
+
+    public function setAccessDateTime(\DateTimeInterface $accessTime): void
+    {
+        $this->accessNtfsTime = self::dateTimeToNtfsTime($accessTime);
+    }
+
+    public function getCreateDateTime(): \DateTimeInterface
+    {
+        return self::ntfsTimeToDateTime($this->createNtfsTime);
+    }
+
+    public function setCreateDateTime(\DateTimeInterface $createTime): void
+    {
+        $this->createNtfsTime = self::dateTimeToNtfsTime($createTime);
+    }
+
+    /**
+     * @param float $timestamp Float timestamp
+     */
+    public static function timestampToNtfsTime(float $timestamp): int
+    {
+        return (int) (($timestamp * 10000000) - self::EPOCH_OFFSET);
+    }
+
+    public static function dateTimeToNtfsTime(\DateTimeInterface $dateTime): int
+    {
+        return self::timestampToNtfsTime((float) $dateTime->format('U.u'));
+    }
+
+    /**
+     * @return float Float unix timestamp
+     */
+    public static function ntfsTimeToTimestamp(int $ntfsTime): float
+    {
+        return (float) (($ntfsTime + self::EPOCH_OFFSET) / 10000000);
+    }
+
+    public static function ntfsTimeToDateTime(int $ntfsTime): \DateTimeInterface
+    {
+        $timestamp = self::ntfsTimeToTimestamp($ntfsTime);
+        $dateTime = \DateTimeImmutable::createFromFormat('U.u', sprintf('%.6f', $timestamp));
+
+        if ($dateTime === false) {
+            throw new InvalidArgumentException('Cannot create date/time object for timestamp ' . $timestamp);
+        }
+
+        return $dateTime;
+    }
+
+    public function __toString(): string
+    {
+        $args = [self::HEADER_ID];
+        $format = '0x%04x NtfsExtra:';
+
+        if ($this->modifyNtfsTime !== 0) {
+            $format .= ' Modify:[%s]';
+            $args[] = $this->getModifyDateTime()->format(\DATE_ATOM);
+        }
+
+        if ($this->accessNtfsTime !== 0) {
+            $format .= ' Access:[%s]';
+            $args[] = $this->getAccessDateTime()->format(\DATE_ATOM);
+        }
+
+        if ($this->createNtfsTime !== 0) {
+            $format .= ' Create:[%s]';
+            $args[] = $this->getCreateDateTime()->format(\DATE_ATOM);
+        }
+
+        return vsprintf($format, $args);
+    }
+}
--- a/src/Model/Extra/Fields/OldUnixExtraField.php
+++ b/src/Model/Extra/Fields/OldUnixExtraField.php
@@ -0,0 +1,295 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Info-ZIP Unix Extra Field (type 1):
+ * ==================================.
+ *
+ * The following is the layout of the old Info-ZIP extra block for
+ * Unix.  It has been replaced by the extended-timestamp extra block
+ * (0x5455) and the Unix type 2 extra block (0x7855).
+ * (Last Revision 19970118)
+ *
+ * Local-header version:
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (Unix1) 0x5855        Short       tag for this extra block type ("UX")
+ * TSize         Short       total data size for this block
+ * AcTime        Long        time of last access (UTC/GMT)
+ * ModTime       Long        time of last modification (UTC/GMT)
+ * UID           Short       Unix user ID (optional)
+ * GID           Short       Unix group ID (optional)
+ *
+ * Central-header version:
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (Unix1) 0x5855        Short       tag for this extra block type ("UX")
+ * TSize         Short       total data size for this block
+ * AcTime        Long        time of last access (GMT/UTC)
+ * ModTime       Long        time of last modification (GMT/UTC)
+ *
+ * The file access and modification times are in standard Unix signed-
+ * long format, indicating the number of seconds since 1 January 1970
+ * 00:00:00.  The times are relative to Coordinated Universal Time
+ * (UTC), also sometimes referred to as Greenwich Mean Time (GMT).  To
+ * convert to local time, the software must know the local timezone
+ * offset from UTC/GMT.  The modification time may be used by non-Unix
+ * systems to support inter-timezone freshening and updating of zip
+ * archives.
+ *
+ * The local-header extra block may optionally contain UID and GID
+ * info for the file.  The local-header TSize value is the only
+ * indication of this.  Note that Unix UIDs and GIDs are usually
+ * specific to a particular machine, and they generally require root
+ * access to restore.
+ *
+ * This extra field type is obsolete, but it has been in use since
+ * mid-1994. Therefore future archiving software should continue to
+ * support it.
+ */
+final class OldUnixExtraField implements ZipExtraField
+{
+    /** @var int Header id */
+    public const HEADER_ID = 0x5855;
+
+    /** @var int|null Access timestamp */
+    private ?int $accessTime;
+
+    /** @var int|null Modify timestamp */
+    private ?int $modifyTime;
+
+    /** @var int|null User id */
+    private ?int $uid;
+
+    /** @var int|null Group id */
+    private ?int $gid;
+
+    public function __construct(?int $accessTime, ?int $modifyTime, ?int $uid, ?int $gid)
+    {
+        $this->accessTime = $accessTime;
+        $this->modifyTime = $modifyTime;
+        $this->uid = $uid;
+        $this->gid = $gid;
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return OldUnixExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $length = \strlen($buffer);
+
+        $accessTime = $modifyTime = $uid = $gid = null;
+
+        if ($length >= 4) {
+            $accessTime = unpack('V', $buffer)[1];
+        }
+
+        if ($length >= 8) {
+            $modifyTime = unpack('V', substr($buffer, 4, 4))[1];
+        }
+
+        if ($length >= 10) {
+            $uid = unpack('v', substr($buffer, 8, 2))[1];
+        }
+
+        if ($length >= 12) {
+            $gid = unpack('v', substr($buffer, 10, 2))[1];
+        }
+
+        return new self($accessTime, $modifyTime, $uid, $gid);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return OldUnixExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $length = \strlen($buffer);
+
+        $accessTime = $modifyTime = null;
+
+        if ($length >= 4) {
+            $accessTime = unpack('V', $buffer)[1];
+        }
+
+        if ($length >= 8) {
+            $modifyTime = unpack('V', substr($buffer, 4, 4))[1];
+        }
+
+        return new self($accessTime, $modifyTime, null, null);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        $data = '';
+
+        if ($this->accessTime !== null) {
+            $data .= pack('V', $this->accessTime);
+
+            if ($this->modifyTime !== null) {
+                $data .= pack('V', $this->modifyTime);
+
+                if ($this->uid !== null) {
+                    $data .= pack('v', $this->uid);
+
+                    if ($this->gid !== null) {
+                        $data .= pack('v', $this->gid);
+                    }
+                }
+            }
+        }
+
+        return $data;
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        $data = '';
+
+        if ($this->accessTime !== null) {
+            $data .= pack('V', $this->accessTime);
+
+            if ($this->modifyTime !== null) {
+                $data .= pack('V', $this->modifyTime);
+            }
+        }
+
+        return $data;
+    }
+
+    public function getAccessTime(): ?int
+    {
+        return $this->accessTime;
+    }
+
+    public function setAccessTime(?int $accessTime): void
+    {
+        $this->accessTime = $accessTime;
+    }
+
+    public function getAccessDateTime(): ?\DateTimeInterface
+    {
+        try {
+            return $this->accessTime === null ? null
+                : new \DateTimeImmutable('@' . $this->accessTime);
+        } catch (\Exception $e) {
+            return null;
+        }
+    }
+
+    public function getModifyTime(): ?int
+    {
+        return $this->modifyTime;
+    }
+
+    public function setModifyTime(?int $modifyTime): void
+    {
+        $this->modifyTime = $modifyTime;
+    }
+
+    public function getModifyDateTime(): ?\DateTimeInterface
+    {
+        try {
+            return $this->modifyTime === null ? null
+                : new \DateTimeImmutable('@' . $this->modifyTime);
+        } catch (\Exception $e) {
+            return null;
+        }
+    }
+
+    public function getUid(): ?int
+    {
+        return $this->uid;
+    }
+
+    public function setUid(?int $uid): void
+    {
+        $this->uid = $uid;
+    }
+
+    public function getGid(): ?int
+    {
+        return $this->gid;
+    }
+
+    public function setGid(?int $gid): void
+    {
+        $this->gid = $gid;
+    }
+
+    public function __toString(): string
+    {
+        $args = [self::HEADER_ID];
+        $format = '0x%04x OldUnix:';
+
+        if (($modifyTime = $this->getModifyDateTime()) !== null) {
+            $format .= ' Modify:[%s]';
+            $args[] = $modifyTime->format(\DATE_ATOM);
+        }
+
+        if (($accessTime = $this->getAccessDateTime()) !== null) {
+            $format .= ' Access:[%s]';
+            $args[] = $accessTime->format(\DATE_ATOM);
+        }
+
+        if ($this->uid !== null) {
+            $format .= ' UID=%d';
+            $args[] = $this->uid;
+        }
+
+        if ($this->gid !== null) {
+            $format .= ' GID=%d';
+            $args[] = $this->gid;
+        }
+
+        return vsprintf($format, $args);
+    }
+}
--- a/src/Model/Extra/Fields/UnicodeCommentExtraField.php
+++ b/src/Model/Extra/Fields/UnicodeCommentExtraField.php
@@ -0,0 +1,80 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+/**
+ * Info-ZIP Unicode Comment Extra Field (0x6375):.
+ *
+ * Stores the UTF-8 version of the file comment as stored in the
+ * central directory header. (Last Revision 20070912)
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (UCom) 0x6375        Short       tag for this extra block type ("uc")
+ * TSize         Short       total data size for this block
+ * Version       1 byte      version of this extra field, currently 1
+ * ComCRC32      4 bytes     Comment Field CRC32 Checksum
+ * UnicodeCom    Variable    UTF-8 version of the entry comment
+ *
+ * Currently Version is set to the number 1.  If there is a need
+ * to change this field, the version will be incremented.  Changes
+ * may not be backward compatible so this extra field should not be
+ * used if the version is not recognized.
+ *
+ * The ComCRC32 is the standard zip CRC32 checksum of the File Comment
+ * field in the central directory header.  This is used to verify that
+ * the comment field has not changed since the Unicode Comment extra field
+ * was created.  This can happen if a utility changes the File Comment
+ * field but does not update the UTF-8 Comment extra field.  If the CRC
+ * check fails, this Unicode Comment extra field should be ignored and
+ * the File Comment field in the header should be used instead.
+ *
+ * The UnicodeCom field is the UTF-8 version of the File Comment field
+ * in the header.  As UnicodeCom is defined to be UTF-8, no UTF-8 byte
+ * order mark (BOM) is used.  The length of this field is determined by
+ * subtracting the size of the previous fields from TSize.  If both the
+ * File Name and Comment fields are UTF-8, the new General Purpose Bit
+ * Flag, bit 11 (Language encoding flag (EFS)), can be used to indicate
+ * both the header File Name and Comment fields are UTF-8 and, in this
+ * case, the Unicode Path and Unicode Comment extra fields are not
+ * needed and should not be created.  Note that, for backward
+ * compatibility, bit 11 should only be used if the native character set
+ * of the paths and comments being zipped up are already in UTF-8. It is
+ * expected that the same file comment storage method, either general
+ * purpose bit 11 or extra fields, be used in both the Local and Central
+ * Directory Header for a file.
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT section 4.6.8
+ */
+final class UnicodeCommentExtraField extends AbstractUnicodeExtraField
+{
+    public const HEADER_ID = 0x6375;
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    public function __toString(): string
+    {
+        return sprintf(
+            '0x%04x UnicodeComment: "%s"',
+            self::HEADER_ID,
+            $this->getUnicodeValue()
+        );
+    }
+}
--- a/src/Model/Extra/Fields/UnicodePathExtraField.php
+++ b/src/Model/Extra/Fields/UnicodePathExtraField.php
@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+/**
+ * Info-ZIP Unicode Path Extra Field (0x7075):
+ * ==========================================.
+ *
+ * Stores the UTF-8 version of the file name field as stored in the
+ * local header and central directory header. (Last Revision 20070912)
+ *
+ * Value         Size        Description
+ * -----         ----        -----------
+ * (UPath) 0x7075        Short       tag for this extra block type ("up")
+ * TSize         Short       total data size for this block
+ * Version       1 byte      version of this extra field, currently 1
+ * NameCRC32     4 bytes     File Name Field CRC32 Checksum
+ * UnicodeName   Variable    UTF-8 version of the entry File Name
+ *
+ * Currently Version is set to the number 1.  If there is a need
+ * to change this field, the version will be incremented.  Changes
+ * may not be backward compatible so this extra field should not be
+ * used if the version is not recognized.
+ *
+ * The NameCRC32 is the standard zip CRC32 checksum of the File Name
+ * field in the header.  This is used to verify that the header
+ * File Name field has not changed since the Unicode Path extra field
+ * was created.  This can happen if a utility renames the File Name but
+ * does not update the UTF-8 path extra field.  If the CRC check fails,
+ * this UTF-8 Path Extra Field should be ignored and the File Name field
+ * in the header should be used instead.
+ *
+ * The UnicodeName is the UTF-8 version of the contents of the File Name
+ * field in the header.  As UnicodeName is defined to be UTF-8, no UTF-8
+ * byte order mark (BOM) is used.  The length of this field is determined
+ * by subtracting the size of the previous fields from TSize.  If both
+ * the File Name and Comment fields are UTF-8, the new General Purpose
+ * Bit Flag, bit 11 (Language encoding flag (EFS)), can be used to
+ * indicate that both the header File Name and Comment fields are UTF-8
+ * and, in this case, the Unicode Path and Unicode Comment extra fields
+ * are not needed and should not be created.  Note that, for backward
+ * compatibility, bit 11 should only be used if the native character set
+ * of the paths and comments being zipped up are already in UTF-8. It is
+ * expected that the same file name storage method, either general
+ * purpose bit 11 or extra fields, be used in both the Local and Central
+ * Directory Header for a file.
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT section 4.6.9
+ */
+final class UnicodePathExtraField extends AbstractUnicodeExtraField
+{
+    public const HEADER_ID = 0x7075;
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    public function __toString(): string
+    {
+        return sprintf(
+            '0x%04x UnicodePath: "%s"',
+            self::HEADER_ID,
+            $this->getUnicodeValue()
+        );
+    }
+}
--- a/src/Model/Extra/Fields/UnrecognizedExtraField.php
+++ b/src/Model/Extra/Fields/UnrecognizedExtraField.php
@@ -0,0 +1,108 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Exception\RuntimeException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Simple placeholder for all those extra fields we don't want to deal with.
+ */
+final class UnrecognizedExtraField implements ZipExtraField
+{
+    private int $headerId;
+
+    /** @var string extra field data without Header-ID or length specifier */
+    private string $data;
+
+    public function __construct(int $headerId, string $data)
+    {
+        $this->headerId = $headerId;
+        $this->data = $data;
+    }
+
+    public function setHeaderId(int $headerId): void
+    {
+        $this->headerId = $headerId;
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return $this->headerId;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return UnrecognizedExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        throw new RuntimeException('Unsupport parse');
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return UnrecognizedExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        throw new RuntimeException('Unsupport parse');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function packLocalFileData(): string
+    {
+        return $this->data;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function packCentralDirData(): string
+    {
+        return $this->data;
+    }
+
+    public function getData(): string
+    {
+        return $this->data;
+    }
+
+    public function setData(string $data): void
+    {
+        $this->data = $data;
+    }
+
+    public function __toString(): string
+    {
+        $args = [$this->headerId, $this->data];
+        $format = '0x%04x Unrecognized Extra Field: "%s"';
+
+        return vsprintf($format, $args);
+    }
+}
--- a/src/Model/Extra/Fields/WinZipAesExtraField.php
+++ b/src/Model/Extra/Fields/WinZipAesExtraField.php
@@ -0,0 +1,356 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Constants\ZipCompressionMethod;
+use PhpZip\Constants\ZipEncryptionMethod;
+use PhpZip\Exception\InvalidArgumentException;
+use PhpZip\Exception\ZipException;
+use PhpZip\Exception\ZipUnsupportMethodException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * WinZip AES Extra Field.
+ *
+ * @see http://www.winzip.com/win/en/aes_tips.htm AES Coding Tips for Developers
+ */
+final class WinZipAesExtraField implements ZipExtraField
+{
+    /** @var int Header id */
+    public const HEADER_ID = 0x9901;
+
+    /**
+     * @var int Data size (currently 7, but subject to possible increase
+     *          in the future)
+     */
+    public const DATA_SIZE = 7;
+
+    /**
+     * @var int The vendor ID field should always be set to the two ASCII
+     *          characters "AE"
+     */
+    public const VENDOR_ID = 0x4541; // 'A' | ('E' << 8)
+
+    /**
+     * @var int Entries of this type do include the standard ZIP CRC-32 value.
+     *          For use with {@see WinZipAesExtraField::setVendorVersion()}.
+     */
+    public const VERSION_AE1 = 1;
+
+    /**
+     * @var int Entries of this type do not include the standard ZIP CRC-32 value.
+     *          For use with {@see WinZipAesExtraField::setVendorVersion().
+     */
+    public const VERSION_AE2 = 2;
+
+    /** @var int integer mode value indicating AES encryption 128-bit strength */
+    public const KEY_STRENGTH_128BIT = 0x01;
+
+    /** @var int integer mode value indicating AES encryption 192-bit strength */
+    public const KEY_STRENGTH_192BIT = 0x02;
+
+    /** @var int integer mode value indicating AES encryption 256-bit strength */
+    public const KEY_STRENGTH_256BIT = 0x03;
+
+    /** @var int[] */
+    private const ALLOW_VENDOR_VERSIONS = [
+        self::VERSION_AE1,
+        self::VERSION_AE2,
+    ];
+
+    /** @var array<int, int> */
+    private const ENCRYPTION_STRENGTHS = [
+        self::KEY_STRENGTH_128BIT => 128,
+        self::KEY_STRENGTH_192BIT => 192,
+        self::KEY_STRENGTH_256BIT => 256,
+    ];
+
+    /** @var array<int, int> */
+    private const MAP_KEY_STRENGTH_METHODS = [
+        self::KEY_STRENGTH_128BIT => ZipEncryptionMethod::WINZIP_AES_128,
+        self::KEY_STRENGTH_192BIT => ZipEncryptionMethod::WINZIP_AES_192,
+        self::KEY_STRENGTH_256BIT => ZipEncryptionMethod::WINZIP_AES_256,
+    ];
+
+    /** @var int Integer version number specific to the zip vendor */
+    private int $vendorVersion = self::VERSION_AE1;
+
+    /** @var int Integer mode value indicating AES encryption strength */
+    private int $keyStrength = self::KEY_STRENGTH_256BIT;
+
+    /** @var int The actual compression method used to compress the file */
+    private int $compressionMethod;
+
+    /**
+     * @param int $vendorVersion     Integer version number specific to the zip vendor
+     * @param int $keyStrength       Integer mode value indicating AES encryption strength
+     * @param int $compressionMethod The actual compression method used to compress the file
+     *
+     * @throws ZipUnsupportMethodException
+     */
+    public function __construct(int $vendorVersion, int $keyStrength, int $compressionMethod)
+    {
+        $this->setVendorVersion($vendorVersion);
+        $this->setKeyStrength($keyStrength);
+        $this->setCompressionMethod($compressionMethod);
+    }
+
+    /**
+     * @throws ZipUnsupportMethodException
+     *
+     * @return WinZipAesExtraField
+     */
+    public static function create(ZipEntry $entry): self
+    {
+        $keyStrength = array_search($entry->getEncryptionMethod(), self::MAP_KEY_STRENGTH_METHODS, true);
+
+        if ($keyStrength === false) {
+            throw new InvalidArgumentException('Not support encryption method ' . $entry->getEncryptionMethod());
+        }
+
+        // WinZip 11 will continue to use AE-2, with no CRC, for very small files
+        // of less than 20 bytes. It will also use AE-2 for files compressed in
+        // BZIP2 format, because this format has internal integrity checks
+        // equivalent to a CRC check built in.
+        //
+        // https://www.winzip.com/win/en/aes_info.html
+        $vendorVersion = (
+            $entry->getUncompressedSize() < 20
+            || $entry->getCompressionMethod() === ZipCompressionMethod::BZIP2
+        )
+            ? self::VERSION_AE2
+            : self::VERSION_AE1;
+
+        $field = new self($vendorVersion, $keyStrength, $entry->getCompressionMethod());
+
+        $entry->getLocalExtraFields()->add($field);
+        $entry->getCdExtraFields()->add($field);
+
+        return $field;
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string    $buffer the buffer to read data from
+     * @param ?ZipEntry $entry
+     *
+     * @throws ZipException on error
+     *
+     * @return WinZipAesExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $size = \strlen($buffer);
+
+        if ($size !== self::DATA_SIZE) {
+            throw new ZipException(
+                sprintf(
+                    'WinZip AES Extra data invalid size: %d. Must be %d',
+                    $size,
+                    self::DATA_SIZE
+                )
+            );
+        }
+
+        [
+            'vendorVersion' => $vendorVersion,
+            'vendorId' => $vendorId,
+            'keyStrength' => $keyStrength,
+            'compressionMethod' => $compressionMethod,
+        ] = unpack('vvendorVersion/vvendorId/ckeyStrength/vcompressionMethod', $buffer);
+
+        if ($vendorId !== self::VENDOR_ID) {
+            throw new ZipException(
+                sprintf(
+                    'Vendor id invalid: %d. Must be %d',
+                    $vendorId,
+                    self::VENDOR_ID
+                )
+            );
+        }
+
+        return new self($vendorVersion, $keyStrength, $compressionMethod);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string    $buffer the buffer to read data from
+     * @param ?ZipEntry $entry
+     *
+     * @throws ZipException
+     *
+     * @return WinZipAesExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        return self::unpackLocalFileData($buffer, $entry);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        return pack(
+            'vvcv',
+            $this->vendorVersion,
+            self::VENDOR_ID,
+            $this->keyStrength,
+            $this->compressionMethod
+        );
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        return $this->packLocalFileData();
+    }
+
+    /**
+     * Returns the vendor version.
+     *
+     * @see WinZipAesExtraField::VERSION_AE2
+     * @see WinZipAesExtraField::VERSION_AE1
+     */
+    public function getVendorVersion(): int
+    {
+        return $this->vendorVersion;
+    }
+
+    /**
+     * Sets the vendor version.
+     *
+     * @param int $vendorVersion the vendor version
+     *
+     * @see    WinZipAesExtraField::VERSION_AE2
+     * @see    WinZipAesExtraField::VERSION_AE1
+     */
+    public function setVendorVersion(int $vendorVersion): void
+    {
+        if (!\in_array($vendorVersion, self::ALLOW_VENDOR_VERSIONS, true)) {
+            throw new InvalidArgumentException(
+                sprintf(
+                    'Unsupport WinZip AES vendor version: %d',
+                    $vendorVersion
+                )
+            );
+        }
+        $this->vendorVersion = $vendorVersion;
+    }
+
+    /**
+     * Returns vendor id.
+     */
+    public function getVendorId(): int
+    {
+        return self::VENDOR_ID;
+    }
+
+    public function getKeyStrength(): int
+    {
+        return $this->keyStrength;
+    }
+
+    /**
+     * Set key strength.
+     */
+    public function setKeyStrength(int $keyStrength): void
+    {
+        if (!isset(self::ENCRYPTION_STRENGTHS[$keyStrength])) {
+            throw new InvalidArgumentException(
+                sprintf(
+                    'Key strength %d not support value. Allow values: %s',
+                    $keyStrength,
+                    implode(', ', array_keys(self::ENCRYPTION_STRENGTHS))
+                )
+            );
+        }
+        $this->keyStrength = $keyStrength;
+    }
+
+    public function getCompressionMethod(): int
+    {
+        return $this->compressionMethod;
+    }
+
+    /**
+     * @throws ZipUnsupportMethodException
+     */
+    public function setCompressionMethod(int $compressionMethod): void
+    {
+        ZipCompressionMethod::checkSupport($compressionMethod);
+        $this->compressionMethod = $compressionMethod;
+    }
+
+    public function getEncryptionStrength(): int
+    {
+        return self::ENCRYPTION_STRENGTHS[$this->keyStrength];
+    }
+
+    public function getEncryptionMethod(): int
+    {
+        $keyStrength = $this->getKeyStrength();
+
+        if (!isset(self::MAP_KEY_STRENGTH_METHODS[$keyStrength])) {
+            throw new InvalidArgumentException('Invalid encryption method');
+        }
+
+        return self::MAP_KEY_STRENGTH_METHODS[$keyStrength];
+    }
+
+    public function isV1(): bool
+    {
+        return $this->vendorVersion === self::VERSION_AE1;
+    }
+
+    public function isV2(): bool
+    {
+        return $this->vendorVersion === self::VERSION_AE2;
+    }
+
+    public function getSaltSize(): int
+    {
+        return (int) ($this->getEncryptionStrength() / 8 / 2);
+    }
+
+    public function __toString(): string
+    {
+        return sprintf(
+            '0x%04x WINZIP AES: VendorVersion=%d KeyStrength=0x%02x CompressionMethod=%s',
+            __CLASS__,
+            $this->vendorVersion,
+            $this->keyStrength,
+            $this->compressionMethod
+        );
+    }
+}
--- a/src/Model/Extra/Fields/Zip64ExtraField.php
+++ b/src/Model/Extra/Fields/Zip64ExtraField.php
@@ -0,0 +1,277 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra\Fields;
+
+use PhpZip\Constants\ZipConstants;
+use PhpZip\Exception\RuntimeException;
+use PhpZip\Exception\ZipException;
+use PhpZip\Model\Extra\ZipExtraField;
+use PhpZip\Model\ZipEntry;
+
+/**
+ * ZIP64 Extra Field.
+ *
+ * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
+ */
+final class Zip64ExtraField implements ZipExtraField
+{
+    /** @var int The Header ID for a ZIP64 Extended Information Extra Field. */
+    public const HEADER_ID = 0x0001;
+
+    private ?int $uncompressedSize;
+
+    private ?int $compressedSize;
+
+    private ?int $localHeaderOffset;
+
+    private ?int $diskStart;
+
+    public function __construct(
+        ?int $uncompressedSize = null,
+        ?int $compressedSize = null,
+        ?int $localHeaderOffset = null,
+        ?int $diskStart = null
+    ) {
+        $this->uncompressedSize = $uncompressedSize;
+        $this->compressedSize = $compressedSize;
+        $this->localHeaderOffset = $localHeaderOffset;
+        $this->diskStart = $diskStart;
+    }
+
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int
+    {
+        return self::HEADER_ID;
+    }
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string    $buffer the buffer to read data from
+     * @param ?ZipEntry $entry
+     *
+     * @throws ZipException on error
+     *
+     * @return Zip64ExtraField
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        $length = \strlen($buffer);
+
+        if ($length === 0) {
+            // no local file data at all, may happen if an archive
+            // only holds a ZIP64 extended information extra field
+            // inside the central directory but not inside the local
+            // file header
+            return new self();
+        }
+
+        if ($length < 16) {
+            throw new ZipException(
+                'Zip64 extended information must contain both size values in the local file header.'
+            );
+        }
+
+        [
+            'uncompressedSize' => $uncompressedSize,
+            'compressedSize' => $compressedSize,
+        ] = unpack('PuncompressedSize/PcompressedSize', substr($buffer, 0, 16));
+
+        return new self($uncompressedSize, $compressedSize);
+    }
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string    $buffer the buffer to read data from
+     * @param ?ZipEntry $entry
+     *
+     * @throws ZipException
+     *
+     * @return Zip64ExtraField
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self
+    {
+        if ($entry === null) {
+            throw new RuntimeException('zipEntry is null');
+        }
+
+        $length = \strlen($buffer);
+        $remaining = $length;
+
+        $uncompressedSize = null;
+        $compressedSize = null;
+        $localHeaderOffset = null;
+        $diskStart = null;
+
+        if ($entry->getUncompressedSize() === ZipConstants::ZIP64_MAGIC) {
+            if ($remaining < 8) {
+                throw new ZipException('ZIP64 extension corrupt (no uncompressed size).');
+            }
+            $uncompressedSize = unpack('P', substr($buffer, $length - $remaining, 8))[1];
+            $remaining -= 8;
+        }
+
+        if ($entry->getCompressedSize() === ZipConstants::ZIP64_MAGIC) {
+            if ($remaining < 8) {
+                throw new ZipException('ZIP64 extension corrupt (no compressed size).');
+            }
+            $compressedSize = unpack('P', substr($buffer, $length - $remaining, 8))[1];
+            $remaining -= 8;
+        }
+
+        if ($entry->getLocalHeaderOffset() === ZipConstants::ZIP64_MAGIC) {
+            if ($remaining < 8) {
+                throw new ZipException('ZIP64 extension corrupt (no relative local header offset).');
+            }
+            $localHeaderOffset = unpack('P', substr($buffer, $length - $remaining, 8))[1];
+            $remaining -= 8;
+        }
+
+        if ($remaining === 4) {
+            $diskStart = unpack('V', substr($buffer, $length - $remaining, 4))[1];
+        }
+
+        return new self($uncompressedSize, $compressedSize, $localHeaderOffset, $diskStart);
+    }
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string
+    {
+        if ($this->uncompressedSize !== null || $this->compressedSize !== null) {
+            if ($this->uncompressedSize === null || $this->compressedSize === null) {
+                throw new \InvalidArgumentException(
+                    'Zip64 extended information must contain both size values in the local file header.'
+                );
+            }
+
+            return $this->packSizes();
+        }
+
+        return '';
+    }
+
+    private function packSizes(): string
+    {
+        $data = '';
+
+        if ($this->uncompressedSize !== null) {
+            $data .= pack('P', $this->uncompressedSize);
+        }
+
+        if ($this->compressedSize !== null) {
+            $data .= pack('P', $this->compressedSize);
+        }
+
+        return $data;
+    }
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string
+    {
+        $data = $this->packSizes();
+
+        if ($this->localHeaderOffset !== null) {
+            $data .= pack('P', $this->localHeaderOffset);
+        }
+
+        if ($this->diskStart !== null) {
+            $data .= pack('V', $this->diskStart);
+        }
+
+        return $data;
+    }
+
+    public function getUncompressedSize(): ?int
+    {
+        return $this->uncompressedSize;
+    }
+
+    public function setUncompressedSize(?int $uncompressedSize): void
+    {
+        $this->uncompressedSize = $uncompressedSize;
+    }
+
+    public function getCompressedSize(): ?int
+    {
+        return $this->compressedSize;
+    }
+
+    public function setCompressedSize(?int $compressedSize): void
+    {
+        $this->compressedSize = $compressedSize;
+    }
+
+    public function getLocalHeaderOffset(): ?int
+    {
+        return $this->localHeaderOffset;
+    }
+
+    public function setLocalHeaderOffset(?int $localHeaderOffset): void
+    {
+        $this->localHeaderOffset = $localHeaderOffset;
+    }
+
+    public function getDiskStart(): ?int
+    {
+        return $this->diskStart;
+    }
+
+    public function setDiskStart(?int $diskStart): void
+    {
+        $this->diskStart = $diskStart;
+    }
+
+    public function __toString(): string
+    {
+        $args = [self::HEADER_ID];
+        $format = '0x%04x ZIP64: ';
+        $formats = [];
+
+        if ($this->uncompressedSize !== null) {
+            $formats[] = 'SIZE=%d';
+            $args[] = $this->uncompressedSize;
+        }
+
+        if ($this->compressedSize !== null) {
+            $formats[] = 'COMP_SIZE=%d';
+            $args[] = $this->compressedSize;
+        }
+
+        if ($this->localHeaderOffset !== null) {
+            $formats[] = 'OFFSET=%d';
+            $args[] = $this->localHeaderOffset;
+        }
+
+        if ($this->diskStart !== null) {
+            $formats[] = 'DISK_START=%d';
+            $args[] = $this->diskStart;
+        }
+        $format .= implode(' ', $formats);
+
+        return vsprintf($format, $args);
+    }
+}
--- a/src/Model/Extra/ZipExtraDriver.php
+++ b/src/Model/Extra/ZipExtraDriver.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra;
+
+use PhpZip\Exception\InvalidArgumentException;
+use PhpZip\Model\Extra\Fields\ApkAlignmentExtraField;
+use PhpZip\Model\Extra\Fields\AsiExtraField;
+use PhpZip\Model\Extra\Fields\ExtendedTimestampExtraField;
+use PhpZip\Model\Extra\Fields\JarMarkerExtraField;
+use PhpZip\Model\Extra\Fields\NewUnixExtraField;
+use PhpZip\Model\Extra\Fields\NtfsExtraField;
+use PhpZip\Model\Extra\Fields\OldUnixExtraField;
+use PhpZip\Model\Extra\Fields\UnicodeCommentExtraField;
+use PhpZip\Model\Extra\Fields\UnicodePathExtraField;
+use PhpZip\Model\Extra\Fields\WinZipAesExtraField;
+use PhpZip\Model\Extra\Fields\Zip64ExtraField;
+
+/**
+ * Class ZipExtraManager.
+ */
+final class ZipExtraDriver
+{
+    /**
+     * @var array<int, string>
+     * @psalm-var array<int, class-string<ZipExtraField>>
+     */
+    private static array $implementations = [
+        ApkAlignmentExtraField::HEADER_ID => ApkAlignmentExtraField::class,
+        AsiExtraField::HEADER_ID => AsiExtraField::class,
+        ExtendedTimestampExtraField::HEADER_ID => ExtendedTimestampExtraField::class,
+        JarMarkerExtraField::HEADER_ID => JarMarkerExtraField::class,
+        NewUnixExtraField::HEADER_ID => NewUnixExtraField::class,
+        NtfsExtraField::HEADER_ID => NtfsExtraField::class,
+        OldUnixExtraField::HEADER_ID => OldUnixExtraField::class,
+        UnicodeCommentExtraField::HEADER_ID => UnicodeCommentExtraField::class,
+        UnicodePathExtraField::HEADER_ID => UnicodePathExtraField::class,
+        WinZipAesExtraField::HEADER_ID => WinZipAesExtraField::class,
+        Zip64ExtraField::HEADER_ID => Zip64ExtraField::class,
+    ];
+
+    private function __construct()
+    {
+    }
+
+    /**
+     * @param string|ZipExtraField $extraField ZipExtraField object or class name
+     */
+    public static function register($extraField): void
+    {
+        if (!is_a($extraField, ZipExtraField::class, true)) {
+            throw new InvalidArgumentException(
+                sprintf(
+                    '$extraField "%s" is not implements interface %s',
+                    (string) $extraField,
+                    ZipExtraField::class
+                )
+            );
+        }
+        self::$implementations[\call_user_func([$extraField, 'getHeaderId'])] = $extraField;
+    }
+
+    /**
+     * @param int|string|ZipExtraField $extraType ZipExtraField object or class name or extra header id
+     */
+    public static function unregister($extraType): bool
+    {
+        $headerId = null;
+
+        if (\is_int($extraType)) {
+            $headerId = $extraType;
+        } elseif (is_a($extraType, ZipExtraField::class, true)) {
+            $headerId = \call_user_func([$extraType, 'getHeaderId']);
+        } else {
+            return false;
+        }
+
+        if (isset(self::$implementations[$headerId])) {
+            unset(self::$implementations[$headerId]);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public static function getClassNameOrNull(int $headerId): ?string
+    {
+        if ($headerId < 0 || $headerId > 0xFFFF) {
+            throw new \InvalidArgumentException('$headerId out of range: ' . $headerId);
+        }
+
+        return self::$implementations[$headerId] ?? null;
+    }
+}
--- a/src/Model/Extra/ZipExtraField.php
+++ b/src/Model/Extra/ZipExtraField.php
@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model\Extra;
+
+use PhpZip\Model\ZipEntry;
+
+/**
+ * Extra Field in a Local or Central Header of a ZIP archive.
+ * It defines the common properties of all Extra Fields and how to
+ * serialize/unserialize them to/from byte arrays.
+ */
+interface ZipExtraField
+{
+    /**
+     * Returns the Header ID (type) of this Extra Field.
+     * The Header ID is an unsigned short integer (two bytes)
+     * which must be constant during the life cycle of this object.
+     */
+    public function getHeaderId(): int;
+
+    /**
+     * Populate data from this array as if it was in local file data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return static
+     */
+    public static function unpackLocalFileData(string $buffer, ?ZipEntry $entry = null): self;
+
+    /**
+     * Populate data from this array as if it was in central directory data.
+     *
+     * @param string        $buffer the buffer to read data from
+     * @param ZipEntry|null $entry  optional zip entry
+     *
+     * @return static
+     */
+    public static function unpackCentralDirData(string $buffer, ?ZipEntry $entry = null): self;
+
+    /**
+     * The actual data to put into local file data - without Header-ID
+     * or length specifier.
+     *
+     * @return string the data
+     */
+    public function packLocalFileData(): string;
+
+    /**
+     * The actual data to put into central directory - without Header-ID or
+     * length specifier.
+     *
+     * @return string the data
+     */
+    public function packCentralDirData(): string;
+
+    public function __toString(): string;
+}
--- a/src/Model/ImmutableZipContainer.php
+++ b/src/Model/ImmutableZipContainer.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model;
+
+class ImmutableZipContainer implements \Countable
+{
+    /** @var ZipEntry[] */
+    protected array $entries;
+
+    /** @var string|null Archive comment */
+    protected ?string $archiveComment;
+
+    /**
+     * @param ZipEntry[] $entries
+     * @param ?string    $archiveComment
+     */
+    public function __construct(array $entries, ?string $archiveComment = null)
+    {
+        $this->entries = $entries;
+        $this->archiveComment = $archiveComment;
+    }
+
+    /**
+     * @return ZipEntry[]
+     */
+    public function &getEntries(): array
+    {
+        return $this->entries;
+    }
+
+    public function getArchiveComment(): ?string
+    {
+        return $this->archiveComment;
+    }
+
+    /**
+     * Count elements of an object.
+     *
+     * @see https://php.net/manual/en/countable.count.php
+     *
+     * @return int The custom count as an integer.
+     *             The return value is cast to an integer.
+     */
+    public function count(): int
+    {
+        return \count($this->entries);
+    }
+
+    /**
+     * When an object is cloned, PHP 5 will perform a shallow copy of all of the object's properties.
+     * Any properties that are references to other variables, will remain references.
+     * Once the cloning is complete, if a __clone() method is defined,
+     * then the newly created object's __clone() method will be called, to allow any necessary properties that need to
+     * be changed. NOT CALLABLE DIRECTLY.
+     *
+     * @see https://php.net/manual/en/language.oop5.cloning.php
+     */
+    public function __clone()
+    {
+        foreach ($this->entries as $key => $value) {
+            $this->entries[$key] = clone $value;
+        }
+    }
+}
--- a/src/Model/ZipContainer.php
+++ b/src/Model/ZipContainer.php
@@ -0,0 +1,335 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model;
+
+use PhpZip\Constants\ZipEncryptionMethod;
+use PhpZip\Exception\InvalidArgumentException;
+use PhpZip\Exception\ZipEntryNotFoundException;
+use PhpZip\Exception\ZipException;
+
+/**
+ * Zip Container.
+ */
+class ZipContainer extends ImmutableZipContainer
+{
+    /**
+     * @var ImmutableZipContainer|null The source container contains zip entries from
+     *                                 an open zip archive. The source container makes
+     *                                 it possible to undo changes in the archive.
+     *                                 When cloning, this container is not cloned.
+     */
+    private ?ImmutableZipContainer $sourceContainer;
+
+    public function __construct(?ImmutableZipContainer $sourceContainer = null)
+    {
+        $entries = [];
+        $archiveComment = null;
+
+        if ($sourceContainer !== null) {
+            foreach ($sourceContainer->getEntries() as $entryName => $entry) {
+                $entries[$entryName] = clone $entry;
+            }
+            $archiveComment = $sourceContainer->getArchiveComment();
+        }
+        parent::__construct($entries, $archiveComment);
+        $this->sourceContainer = $sourceContainer;
+    }
+
+    public function getSourceContainer(): ?ImmutableZipContainer
+    {
+        return $this->sourceContainer;
+    }
+
+    public function addEntry(ZipEntry $entry): void
+    {
+        $this->entries[$entry->getName()] = $entry;
+    }
+
+    /**
+     * @param string|ZipEntry $entry
+     */
+    public function deleteEntry($entry): bool
+    {
+        $entry = $entry instanceof ZipEntry ? $entry->getName() : (string) $entry;
+
+        if (isset($this->entries[$entry])) {
+            unset($this->entries[$entry]);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @param string|ZipEntry $old
+     * @param string|ZipEntry $new
+     *
+     * @throws ZipException
+     *
+     * @return ZipEntry New zip entry
+     */
+    public function renameEntry($old, $new): ZipEntry
+    {
+        $old = $old instanceof ZipEntry ? $old->getName() : (string) $old;
+        $new = $new instanceof ZipEntry ? $new->getName() : (string) $new;
+
+        if (isset($this->entries[$new])) {
+            throw new InvalidArgumentException('New entry name ' . $new . ' is exists.');
+        }
+
+        $entry = $this->getEntry($old);
+        $newEntry = $entry->rename($new);
+
+        $this->deleteEntry($entry);
+        $this->addEntry($newEntry);
+
+        return $newEntry;
+    }
+
+    /**
+     * @param string|ZipEntry $entryName
+     *
+     * @throws ZipEntryNotFoundException
+     */
+    public function getEntry($entryName): ZipEntry
+    {
+        $entry = $this->getEntryOrNull($entryName);
+
+        if ($entry !== null) {
+            return $entry;
+        }
+
+        throw new ZipEntryNotFoundException($entryName);
+    }
+
+    /**
+     * @param string|ZipEntry $entryName
+     */
+    public function getEntryOrNull($entryName): ?ZipEntry
+    {
+        $entryName = $entryName instanceof ZipEntry ? $entryName->getName() : (string) $entryName;
+
+        return $this->entries[$entryName] ?? null;
+    }
+
+    /**
+     * @param string|ZipEntry $entryName
+     */
+    public function hasEntry($entryName): bool
+    {
+        $entryName = $entryName instanceof ZipEntry ? $entryName->getName() : (string) $entryName;
+
+        return isset($this->entries[$entryName]);
+    }
+
+    /**
+     * Delete all entries.
+     */
+    public function deleteAll(): void
+    {
+        $this->entries = [];
+    }
+
+    /**
+     * Delete entries by regex pattern.
+     *
+     * @param string $regexPattern Regex pattern
+     *
+     * @return ZipEntry[] Deleted entries
+     */
+    public function deleteByRegex(string $regexPattern): array
+    {
+        if (empty($regexPattern)) {
+            throw new InvalidArgumentException('The regex pattern is not specified');
+        }
+
+        /** @var ZipEntry[] $found */
+        $found = [];
+
+        foreach ($this->entries as $entryName => $entry) {
+            if (preg_match($regexPattern, $entryName)) {
+                $found[] = $entry;
+            }
+        }
+
+        foreach ($found as $entry) {
+            $this->deleteEntry($entry);
+        }
+
+        return $found;
+    }
+
+    /**
+     * Undo all changes done in the archive.
+     */
+    public function unchangeAll(): void
+    {
+        $this->entries = [];
+
+        if ($this->sourceContainer !== null) {
+            foreach ($this->sourceContainer->getEntries() as $entry) {
+                $this->entries[$entry->getName()] = clone $entry;
+            }
+        }
+        $this->unchangeArchiveComment();
+    }
+
+    /**
+     * Undo change archive comment.
+     */
+    public function unchangeArchiveComment(): void
+    {
+        $this->archiveComment = null;
+
+        if ($this->sourceContainer !== null) {
+            $this->archiveComment = $this->sourceContainer->archiveComment;
+        }
+    }
+
+    /**
+     * Revert all changes done to an entry with the given name.
+     *
+     * @param string|ZipEntry $entry Entry name or ZipEntry
+     */
+    public function unchangeEntry($entry): bool
+    {
+        $entry = $entry instanceof ZipEntry ? $entry->getName() : (string) $entry;
+
+        if (
+            $this->sourceContainer !== null
+            && isset($this->entries[$entry], $this->sourceContainer->entries[$entry])
+        ) {
+            $this->entries[$entry] = clone $this->sourceContainer->entries[$entry];
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Entries sort by name.
+     *
+     * Example:
+     * ```php
+     * $zipContainer->sortByName(static function (string $nameA, string $nameB): int {
+     *     return strcmp($nameA, $nameB);
+     * });
+     * ```
+     */
+    public function sortByName(callable $cmp): void
+    {
+        uksort($this->entries, $cmp);
+    }
+
+    /**
+     * Entries sort by entry.
+     *
+     * Example:
+     * ```php
+     * $zipContainer->sortByEntry(static function (ZipEntry $a, ZipEntry $b): int {
+     *     return strcmp($a->getName(), $b->getName());
+     * });
+     * ```
+     */
+    public function sortByEntry(callable $cmp): void
+    {
+        uasort($this->entries, $cmp);
+    }
+
+    public function setArchiveComment(?string $archiveComment): void
+    {
+        if ($archiveComment !== null && $archiveComment !== '') {
+            $length = \strlen($archiveComment);
+
+            if ($length > 0xFFFF) {
+                throw new InvalidArgumentException('Length comment out of range');
+            }
+        }
+        $this->archiveComment = $archiveComment;
+    }
+
+    public function matcher(): ZipEntryMatcher
+    {
+        return new ZipEntryMatcher($this);
+    }
+
+    /**
+     * Specify a password for extracting files.
+     *
+     * @param ?string $password
+     */
+    public function setReadPassword(?string $password): void
+    {
+        if ($this->sourceContainer !== null) {
+            foreach ($this->sourceContainer->entries as $entry) {
+                if ($entry->isEncrypted()) {
+                    $entry->setPassword($password);
+                }
+            }
+        }
+    }
+
+    /**
+     * @throws ZipEntryNotFoundException
+     * @throws ZipException
+     */
+    public function setReadPasswordEntry(string $entryName, string $password): void
+    {
+        if (!isset($this->sourceContainer->entries[$entryName])) {
+            throw new ZipEntryNotFoundException($entryName);
+        }
+
+        if ($this->sourceContainer->entries[$entryName]->isEncrypted()) {
+            $this->sourceContainer->entries[$entryName]->setPassword($password);
+        }
+    }
+
+    /**
+     * @param ?string $writePassword
+     *
+     * @throws ZipEntryNotFoundException
+     */
+    public function setWritePassword(?string $writePassword): void
+    {
+        $this->matcher()->all()->setPassword($writePassword);
+    }
+
+    /**
+     * Remove password.
+     *
+     * @throws ZipEntryNotFoundException
+     */
+    public function removePassword(): void
+    {
+        $this->matcher()->all()->setPassword(null);
+    }
+
+    /**
+     * @param string|ZipEntry $entryName
+     *
+     * @throws ZipEntryNotFoundException
+     */
+    public function removePasswordEntry($entryName): void
+    {
+        $this->matcher()->add($entryName)->setPassword(null);
+    }
+
+    /**
+     * @throws ZipEntryNotFoundException
+     */
+    public function setEncryptionMethod(int $encryptionMethod = ZipEncryptionMethod::WINZIP_AES_256): void
+    {
+        $this->matcher()->all()->setEncryptionMethod($encryptionMethod);
+    }
+}
--- a/src/Model/ZipData.php
+++ b/src/Model/ZipData.php
@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model;
+
+use PhpZip\Exception\ZipException;
+
+interface ZipData
+{
+    /**
+     * @return string returns data as string
+     */
+    public function getDataAsString(): string;
+
+    /**
+     * @return resource returns stream data
+     */
+    public function getDataAsStream();
+
+    /**
+     * @param resource $outStream
+     *
+     * @throws ZipException
+     */
+    public function copyDataToStream($outStream);
+}
--- a/src/Model/ZipEntry.php
+++ b/src/Model/ZipEntry.php
--- a/src/Model/ZipEntryMatcher.php
+++ b/src/Model/ZipEntryMatcher.php
@@ -0,0 +1,194 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the nelexa/zip package.
+ * (c) Ne-Lexa <https://github.com/Ne-Lexa/php-zip>
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace PhpZip\Model;
+
+use PhpZip\Exception\ZipEntryNotFoundException;
+
+class ZipEntryMatcher implements \Countable
+{
+    protected ZipContainer $zipContainer;
+
+    protected array $matches = [];
+
+    public function __construct(ZipContainer $zipContainer)
+    {
+        $this->zipContainer = $zipContainer;
+    }
+
+    /**
+     * @param string|ZipEntry|string[]|ZipEntry[] $entries
+     *
+     * @return ZipEntryMatcher
+     */
+    public function add($entries): self
+    {
+        $entries = (array) $entries;
+        $entries = array_map(
+            static fn ($entry) => $entry instanceof ZipEntry ? $entry->getName() : (string) $entry,
+            $entries
+        );
+        $this->matches = array_values(
+            array_map(
+                'strval',
+                array_unique(
+                    array_merge(
+                        $this->matches,
+                        array_keys(
+                            array_intersect_key(
+                                $this->zipContainer->getEntries(),
+                                array_flip($entries)
+                            )
+                        )
+                    )
+                )
+            )
+        );
+
+        return $this;
+    }
+
+    /**
+     * @return ZipEntryMatcher
+     * @noinspection PhpUnusedParameterInspection
+     */
+    public function match(string $regexp): self
+    {
+        array_walk(
+            $this->zipContainer->getEntries(),
+            function (ZipEntry $entry, string $entryName) use ($regexp): void {
+                if (preg_match($regexp, $entryName)) {
+                    $this->matches[] = $entryName;
+                }
+            }
+        );
+        $this->matches = array_unique($this->matches);
+
+        return $this;
+    }
+
+    /**
+     * @return ZipEntryMatcher
+     */
+    public function all(): self
+    {
+        $this->matches = array_map(
+            'strval',
+            array_keys($this->zipContainer->getEntries())
+        );
+
+        return $this;
+    }
+
+    /**
+     * Callable function for all select entries.
+     *
+     * Callable function signature:
+     * function(string $entryName){}
+     */
+    public function invoke(callable $callable): void
+    {
+        if (!empty($this->matches)) {
+            array_walk(
+                $this->matches,
+                /** @param string $entryName */
+                static function (string $entryName) use ($callable): void {
+                    $callable($entryName);
+                }
+            );
+        }
+    }
+
+    public function getMatches(): array
+    {
+        return $this->matches;
+    }
+
+    public function delete(): void
+    {
+        array_walk(
+            $this->matches,
+            /** @param string $entryName */
+            function (string $entryName): void {
+                $this->zipContainer->deleteEntry($entryName);
+            }
+        );
+        $this->matches = [];
+    }
+
+    /**
+     * @param ?string $password
+     * @param ?int    $encryptionMethod
+     *
+     * @throws ZipEntryNotFoundException
+     */
+    public function setPassword(?string $password, ?int $encryptionMethod = null): void
+    {
+        array_walk(
+            $this->matches,
+            /** @param string $entryName */
+            function (string $entryName) use ($password, $encryptionMethod): void {
+                $entry = $this->zipContainer->getEntry($entryName);
+
+                if (!$entry->isDirectory()) {
+                    $entry->setPassword($password, $encryptionMethod);
+                }
+            }
+        );
+    }
+
+    /**
+     * @throws ZipEntryNotFoundException
+     */
+    public function setEncryptionMethod(int $encryptionMethod): void
+    {
+        array_walk(
+            $this->matches,
+            /** @param string $entryName */
+            function (string $entryName) use ($encryptionMethod): void {
+                $entry = $this->zipContainer->getEntry($entryName);
+
+                if (!$entry->isDirectory()) {
+                    $entry->setEncryptionMethod($encryptionMethod);
+                }
+            }
+        );
+    }
+
+    /**
+     * @throws ZipEntryNotFoundException
+     */
+    public function disableEncryption(): void
+    {
+        array_walk(
+            $this->matches,
+            function (string $entryName): void {
+                $entry = $this->zipContainer->getEntry($entryName);
+
+                if (!$entry->isDirectory()) {
+                    $entry->disableEncryption();
+                }
+            }
+        );
+    }
+
+    /**
+     * Count elements of an object.
+     *
+     * @see http://php.net/manual/en/countable.count.php
+     *
+     * @return int the custom count as an integer
+     */
+    public function count(): int
+    {
+        return \count($this->matches);
+    }
+}
--- a/src/PhpZip/Crypto/CryptoEngine.php
+++ b/src/PhpZip/Crypto/CryptoEngine.php
@@ -1,24 +0,0 @@
-<?php
-namespace PhpZip\Crypto;
-
-use PhpZip\Exception\ZipAuthenticationException;
-
-interface CryptoEngine
-{
-    /**
-     * Decryption string.
-     *
-     * @param string $encryptionContent
-     * @return string
-     * @throws ZipAuthenticationException
-     */
-    public function decrypt($encryptionContent);
-
-    /**
-     * Encryption string.
-     *
-     * @param string $content
-     * @return string
-     */
-    public function encrypt($content);
-}
--- a/src/PhpZip/Crypto/TraditionalPkwareEncryptionEngine.php
+++ b/src/PhpZip/Crypto/TraditionalPkwareEncryptionEngine.php
@@ -1,236 +0,0 @@
-<?php
-namespace PhpZip\Crypto;
-
-use PhpZip\Exception\ZipAuthenticationException;
-use PhpZip\Exception\ZipCryptoException;
-use PhpZip\Model\ZipEntry;
-use PhpZip\Util\CryptoUtil;
-
-/**
- * Traditional PKWARE Encryption Engine.
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class TraditionalPkwareEncryptionEngine implements CryptoEngine
-{
-    /**
-     * Encryption header size
-     */
-    const STD_DEC_HDR_SIZE = 12;
-
-    /**
-     * Crc table
-     *
-     * @var array
-     */
-    private static $CRC_TABLE = [
-        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
-        0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
-        0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-        0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
-        0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
-        0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-        0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
-        0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
-        0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-        0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
-        0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
-        0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-        0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
-        0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
-        0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-        0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
-        0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
-        0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-        0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
-        0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
-        0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-        0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
-        0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
-        0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-        0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
-        0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
-        0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-        0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
-        0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
-        0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-        0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
-        0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
-    ];
-
-    /**
-     * Encryption keys
-     *
-     * @var array
-     */
-    private $keys = [];
-
-    /**
-     * @var ZipEntry
-     */
-    private $entry;
-
-    /**
-     * ZipCryptoEngine constructor.
-     *
-     * @param ZipEntry $entry
-     */
-    public function __construct(ZipEntry $entry)
-    {
-        $this->entry = $entry;
-        $this->initKeys($entry->getPassword());
-    }
-
-    /**
-     * Initial keys
-     *
-     * @param string $password
-     */
-    private function initKeys($password)
-    {
-        $this->keys[0] = 305419896;
-        $this->keys[1] = 591751049;
-        $this->keys[2] = 878082192;
-        foreach (unpack('C*', $password) as $b) {
-            $this->updateKeys($b);
-        }
-    }
-
-    /**
-     * Update keys.
-     *
-     * @param string $charAt
-     */
-    private function updateKeys($charAt)
-    {
-        $this->keys[0] = self::crc32($this->keys[0], $charAt);
-        $this->keys[1] = $this->keys[1] + ($this->keys[0] & 0xff);
-        $this->keys[1] = self::toInt($this->keys[1] * 134775813 + 1);
-        $this->keys[2] = self::toInt(self::crc32($this->keys[2], ($this->keys[1] >> 24) & 0xff));
-    }
-
-    /**
-     * Cast to int
-     *
-     * @param $i
-     * @return int
-     */
-    private static function toInt($i)
-    {
-        $i = (int)($i & 0xffffffff);
-        if ($i > 2147483647) {
-            return -(-$i & 0xffffffff);
-        } elseif ($i < -2147483648) {
-            return $i & -2147483648;
-        }
-        return $i;
-    }
-
-    /**
-     * Update crc.
-     *
-     * @param int $oldCrc
-     * @param string $charAt
-     * @return int
-     */
-    private function crc32($oldCrc, $charAt)
-    {
-        return (($oldCrc >> 8) & 0xffffff) ^ self::$CRC_TABLE[($oldCrc ^ $charAt) & 0xff];
-    }
-
-    /**
-     * @param string $content
-     * @return string
-     * @throws ZipAuthenticationException
-     */
-    public function decrypt($content)
-    {
-        $headerBytes = array_values(unpack('C*', substr($content, 0, self::STD_DEC_HDR_SIZE)));
-        foreach ($headerBytes as &$byte) {
-            $byte = ($byte ^ $this->decryptByte()) & 0xff;
-            $this->updateKeys($byte);
-        }
-
-        if ($this->entry->getGeneralPurposeBitFlag(ZipEntry::GPBF_DATA_DESCRIPTOR)) {
-            // compare against the file type from extended local headers
-            $checkByte = ($this->entry->getDosTime() >> 8) & 0xff;
-        } else {
-            // compare against the CRC otherwise
-            $checkByte = ($this->entry->getCrc() >> 24) & 0xff;
-        }
-        if ($byte !== $checkByte) {
-            throw new ZipAuthenticationException("Bad password for entry " . $this->entry->getName());
-        }
-
-        $outputContent = "";
-        foreach (unpack('C*', substr($content, self::STD_DEC_HDR_SIZE)) as $val) {
-            $val = ($val ^ $this->decryptByte()) & 0xff;
-            $this->updateKeys($val);
-            $outputContent .= pack('c', $val);
-        }
-        return $outputContent;
-    }
-
-    /**
-     * Decrypt byte.
-     *
-     * @return int
-     */
-    private function decryptByte()
-    {
-        $temp = $this->keys[2] | 2;
-        return (($temp * ($temp ^ 1)) >> 8) & 0xffffff;
-    }
-
-    /**
-     * Encryption data
-     *
-     * @param string $data
-     * @return string
-     */
-    public function encrypt($data)
-    {
-        $crc = $this->entry->isDataDescriptorRequired() ?
-            ($this->entry->getDosTime() & 0x0000ffff) << 16 :
-            $this->entry->getCrc();
-        $headerBytes = CryptoUtil::randomBytes(self::STD_DEC_HDR_SIZE);
-
-        // Initialize again since the generated bytes were encrypted.
-        $this->initKeys($this->entry->getPassword());
-        $headerBytes[self::STD_DEC_HDR_SIZE - 1] = pack('c', ($crc >> 24) & 0xff);
-        $headerBytes[self::STD_DEC_HDR_SIZE - 2] = pack('c', ($crc >> 16) & 0xff);
-
-        $headerBytes = $this->encryptData($headerBytes);
-        return $headerBytes . $this->encryptData($data);
-    }
-
-    /**
-     * @param string $content
-     * @return string
-     * @throws ZipCryptoException
-     */
-    private function encryptData($content)
-    {
-        if (null === $content) {
-            throw new ZipCryptoException('content is null');
-        }
-        $buff = '';
-        foreach (unpack('C*', $content) as $val) {
-            $buff .= pack('c', $this->encryptByte($val));
-        }
-        return $buff;
-    }
-
-    /**
-     * @param int $byte
-     * @return int
-     */
-    private function encryptByte($byte)
-    {
-        $tempVal = $byte ^ $this->decryptByte() & 0xff;
-        $this->updateKeys($byte);
-        return $tempVal;
-    }
-}
--- a/src/PhpZip/Crypto/WinZipAesEngine.php
+++ b/src/PhpZip/Crypto/WinZipAesEngine.php
@@ -1,247 +0,0 @@
-<?php
-namespace PhpZip\Crypto;
-
-use PhpZip\Exception\RuntimeException;
-use PhpZip\Exception\ZipAuthenticationException;
-use PhpZip\Exception\ZipCryptoException;
-use PhpZip\Extra\WinZipAesEntryExtraField;
-use PhpZip\Model\ZipEntry;
-use PhpZip\Util\CryptoUtil;
-
-/**
- * WinZip Aes Encryption Engine.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class WinZipAesEngine implements CryptoEngine
-{
-    /**
-     * The block size of the Advanced Encryption Specification (AES) Algorithm
-     * in bits (AES_BLOCK_SIZE_BITS).
-     */
-    const AES_BLOCK_SIZE_BITS = 128;
-    const PWD_VERIFIER_BITS = 16;
-    /**
-     * The iteration count for the derived keys of the cipher, KLAC and MAC.
-     */
-    const ITERATION_COUNT = 1000;
-    /**
-     * @var ZipEntry
-     */
-    private $entry;
-
-    /**
-     * WinZipAesEngine constructor.
-     * @param ZipEntry $entry
-     */
-    public function __construct(ZipEntry $entry)
-    {
-        $this->entry = $entry;
-    }
-
-    /**
-     * Decrypt from stream resource.
-     *
-     * @param string $content Input stream buffer
-     * @return string
-     * @throws ZipAuthenticationException
-     * @throws ZipCryptoException
-     */
-    public function decrypt($content)
-    {
-        /**
-         * @var WinZipAesEntryExtraField $field
-         */
-        $field = $this->entry->getExtraField(WinZipAesEntryExtraField::getHeaderId());
-        if (null === $field) {
-            throw new ZipCryptoException($this->entry->getName() . " (missing extra field for WinZip AES entry)");
-        }
-
-        // Get key strength.
-        $keyStrengthBits = $field->getKeyStrength();
-        $keyStrengthBytes = $keyStrengthBits / 8;
-
-        $pos = $keyStrengthBytes / 2;
-        $salt = substr($content, 0, $pos);
-        $passwordVerifier = substr($content, $pos, self::PWD_VERIFIER_BITS / 8);
-        $pos += self::PWD_VERIFIER_BITS / 8;
-
-        $sha1Size = 20;
-
-        // Init start, end and size of encrypted data.
-        $start = $pos;
-        $endPos = strlen($content);
-        $footerSize = $sha1Size / 2;
-        $end = $endPos - $footerSize;
-        $size = $end - $start;
-
-        if (0 > $size) {
-            throw new ZipCryptoException($this->entry->getName() . " (false positive WinZip AES entry is too short)");
-        }
-
-        // Load authentication code.
-        $authenticationCode = substr($content, $end, $footerSize);
-        if ($end + $footerSize !== $endPos) {
-            // This should never happen unless someone is writing to the
-            // end of the file concurrently!
-            throw new ZipCryptoException("Expected end of file after WinZip AES authentication code!");
-        }
-
-        $password = $this->entry->getPassword();
-        assert($password !== null);
-        assert(self::AES_BLOCK_SIZE_BITS <= $keyStrengthBits);
-
-        // WinZip 99-character limit
-        // @see https://sourceforge.net/p/p7zip/discussion/383044/thread/c859a2f0/
-        $password = substr($password, 0, 99);
-        $ctrIvSize = self::AES_BLOCK_SIZE_BITS / 8;
-        $iv = str_repeat(chr(0), $ctrIvSize);
-        do {
-            // Here comes the strange part about WinZip AES encryption:
-            // Its unorthodox use of the Password-Based Key Derivation
-            // Function 2 (PBKDF2) of PKCS #5 V2.0 alias RFC 2898.
-            // Yes, the password verifier is only a 16 bit value.
-            // So we must use the MAC for password verification, too.
-            $keyParam = hash_pbkdf2(
-                "sha1",
-                $password,
-                $salt,
-                self::ITERATION_COUNT,
-                (2 * $keyStrengthBits + self::PWD_VERIFIER_BITS) / 8,
-                true
-            );
-            $key = substr($keyParam, 0, $keyStrengthBytes);
-            $sha1MacParam = substr($keyParam, $keyStrengthBytes, $keyStrengthBytes);
-            // Verify password.
-        } while (!$passwordVerifier === substr($keyParam, 2 * $keyStrengthBytes));
-
-        $content = substr($content, $start, $size);
-        $mac = hash_hmac('sha1', $content, $sha1MacParam, true);
-
-        if (substr($mac, 0, 10) !== $authenticationCode) {
-            throw new ZipAuthenticationException($this->entry->getName() .
-                " (authenticated WinZip AES entry content has been tampered with)");
-        }
-
-        return self::aesCtrSegmentIntegerCounter(false, $content, $key, $iv);
-    }
-
-    /**
-     * Decryption or encryption AES-CTR with Segment Integer Count (SIC).
-     *
-     * @param bool $encrypted If true encryption else decryption
-     * @param string $str Data
-     * @param string $key Key
-     * @param string $iv IV
-     * @return string
-     */
-    private static function aesCtrSegmentIntegerCounter($encrypted = true, $str, $key, $iv)
-    {
-        $numOfBlocks = ceil(strlen($str) / 16);
-        $ctrStr = '';
-        for ($i = 0; $i < $numOfBlocks; ++$i) {
-            for ($j = 0; $j < 16; ++$j) {
-                $n = ord($iv[$j]);
-                if (0x100 === ++$n) {
-                    // overflow, set this one to 0, increment next
-                    $iv[$j] = chr(0);
-                } else {
-                    // no overflow, just write incremented number back and abort
-                    $iv[$j] = chr($n);
-                    break;
-                }
-            }
-            $data = substr($str, $i * 16, 16);
-            $ctrStr .= $encrypted ?
-                self::encryptCtr($data, $key, $iv) :
-                self::decryptCtr($data, $key, $iv);
-        }
-        return $ctrStr;
-    }
-
-    /**
-     * Encrypt AES-CTR.
-     *
-     * @param string $data Raw data
-     * @param string $key Aes key
-     * @param string $iv Aes IV
-     * @return string Encrypted data
-     * @throws RuntimeException
-     */
-    private static function encryptCtr($data, $key, $iv)
-    {
-        if (extension_loaded("openssl")) {
-            $numBits = strlen($key) * 8;
-            return openssl_encrypt($data, 'AES-' . $numBits . '-CTR', $key, OPENSSL_RAW_DATA, $iv);
-        } elseif (extension_loaded("mcrypt")) {
-            return mcrypt_encrypt(MCRYPT_RIJNDAEL_128, $key, $data, "ctr", $iv);
-        } else {
-            throw new RuntimeException('Extension openssl or mcrypt not loaded');
-        }
-    }
-
-    /**
-     * Decrypt AES-CTR.
-     *
-     * @param string $data Encrypted data
-     * @param string $key Aes key
-     * @param string $iv Aes IV
-     * @return string Raw data
-     * @throws RuntimeException
-     */
-    private static function decryptCtr($data, $key, $iv)
-    {
-        if (extension_loaded("openssl")) {
-            $numBits = strlen($key) * 8;
-            return openssl_decrypt($data, 'AES-' . $numBits . '-CTR', $key, OPENSSL_RAW_DATA, $iv);
-        } elseif (extension_loaded("mcrypt")) {
-            return mcrypt_decrypt(MCRYPT_RIJNDAEL_128, $key, $data, "ctr", $iv);
-        } else {
-            throw new RuntimeException('Extension openssl or mcrypt not loaded');
-        }
-    }
-
-    /**
-     * Encryption string.
-     *
-     * @param string $content
-     * @return string
-     */
-    public function encrypt($content)
-    {
-        // Init key strength.
-        $password = $this->entry->getPassword();
-        assert($password !== null);
-
-        // WinZip 99-character limit
-        // @see https://sourceforge.net/p/p7zip/discussion/383044/thread/c859a2f0/
-        $password = substr($password, 0, 99);
-
-        $keyStrengthBytes = 32;
-        $keyStrengthBits = $keyStrengthBytes * 8;
-
-        assert(self::AES_BLOCK_SIZE_BITS <= $keyStrengthBits);
-
-        $salt = CryptoUtil::randomBytes($keyStrengthBytes / 2);
-
-        $keyParam = hash_pbkdf2("sha1", $password, $salt, self::ITERATION_COUNT, (2 * $keyStrengthBits + self::PWD_VERIFIER_BITS) / 8, true);
-        $sha1HMacParam = substr($keyParam, $keyStrengthBytes, $keyStrengthBytes);
-
-        // Can you believe they "forgot" the nonce in the CTR mode IV?! :-(
-        $ctrIvSize = self::AES_BLOCK_SIZE_BITS / 8;
-        $iv = str_repeat(chr(0), $ctrIvSize);
-
-        $key = substr($keyParam, 0, $keyStrengthBytes);
-
-        $content = self::aesCtrSegmentIntegerCounter(true, $content, $key, $iv);
-
-        $mac = hash_hmac('sha1', $content, $sha1HMacParam, true);
-
-        return ($salt .
-            substr($keyParam, 2 * $keyStrengthBytes, self::PWD_VERIFIER_BITS / 8) .
-            $content .
-            substr($mac, 0, 10)
-        );
-    }
-}
--- a/src/PhpZip/Exception/Crc32Exception.php
+++ b/src/PhpZip/Exception/Crc32Exception.php
@@ -1,70 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Thrown to indicate a CRC32 mismatch between the declared value in the
- * Central File Header and the Data Descriptor or between the declared value
- * and the computed value from the decompressed data.
- *
- * The exception's detail message is the name of the ZIP entry.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class Crc32Exception extends ZipException
-{
-    /**
-     * Expected crc.
-     *
-     * @var int
-     */
-    private $expectedCrc;
-
-    /**
-     * Actual crc.
-     *
-     * @var int
-     */
-    private $actualCrc;
-
-    /**
-     * Crc32Exception constructor.
-     *
-     * @param string $name
-     * @param int $expected
-     * @param int $actual
-     */
-    public function __construct($name, $expected, $actual)
-    {
-        parent::__construct($name
-            . " (expected CRC32 value 0x"
-            . dechex($expected)
-            . ", but is actually 0x"
-            . dechex($actual)
-            . ")");
-        assert($expected != $actual);
-        $this->expectedCrc = $expected;
-        $this->actualCrc = $actual;
-    }
-
-    /**
-     * Returns expected crc.
-     *
-     * @return int
-     */
-    public function getExpectedCrc()
-    {
-        return $this->expectedCrc;
-    }
-
-    /**
-     * Returns actual crc.
-     *
-     * @return int
-     */
-    public function getActualCrc()
-    {
-        return $this->actualCrc;
-    }
-
-}
--- a/src/PhpZip/Exception/InvalidArgumentException.php
+++ b/src/PhpZip/Exception/InvalidArgumentException.php
@@ -1,14 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Thrown to indicate that a method has been passed an illegal or
- * inappropriate argument.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class InvalidArgumentException extends ZipException
-{
-
-}
--- a/src/PhpZip/Exception/RuntimeException.php
+++ b/src/PhpZip/Exception/RuntimeException.php
@@ -1,13 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Runtime exception.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class RuntimeException extends ZipException
-{
-
-}
--- a/src/PhpZip/Exception/ZipAuthenticationException.php
+++ b/src/PhpZip/Exception/ZipAuthenticationException.php
@@ -1,13 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Thrown to indicate that an authenticated ZIP entry has been tampered with.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class ZipAuthenticationException extends ZipCryptoException
-{
-
-}
--- a/src/PhpZip/Exception/ZipCryptoException.php
+++ b/src/PhpZip/Exception/ZipCryptoException.php
@@ -1,14 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Thrown if there is an issue when reading or writing an encrypted ZIP file
- * or entry.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class ZipCryptoException extends ZipException
-{
-
-}
--- a/src/PhpZip/Exception/ZipException.php
+++ b/src/PhpZip/Exception/ZipException.php
@@ -1,14 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Signals that a Zip exception of some sort has occurred.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- * @see \Exception
- */
-class ZipException extends \Exception
-{
-
-}
--- a/src/PhpZip/Exception/ZipNotFoundEntry.php
+++ b/src/PhpZip/Exception/ZipNotFoundEntry.php
@@ -1,14 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Thrown if entry not found.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- * @see \Exception
- */
-class ZipNotFoundEntry extends ZipException
-{
-
-}
--- a/src/PhpZip/Exception/ZipUnsupportMethod.php
+++ b/src/PhpZip/Exception/ZipUnsupportMethod.php
@@ -1,14 +0,0 @@
-<?php
-namespace PhpZip\Exception;
-
-/**
- * Thrown if entry unsupport compression method.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- * @see \Exception
- */
-class ZipUnsupportMethod extends ZipException
-{
-
-}
--- a/src/PhpZip/Extra/DefaultExtraField.php
+++ b/src/PhpZip/Extra/DefaultExtraField.php
@@ -1,98 +0,0 @@
-<?php
-namespace PhpZip\Extra;
-
-use PhpZip\Exception\ZipException;
-
-/**
- * Default implementation for an Extra Field in a Local or Central Header of a
- * ZIP file.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class DefaultExtraField extends ExtraField
-{
-    /**
-     * @var int
-     */
-    private static $headerId;
-
-    /**
-     * @var string
-     */
-    private $data;
-
-    /**
-     * Constructs a new Extra Field.
-     *
-     * @param int $headerId an unsigned short integer (two bytes) indicating the
-     *         type of the Extra Field.
-     * @throws ZipException
-     */
-    public function __construct($headerId)
-    {
-        if (0x0000 > $headerId || $headerId > 0xffff) {
-            throw new ZipException('headerId out of range');
-        }
-        self::$headerId = $headerId;
-    }
-
-    /**
-     * Returns the Header ID (type) of this Extra Field.
-     * The Header ID is an unsigned short integer (two bytes)
-     * which must be constant during the life cycle of this object.
-     *
-     * @return int
-     */
-    public static function getHeaderId()
-    {
-        return self::$headerId & 0xffff;
-    }
-
-    /**
-     * Returns the Data Size of this Extra Field.
-     * The Data Size is an unsigned short integer (two bytes)
-     * which indicates the length of the Data Block in bytes and does not
-     * include its own size in this Extra Field.
-     * This property may be initialized by calling ExtraField::readFrom.
-     *
-     * @return int The size of the Data Block in bytes
-     *         or 0 if unknown.
-     */
-    public function getDataSize()
-    {
-        return null !== $this->data ? strlen($this->data) : 0;
-    }
-
-    /**
-     * Initializes this Extra Field by deserializing a Data Block of
-     * size bytes $size from the resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset bytes
-     * @param int $size Size
-     * @throws ZipException
-     */
-    public function readFrom($handle, $off, $size)
-    {
-        if (0x0000 > $size || $size > 0xffff) {
-            throw new ZipException('size out of range');
-        }
-        if ($size > 0) {
-            fseek($handle, $off, SEEK_SET);
-            $this->data = fread($handle, $size);
-        }
-    }
-
-    /**
-     * @param resource $handle
-     * @param int $off
-     */
-    public function writeTo($handle, $off)
-    {
-        if (null !== $this->data) {
-            fseek($handle, $off, SEEK_SET);
-            fwrite($handle, $this->data);
-        }
-    }
-}
--- a/src/PhpZip/Extra/ExtraField.php
+++ b/src/PhpZip/Extra/ExtraField.php
@@ -1,120 +0,0 @@
-<?php
-namespace PhpZip\Extra;
-
-use PhpZip\Exception\ZipException;
-
-/**
- * Abstract base class for an Extra Field in a Local or Central Header of a
- * ZIP archive.
- * It defines the common properties of all Extra Fields and how to
- * serialize/deserialize them to/from byte arrays.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-abstract class ExtraField implements ExtraFieldHeader
-{
-    /** The Header ID for a ZIP64 Extended Information Extra Field. */
-    const ZIP64_HEADER_ID = 0x0001;
-
-    /**
-     * @var array|null
-     */
-    private static $registry;
-
-    /**
-     * A static factory method which creates a new Extra Field based on the
-     * given Header ID.
-     * The returned Extra Field still requires proper initialization, for
-     * example by calling ExtraField::readFrom.
-     *
-     * @param int $headerId An unsigned short integer (two bytes) which indicates
-     *         the type of the returned Extra Field.
-     * @return ExtraField A new Extra Field or null if not support header id.
-     * @throws ZipException If headerId is out of range.
-     */
-    public static function create($headerId)
-    {
-        if (0x0000 > $headerId || $headerId > 0xffff) {
-            throw new ZipException('headerId out of range');
-        }
-
-        /**
-         * @var ExtraField $extraField
-         */
-        if (isset(self::getRegistry()[$headerId])) {
-            $extraClassName = self::getRegistry()[$headerId];
-            $extraField = new $extraClassName;
-            if ($extraField::getHeaderId() !== $headerId) {
-                throw new ZipException('Runtime error support headerId ' . $headerId);
-            }
-        } else {
-            $extraField = new DefaultExtraField($headerId);
-        }
-        return $extraField;
-    }
-
-    /**
-     * Registered extra field classes.
-     *
-     * @return array|null
-     */
-    private static function getRegistry()
-    {
-        if (null === self::$registry) {
-            self::$registry[WinZipAesEntryExtraField::getHeaderId()] = WinZipAesEntryExtraField::class;
-            self::$registry[NtfsExtraField::getHeaderId()] = NtfsExtraField::class;
-        }
-        return self::$registry;
-    }
-
-    /**
-     * Returns a protective copy of the Data Block.
-     *
-     * @return resource
-     * @throws ZipException If size data block out of range.
-     */
-    public function getDataBlock()
-    {
-        $size = $this->getDataSize();
-        if (0x0000 > $size || $size > 0xffff) {
-            throw new ZipException('size data block out of range.');
-        }
-        $fp = fopen('php://memory', 'r+b');
-        if (0 === $size) return $fp;
-        $this->writeTo($fp, 0);
-        rewind($fp);
-        return $fp;
-    }
-
-    /**
-     * Returns the Data Size of this Extra Field.
-     * The Data Size is an unsigned short integer (two bytes)
-     * which indicates the length of the Data Block in bytes and does not
-     * include its own size in this Extra Field.
-     * This property may be initialized by calling ExtraField::readFrom.
-     *
-     * @return int The size of the Data Block in bytes
-     *         or 0 if unknown.
-     */
-    abstract public function getDataSize();
-
-    /**
-     * Serializes a Data Block of ExtraField::getDataSize bytes to the
-     * resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset bytes
-     */
-    abstract public function writeTo($handle, $off);
-
-    /**
-     * Initializes this Extra Field by deserializing a Data Block of
-     * size bytes $size from the resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset bytes
-     * @param int $size Size
-     */
-    abstract public function readFrom($handle, $off, $size);
-}
--- a/src/PhpZip/Extra/ExtraFieldHeader.php
+++ b/src/PhpZip/Extra/ExtraFieldHeader.php
@@ -1,21 +0,0 @@
-<?php
-namespace PhpZip\Extra;
-
-/**
- * Interface ExtraFieldHeader
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-interface ExtraFieldHeader
-{
-    /**
-     * Returns the Header ID (type) of this Extra Field.
-     * The Header ID is an unsigned short integer (two bytes)
-     * which must be constant during the life cycle of this object.
-     *
-     * @return int
-     */
-    public static function getHeaderId();
-
-}
--- a/src/PhpZip/Extra/ExtraFields.php
+++ b/src/PhpZip/Extra/ExtraFields.php
@@ -1,200 +0,0 @@
-<?php
-namespace PhpZip\Extra;
-
-use PhpZip\Exception\ZipException;
-
-/**
- * Represents a collection of Extra Fields as they may
- * be present at several locations in ZIP files.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class ExtraFields
-{
-    /**
-     * The map of Extra Fields.
-     * Maps from Header ID to Extra Field.
-     * Must not be null, but may be empty if no Extra Fields are used.
-     * The map is sorted by Header IDs in ascending order.
-     *
-     * @var ExtraField[]
-     */
-    private $extra = [];
-
-    /**
-     * Returns the number of Extra Fields in this collection.
-     *
-     * @return int
-     */
-    public function size()
-    {
-        return sizeof($this->extra);
-    }
-
-    /**
-     * Returns the Extra Field with the given Header ID or null
-     * if no such Extra Field exists.
-     *
-     * @param int $headerId The requested Header ID.
-     * @return ExtraField The Extra Field with the given Header ID or
-     *         if no such Extra Field exists.
-     * @throws ZipException If headerId is out of range.
-     */
-    public function get($headerId)
-    {
-        if (0x0000 > $headerId || $headerId > 0xffff) {
-            throw new ZipException('headerId out of range');
-        }
-        if (isset($this->extra[$headerId])) {
-            return $this->extra[$headerId];
-        }
-        return null;
-    }
-
-    /**
-     * Stores the given Extra Field in this collection.
-     *
-     * @param ExtraField $extraField The Extra Field to store in this collection.
-     * @return ExtraField The Extra Field previously associated with the Header ID of
-     *                    of the given Extra Field or null if no such Extra Field existed.
-     * @throws ZipException If headerId is out of range.
-     */
-    public function add(ExtraField $extraField)
-    {
-        $headerId = $extraField::getHeaderId();
-        if (0x0000 > $headerId || $headerId > 0xffff) {
-            throw new ZipException('headerId out of range');
-        }
-        $this->extra[$headerId] = $extraField;
-        return $extraField;
-    }
-
-    /**
-     * Returns Extra Field exists
-     *
-     * @param int $headerId The requested Header ID.
-     * @return bool
-     */
-    public function has($headerId)
-    {
-        return isset($this->extra[$headerId]);
-    }
-
-    /**
-     * Removes the Extra Field with the given Header ID.
-     *
-     * @param int $headerId The requested Header ID.
-     * @return ExtraField   The Extra Field with the given Header ID or null
-     *                      if no such Extra Field exists.
-     * @throws ZipException If headerId is out of range or extra field not found.
-     */
-    public function remove($headerId)
-    {
-        if (0x0000 > $headerId || $headerId > 0xffff) {
-            throw new ZipException('headerId out of range');
-        }
-        if (isset($this->extra[$headerId])) {
-            $ef = $this->extra[$headerId];
-            unset($this->extra[$headerId]);
-            return $ef;
-        }
-        throw new ZipException('ExtraField not found');
-    }
-
-    /**
-     * Returns a protective copy of the Extra Fields.
-     * null is never returned.
-     *
-     * @return string
-     * @throws ZipException If size out of range
-     */
-    public function getExtra()
-    {
-        $size = $this->getExtraLength();
-        if (0x0000 > $size || $size > 0xffff) {
-            throw new ZipException('size out of range');
-        }
-        if (0 === $size) return '';
-
-        $fp = fopen('php://memory', 'r+b');
-        $offset = 0;
-        /**
-         * @var ExtraField $ef
-         */
-        foreach ($this->extra as $ef) {
-            fwrite($fp, pack('vv', $ef::getHeaderId(), $ef->getDataSize()));
-            $offset += 4;
-            fwrite($fp, $ef->writeTo($fp, $offset));
-            $offset += $ef->getDataSize();
-        }
-        rewind($fp);
-        $content = stream_get_contents($fp);
-        fclose($fp);
-        return $content;
-    }
-
-    /**
-     * Returns the number of bytes required to hold the Extra Fields.
-     *
-     * @return int The length of the Extra Fields in bytes. May be 0.
-     * @see #getExtra
-     */
-    public function getExtraLength()
-    {
-        if (empty($this->extra)) {
-            return 0;
-        }
-        $length = 0;
-
-        /**
-         * @var ExtraField $extraField
-         */
-        foreach ($this->extra as $extraField) {
-            $length += 4 + $extraField->getDataSize();
-        }
-        return $length;
-    }
-
-    /**
-     * Initializes this Extra Field by deserializing a Data Block of
-     * size bytes $size from the resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset
-     * @param int $size Size
-     * @throws ZipException If size out of range
-     */
-    public function readFrom($handle, $off, $size)
-    {
-        if (0x0000 > $size || $size > 0xffff) {
-            throw new ZipException('size out of range');
-        }
-        $map = [];
-        if (null !== $handle && 0 < $size) {
-            $end = $off + $size;
-            while ($off < $end) {
-                fseek($handle, $off);
-                $unpack = unpack('vheaderId/vdataSize', fread($handle, 4));
-                $off += 4;
-                $extraField = ExtraField::create($unpack['headerId']);
-                $extraField->readFrom($handle, $off, $unpack['dataSize']);
-                $off += $unpack['dataSize'];
-                $map[$unpack['headerId']] = $extraField;
-            }
-            assert($off === $end);
-        }
-        $this->extra = $map;
-    }
-
-    /**
-     * If clone extra fields.
-     */
-    function __clone()
-    {
-        foreach ($this->extra as $k => $v) {
-            $this->extra[$k] = clone $v;
-        }
-    }
-
-}
--- a/src/PhpZip/Extra/NtfsExtraField.php
+++ b/src/PhpZip/Extra/NtfsExtraField.php
@@ -1,176 +0,0 @@
-<?php
-namespace PhpZip\Extra;
-
-use PhpZip\Exception\ZipException;
-use PhpZip\Util\PackUtil;
-
-/**
- * NTFS Extra Field
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class NtfsExtraField extends ExtraField
-{
-
-    /**
-     * Modify time
-     *
-     * @var int Unix Timestamp
-     */
-    private $mtime;
-
-    /**
-     * Access Time
-     *
-     * @var int Unix Timestamp
-     */
-    private $atime;
-
-    /**
-     * Create Time
-     *
-     * @var int Unix Time
-     */
-    private $ctime;
-
-    /**
-     * @var string
-     */
-    private $rawData = "";
-
-    /**
-     * Returns the Header ID (type) of this Extra Field.
-     * The Header ID is an unsigned short integer (two bytes)
-     * which must be constant during the life cycle of this object.
-     *
-     * @return int
-     */
-    public static function getHeaderId()
-    {
-        return 0x000a;
-    }
-
-    /**
-     * Returns the Data Size of this Extra Field.
-     * The Data Size is an unsigned short integer (two bytes)
-     * which indicates the length of the Data Block in bytes and does not
-     * include its own size in this Extra Field.
-     * This property may be initialized by calling ExtraField::readFrom.
-     *
-     * @return int The size of the Data Block in bytes
-     *         or 0 if unknown.
-     */
-    public function getDataSize()
-    {
-        return 8 * 4 + strlen($this->rawData);
-    }
-
-    /**
-     * Initializes this Extra Field by deserializing a Data Block of
-     * size bytes $size from the resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset bytes
-     * @param int $size Size
-     * @throws ZipException If size out of range
-     */
-    public function readFrom($handle, $off, $size)
-    {
-        if (0x0000 > $size || $size > 0xffff) {
-            throw new ZipException('size out of range');
-        }
-        if ($size > 0) {
-            $off += 4;
-            fseek($handle, $off, SEEK_SET);
-
-            $unpack = unpack('vtag/vsizeAttr', fread($handle, 4));
-            if (24 === $unpack['sizeAttr']) {
-                $tagData = fread($handle, $unpack['sizeAttr']);
-
-                $this->mtime = PackUtil::unpackLongLE(substr($tagData, 0, 8)) / 10000000 - 11644473600;
-                $this->atime = PackUtil::unpackLongLE(substr($tagData, 8, 8)) / 10000000 - 11644473600;
-                $this->ctime = PackUtil::unpackLongLE(substr($tagData, 16, 8)) / 10000000 - 11644473600;
-            }
-            $off += $unpack['sizeAttr'];
-
-            if ($size > $off) {
-                $this->rawData .= fread($handle, $size - $off);
-            }
-        }
-    }
-
-    /**
-     * Serializes a Data Block of ExtraField::getDataSize bytes to the
-     * resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset bytes
-     */
-    public function writeTo($handle, $off)
-    {
-        if (null !== $this->mtime && null !== $this->atime && null !== $this->ctime) {
-            fseek($handle, $off, SEEK_SET);
-            fwrite($handle, pack('Vvv', 0, 1, 8 * 3 + strlen($this->rawData)));
-            $mtimeLong = ($this->mtime + 11644473600) * 10000000;
-            fwrite($handle, PackUtil::packLongLE($mtimeLong));
-            $atimeLong = ($this->atime + 11644473600) * 10000000;
-            fwrite($handle, PackUtil::packLongLE($atimeLong));
-            $ctimeLong = ($this->ctime + 11644473600) * 10000000;
-            fwrite($handle, PackUtil::packLongLE($ctimeLong));
-            if (!empty($this->rawData)) {
-                fwrite($handle, $this->rawData);
-            }
-        }
-    }
-
-    /**
-     * @return int
-     */
-    public function getMtime()
-    {
-        return $this->mtime;
-    }
-
-    /**
-     * @param int $mtime
-     */
-    public function setMtime($mtime)
-    {
-        $this->mtime = (int)$mtime;
-    }
-
-    /**
-     * @return int
-     */
-    public function getAtime()
-    {
-        return $this->atime;
-    }
-
-    /**
-     * @param int $atime
-     */
-    public function setAtime($atime)
-    {
-        $this->atime = (int)$atime;
-    }
-
-    /**
-     * @return int
-     */
-    public function getCtime()
-    {
-        return $this->ctime;
-    }
-
-    /**
-     * @param int $ctime
-     */
-    public function setCtime($ctime)
-    {
-        $this->ctime = (int)$ctime;
-    }
-
-}
--- a/src/PhpZip/Extra/WinZipAesEntryExtraField.php
+++ b/src/PhpZip/Extra/WinZipAesEntryExtraField.php
@@ -1,236 +0,0 @@
-<?php
-namespace PhpZip\Extra;
-
-use PhpZip\Exception\ZipException;
-
-/**
- * WinZip AES Extra Field.
- *
- * @see http://www.winzip.com/win/en/aes_info.htm AES Encryption Information: Encryption Specification AE-1 and AE-2 (WinZip Computing, S.L.)
- * @see http://www.winzip.com/win/en/aes_tips.htm AES Coding Tips for Developers (WinZip Computing, S.L.)
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class WinZipAesEntryExtraField extends ExtraField
-{
-    const DATA_SIZE = 7;
-    const VENDOR_ID = 17729; // 'A' | ('E' << 8);
-
-    /**
-     * Entries of this type <em>do</em> include the standard ZIP CRC-32 value.
-     * For use with @see WinZipAesEntryExtraField::setVendorVersion()}/@see WinZipAesEntryExtraField::getVendorVersion().
-     */
-    const VV_AE_1 = 1;
-
-    /**
-     * Entries of this type do <em>not</em> include the standard ZIP CRC-32 value.
-     * For use with @see WinZipAesEntryExtraField::setVendorVersion()}/@see WinZipAesEntryExtraField::getVendorVersion().
-     */
-    const VV_AE_2 = 2;
-
-    const KEY_STRENGTH_128BIT = 128;
-    const KEY_STRENGTH_192BIT = 192;
-    const KEY_STRENGTH_256BIT = 256;
-
-    private static $keyStrengths = [
-        self::KEY_STRENGTH_128BIT => 0x01,
-        self::KEY_STRENGTH_192BIT => 0x02,
-        self::KEY_STRENGTH_256BIT => 0x03
-    ];
-
-    /**
-     * Vendor version.
-     *
-     * @var int
-     */
-    private $vendorVersion = self::VV_AE_1;
-
-    /**
-     * Encryption strength.
-     *
-     * @var int
-     */
-    private $encryptionStrength = self::KEY_STRENGTH_256BIT;
-
-    /**
-     * Zip compression method.
-     *
-     * @var int
-     */
-    private $method;
-
-    /**
-     * Returns the Header ID (type) of this Extra Field.
-     * The Header ID is an unsigned short integer (two bytes)
-     * which must be constant during the life cycle of this object.
-     *
-     * @return int
-     */
-    public static function getHeaderId()
-    {
-        return 0x9901;
-    }
-
-    /**
-     * Returns the Data Size of this Extra Field.
-     * The Data Size is an unsigned short integer (two bytes)
-     * which indicates the length of the Data Block in bytes and does not
-     * include its own size in this Extra Field.
-     * This property may be initialized by calling ExtraField::readFrom.
-     *
-     * @return int The size of the Data Block in bytes
-     *         or 0 if unknown.
-     */
-    public function getDataSize()
-    {
-        return self::DATA_SIZE;
-    }
-
-    /**
-     * Returns the vendor version.
-     *
-     * @see WinZipAesEntryExtraField::VV_AE_1
-     * @see WinZipAesEntryExtraField::VV_AE_2
-     */
-    public function getVendorVersion()
-    {
-        return $this->vendorVersion & 0xffff;
-    }
-
-    /**
-     * Sets the vendor version.
-     *
-     * @see    WinZipAesEntryExtraField::VV_AE_1
-     * @see    WinZipAesEntryExtraField::VV_AE_2
-     * @param  int $vendorVersion the vendor version.
-     * @throws ZipException Unsupport vendor version.
-     */
-    public function setVendorVersion($vendorVersion)
-    {
-        if ($vendorVersion < self::VV_AE_1 || self::VV_AE_2 < $vendorVersion) {
-            throw new ZipException($vendorVersion);
-        }
-        $this->vendorVersion = $vendorVersion;
-    }
-
-    /**
-     * Returns vendor id.
-     *
-     * @return int
-     */
-    public function getVendorId()
-    {
-        return self::VENDOR_ID;
-    }
-
-    /**
-     * @return bool|int
-     */
-    public function getKeyStrength()
-    {
-        return self::keyStrength($this->encryptionStrength);
-    }
-
-    /**
-     * @param int $encryptionStrength Encryption strength as bits.
-     * @return int
-     * @throws ZipException If unsupport encryption strength.
-     */
-    public static function keyStrength($encryptionStrength)
-    {
-        $flipKeyStrength = array_flip(self::$keyStrengths);
-        if (!isset($flipKeyStrength[$encryptionStrength])) {
-            throw new ZipException("Unsupport encryption strength " . $encryptionStrength);
-        }
-        return $flipKeyStrength[$encryptionStrength];
-    }
-
-    /**
-     * Returns compression method.
-     *
-     * @return int
-     */
-    public function getMethod()
-    {
-        return $this->method & 0xffff;
-    }
-
-    /**
-     * Sets compression method.
-     *
-     * @param int $compressionMethod Compression method
-     * @throws ZipException Compression method out of range.
-     */
-    public function setMethod($compressionMethod)
-    {
-        if (0x0000 > $compressionMethod || $compressionMethod > 0xffff) {
-            throw new ZipException('Compression method out of range');
-        }
-        $this->method = $compressionMethod;
-    }
-
-    /**
-     * Initializes this Extra Field by deserializing a Data Block of
-     * size bytes $size from the resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset bytes
-     * @param int $size Size
-     * @throws ZipException
-     */
-    public function readFrom($handle, $off, $size)
-    {
-        if (self::DATA_SIZE != $size)
-            throw new ZipException();
-
-        fseek($handle, $off, SEEK_SET);
-        /**
-         * @var int $vendorVersion
-         * @var int $vendorId
-         * @var int $keyStrength
-         * @var int $method
-         */
-        $unpack = unpack('vvendorVersion/vvendorId/ckeyStrength/vmethod', fread($handle, 7));
-        extract($unpack);
-        $this->setVendorVersion($vendorVersion);
-        if (self::VENDOR_ID != $vendorId) {
-            throw new ZipException();
-        }
-        $this->setKeyStrength(self::keyStrength($keyStrength)); // checked
-        $this->setMethod($method);
-    }
-
-    /**
-     * Set key strength.
-     *
-     * @param int $keyStrength
-     */
-    public function setKeyStrength($keyStrength)
-    {
-        $this->encryptionStrength = self::encryptionStrength($keyStrength);
-    }
-
-    /**
-     * Returns encryption strength.
-     *
-     * @param int $keyStrength Key strength in bits.
-     * @return int
-     */
-    public static function encryptionStrength($keyStrength)
-    {
-        return isset(self::$keyStrengths[$keyStrength]) ? self::$keyStrengths[$keyStrength] : self::$keyStrengths[self::KEY_STRENGTH_128BIT];
-    }
-
-    /**
-     * Serializes a Data Block of ExtraField::getDataSize bytes to the
-     * resource $handle at the zero based offset $off.
-     *
-     * @param resource $handle
-     * @param int $off Offset bytes
-     */
-    public function writeTo($handle, $off)
-    {
-        fseek($handle, $off, SEEK_SET);
-        fwrite($handle, pack('vvcv', $this->vendorVersion, self::VENDOR_ID, $this->encryptionStrength, $this->method));
-    }
-}
--- a/src/PhpZip/Mapper/OffsetPositionMapper.php
+++ b/src/PhpZip/Mapper/OffsetPositionMapper.php
@@ -1,42 +0,0 @@
-<?php
-namespace PhpZip\Mapper;
-
-/**
- * Adds a offset value to the given position.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class OffsetPositionMapper extends PositionMapper
-{
-    /**
-     * @var int
-     */
-    private $offset;
-
-    /**
-     * @param int $offset
-     */
-    public function __construct($offset)
-    {
-        $this->offset = $offset;
-    }
-
-    /**
-     * @param int $position
-     * @return int
-     */
-    public function map($position)
-    {
-        return parent::map($position) + $this->offset;
-    }
-
-    /**
-     * @param int $position
-     * @return int
-     */
-    public function unmap($position)
-    {
-        return parent::unmap($position) - $this->offset;
-    }
-}
--- a/src/PhpZip/Mapper/PositionMapper.php
+++ b/src/PhpZip/Mapper/PositionMapper.php
@@ -1,29 +0,0 @@
-<?php
-namespace PhpZip\Mapper;
-
-/**
- * Maps a given position.
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class PositionMapper
-{
-    /**
-     * @param int $position
-     * @return int
-     */
-    public function map($position)
-    {
-        return $position;
-    }
-
-    /**
-     * @param int $position
-     * @return int
-     */
-    public function unmap($position)
-    {
-        return $position;
-    }
-}
--- a/src/PhpZip/Model/CentralDirectory.php
+++ b/src/PhpZip/Model/CentralDirectory.php
@@ -1,482 +0,0 @@
-<?php
-namespace PhpZip\Model;
-
-use PhpZip\Exception\InvalidArgumentException;
-use PhpZip\Exception\ZipException;
-use PhpZip\Exception\ZipNotFoundEntry;
-use PhpZip\Model\Entry\ZipNewStringEntry;
-use PhpZip\Model\Entry\ZipReadEntry;
-use PhpZip\ZipFile;
-
-/**
- * Read Central Directory
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class CentralDirectory
-{
-    /** Central File Header signature. */
-    const CENTRAL_FILE_HEADER_SIG = 0x02014B50;
-    /**
-     * @var EndOfCentralDirectory End of Central Directory
-     */
-    private $endOfCentralDirectory;
-    /**
-     * @var ZipEntry[] Maps entry names to zip entries.
-     */
-    private $entries = [];
-    /**
-     * @var ZipEntry[] New and modified entries
-     */
-    private $modifiedEntries = [];
-    /**
-     * @var int Default compression level for the methods DEFLATED and BZIP2.
-     */
-    private $compressionLevel = ZipFile::LEVEL_DEFAULT_COMPRESSION;
-    /**
-     * @var int|null ZipAlign setting
-     */
-    private $zipAlign;
-    /**
-     * @var string New password
-     */
-    private $password;
-    /**
-     * @var int
-     */
-    private $encryptionMethod;
-    /**
-     * @var bool
-     */
-    private $clearPassword;
-
-    public function __construct()
-    {
-        $this->endOfCentralDirectory = new EndOfCentralDirectory();
-    }
-
-    /**
-     * Reads the central directory from the given seekable byte channel
-     * and populates the internal tables with ZipEntry instances.
-     *
-     * The ZipEntry's will know all data that can be obtained from the
-     * central directory alone, but not the data that requires the local
-     * file header or additional data to be read.
-     *
-     * @param resource $inputStream
-     * @throws ZipException
-     */
-    public function mountCentralDirectory($inputStream)
-    {
-        $this->modifiedEntries = [];
-        $this->checkZipFileSignature($inputStream);
-        $this->endOfCentralDirectory->findCentralDirectory($inputStream);
-
-        $numEntries = $this->endOfCentralDirectory->getCentralDirectoryEntriesSize();
-        $entries = [];
-        for (; $numEntries > 0; $numEntries--) {
-            $entry = new ZipReadEntry($inputStream);
-            $entry->setCentralDirectory($this);
-            // Re-load virtual offset after ZIP64 Extended Information
-            // Extra Field may have been parsed, map it to the real
-            // offset and conditionally update the preamble size from it.
-            $lfhOff = $this->endOfCentralDirectory->getMapper()->map($entry->getOffset());
-            if ($lfhOff < $this->endOfCentralDirectory->getPreamble()) {
-                $this->endOfCentralDirectory->setPreamble($lfhOff);
-            }
-            $entries[$entry->getName()] = $entry;
-        }
-
-        if (0 !== $numEntries % 0x10000) {
-            throw new ZipException("Expected " . abs($numEntries) .
-                ($numEntries > 0 ? " more" : " less") .
-                " entries in the Central Directory!");
-        }
-        $this->entries = $entries;
-
-        if ($this->endOfCentralDirectory->getPreamble() + $this->endOfCentralDirectory->getPostamble() >= fstat($inputStream)['size']) {
-            assert(0 === $numEntries);
-            $this->checkZipFileSignature($inputStream);
-        }
-    }
-
-    /**
-     * Check zip file signature
-     *
-     * @param resource $inputStream
-     * @throws ZipException if this not .ZIP file.
-     */
-    private function checkZipFileSignature($inputStream)
-    {
-        rewind($inputStream);
-        // Constraint: A ZIP file must start with a Local File Header
-        // or a (ZIP64) End Of Central Directory Record if it's empty.
-        $signatureBytes = fread($inputStream, 4);
-        if (strlen($signatureBytes) < 4) {
-            throw new ZipException("Invalid zip file.");
-        }
-        $signature = unpack('V', $signatureBytes)[1];
-        if (
-            ZipEntry::LOCAL_FILE_HEADER_SIG !== $signature
-            && EndOfCentralDirectory::ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIG !== $signature
-            && EndOfCentralDirectory::END_OF_CENTRAL_DIRECTORY_RECORD_SIG !== $signature
-        ) {
-            throw new ZipException("Expected Local File Header or (ZIP64) End Of Central Directory Record! Signature: " . $signature);
-        }
-    }
-
-    /**
-     * Set compression method for new or rewrites entries.
-     * @param int $compressionLevel
-     * @throws InvalidArgumentException
-     * @see ZipFile::LEVEL_DEFAULT_COMPRESSION
-     * @see ZipFile::LEVEL_BEST_SPEED
-     * @see ZipFile::LEVEL_BEST_COMPRESSION
-     */
-    public function setCompressionLevel($compressionLevel = ZipFile::LEVEL_DEFAULT_COMPRESSION)
-    {
-        if ($compressionLevel < ZipFile::LEVEL_DEFAULT_COMPRESSION ||
-            $compressionLevel > ZipFile::LEVEL_BEST_COMPRESSION
-        ) {
-            throw new InvalidArgumentException('Invalid compression level. Minimum level ' .
-                ZipFile::LEVEL_DEFAULT_COMPRESSION . '. Maximum level ' . ZipFile::LEVEL_BEST_COMPRESSION);
-        }
-        $this->compressionLevel = $compressionLevel;
-    }
-
-    /**
-     * @return ZipEntry[]
-     */
-    public function &getEntries()
-    {
-        return $this->entries;
-    }
-
-    /**
-     * @param string $entryName
-     * @return ZipEntry
-     * @throws ZipNotFoundEntry
-     */
-    public function getEntry($entryName)
-    {
-        if (!isset($this->entries[$entryName])) {
-            throw new ZipNotFoundEntry('Zip entry ' . $entryName . ' not found');
-        }
-        return $this->entries[$entryName];
-    }
-
-    /**
-     * @param string $entryName
-     * @return ZipEntry
-     * @throws ZipNotFoundEntry
-     */
-    public function getModifiedEntry($entryName){
-        if (!isset($this->modifiedEntries[$entryName])) {
-            throw new ZipNotFoundEntry('Zip modified entry ' . $entryName . ' not found');
-        }
-        return $this->modifiedEntries[$entryName];
-    }
-
-    /**
-     * @return EndOfCentralDirectory
-     */
-    public function getEndOfCentralDirectory()
-    {
-        return $this->endOfCentralDirectory;
-    }
-
-    public function getArchiveComment()
-    {
-        return null === $this->endOfCentralDirectory->getComment() ?
-            '' :
-            $this->endOfCentralDirectory->getComment();
-    }
-
-    /**
-     * Set entry comment
-     * @param string $entryName
-     * @param string|null $comment
-     * @throws ZipNotFoundEntry
-     */
-    public function setEntryComment($entryName, $comment)
-    {
-        if (isset($this->modifiedEntries[$entryName])) {
-            $this->modifiedEntries[$entryName]->setComment($comment);
-        } elseif (isset($this->entries[$entryName])) {
-            $entry = clone $this->entries[$entryName];
-            $entry->setComment($comment);
-            $this->putInModified($entryName, $entry);
-        } else {
-            throw new ZipNotFoundEntry("Not found entry " . $entryName);
-        }
-    }
-
-    /**
-     * @param string|null $password
-     * @param int|null $encryptionMethod
-     */
-    public function setNewPassword($password, $encryptionMethod = null)
-    {
-        $this->password = $password;
-        $this->encryptionMethod = $encryptionMethod;
-        $this->clearPassword = $password === null;
-    }
-
-    /**
-     * @return int|null
-     */
-    public function getZipAlign()
-    {
-        return $this->zipAlign;
-    }
-
-    /**
-     * @param int|null $zipAlign
-     */
-    public function setZipAlign($zipAlign = null)
-    {
-        if (null === $zipAlign) {
-            $this->zipAlign = null;
-            return;
-        }
-        $this->zipAlign = (int)$zipAlign;
-    }
-
-    /**
-     * Put modification or new entries.
-     *
-     * @param $entryName
-     * @param ZipEntry $entry
-     */
-    public function putInModified($entryName, ZipEntry $entry)
-    {
-        $this->modifiedEntries[$entryName] = $entry;
-    }
-
-    /**
-     * @param string $entryName
-     * @throws ZipNotFoundEntry
-     */
-    public function deleteEntry($entryName)
-    {
-        if (isset($this->entries[$entryName])) {
-            $this->modifiedEntries[$entryName] = null;
-        } elseif (isset($this->modifiedEntries[$entryName])) {
-            unset($this->modifiedEntries[$entryName]);
-        } else {
-            throw new ZipNotFoundEntry("Not found entry " . $entryName);
-        }
-    }
-
-    /**
-     * @param string $regexPattern
-     * @return bool
-     */
-    public function deleteEntriesFromRegex($regexPattern)
-    {
-        $count = 0;
-        foreach ($this->modifiedEntries as $entryName => &$entry) {
-            if (preg_match($regexPattern, $entryName)) {
-                unset($entry);
-                $count++;
-            }
-        }
-        foreach ($this->entries as $entryName => $entry) {
-            if (preg_match($regexPattern, $entryName)) {
-                $this->modifiedEntries[$entryName] = null;
-                $count++;
-            }
-        }
-        return $count > 0;
-    }
-
-    /**
-     * @param string $oldName
-     * @param string $newName
-     * @throws InvalidArgumentException
-     * @throws ZipNotFoundEntry
-     */
-    public function rename($oldName, $newName)
-    {
-        $oldName = (string)$oldName;
-        $newName = (string)$newName;
-
-        if (isset($this->entries[$newName]) || isset($this->modifiedEntries[$newName])) {
-            throw new InvalidArgumentException("New entry name " . $newName . ' is exists.');
-        }
-
-        if (isset($this->modifiedEntries[$oldName]) || isset($this->entries[$oldName])) {
-            $newEntry = clone (isset($this->modifiedEntries[$oldName]) ?
-                $this->modifiedEntries[$oldName] :
-                $this->entries[$oldName]);
-            $newEntry->setName($newName);
-
-            $this->modifiedEntries[$oldName] = null;
-            $this->modifiedEntries[$newName] = $newEntry;
-            return;
-        }
-        throw new ZipNotFoundEntry("Not found entry " . $oldName);
-    }
-
-    /**
-     * Delete all entries.
-     */
-    public function deleteAll()
-    {
-        $this->modifiedEntries = [];
-        foreach ($this->entries as $entry) {
-            $this->modifiedEntries[$entry->getName()] = null;
-        }
-    }
-
-    /**
-     * @param resource $outputStream
-     */
-    public function writeArchive($outputStream)
-    {
-        /**
-         * @var ZipEntry[] $memoryEntriesResult
-         */
-        $memoryEntriesResult = [];
-        foreach ($this->entries as $entryName => $entry) {
-            if (isset($this->modifiedEntries[$entryName])) continue;
-
-            if (
-                (null !== $this->password || $this->clearPassword) &&
-                $entry->isEncrypted() &&
-                $entry->getPassword() !== null &&
-                (
-                    $entry->getPassword() !== $this->password ||
-                    $entry->getEncryptionMethod() !== $this->encryptionMethod
-                )
-            ) {
-                $prototypeEntry = new ZipNewStringEntry($entry->getEntryContent());
-                $prototypeEntry->setName($entry->getName());
-                $prototypeEntry->setMethod($entry->getMethod());
-                $prototypeEntry->setTime($entry->getTime());
-                $prototypeEntry->setExternalAttributes($entry->getExternalAttributes());
-                $prototypeEntry->setExtra($entry->getExtra());
-                $prototypeEntry->setPassword($this->password, $this->encryptionMethod);
-                if ($this->clearPassword) {
-                    $prototypeEntry->clearEncryption();
-                }
-            } else {
-                $prototypeEntry = clone $entry;
-            }
-            $memoryEntriesResult[$entryName] = $prototypeEntry;
-        }
-
-        foreach ($this->modifiedEntries as $entryName => $outputEntry) {
-            if (null === $outputEntry) { // remove marked entry
-                unset($memoryEntriesResult[$entryName]);
-            } else {
-                if (null !== $this->password) {
-                    $outputEntry->setPassword($this->password, $this->encryptionMethod);
-                }
-                $memoryEntriesResult[$entryName] = $outputEntry;
-            }
-        }
-
-        foreach ($memoryEntriesResult as $key => $outputEntry) {
-            $outputEntry->setCentralDirectory($this);
-            $outputEntry->writeEntry($outputStream);
-        }
-        $centralDirectoryOffset = ftell($outputStream);
-        foreach ($memoryEntriesResult as $key => $outputEntry) {
-            if (!$this->writeCentralFileHeader($outputStream, $outputEntry)) {
-                unset($memoryEntriesResult[$key]);
-            }
-        }
-        $centralDirectoryEntries = sizeof($memoryEntriesResult);
-        $this->getEndOfCentralDirectory()->writeEndOfCentralDirectory(
-            $outputStream,
-            $centralDirectoryEntries,
-            $centralDirectoryOffset
-        );
-    }
-
-    /**
-     * Writes a Central File Header record.
-     *
-     * @param resource $outputStream
-     * @param ZipEntry $entry
-     * @return bool false if and only if the record has been skipped,
-     *         i.e. not written for some other reason than an I/O error.
-     */
-    private function writeCentralFileHeader($outputStream, ZipEntry $entry)
-    {
-        $compressedSize = $entry->getCompressedSize();
-        $size = $entry->getSize();
-        // This test MUST NOT include the CRC-32 because VV_AE_2 sets it to
-        // UNKNOWN!
-        if (ZipEntry::UNKNOWN === ($compressedSize | $size)) {
-            return false;
-        }
-        $extra = $entry->getExtra();
-        $extraSize = strlen($extra);
-
-        $commentLength = strlen($entry->getComment());
-        fwrite(
-            $outputStream,
-            pack(
-                'VvvvvVVVVvvvvvVV',
-                // central file header signature   4 bytes  (0x02014b50)
-                self::CENTRAL_FILE_HEADER_SIG,
-                // version made by                 2 bytes
-                ($entry->getPlatform() << 8) | 63,
-                // version needed to extract       2 bytes
-                $entry->getVersionNeededToExtract(),
-                // general purpose bit flag        2 bytes
-                $entry->getGeneralPurposeBitFlags(),
-                // compression method              2 bytes
-                $entry->getMethod(),
-                // last mod file datetime          4 bytes
-                $entry->getDosTime(),
-                // crc-32                          4 bytes
-                $entry->getCrc(),
-                // compressed size                 4 bytes
-                $entry->getCompressedSize(),
-                // uncompressed size               4 bytes
-                $entry->getSize(),
-                // file name length                2 bytes
-                strlen($entry->getName()),
-                // extra field length              2 bytes
-                $extraSize,
-                // file comment length             2 bytes
-                $commentLength,
-                // disk number start               2 bytes
-                0,
-                // internal file attributes        2 bytes
-                0,
-                // external file attributes        4 bytes
-                $entry->getExternalAttributes(),
-                // relative offset of local header 4 bytes
-                $entry->getOffset()
-            )
-        );
-        // file name (variable size)
-        fwrite($outputStream, $entry->getName());
-        if (0 < $extraSize) {
-            // extra field (variable size)
-            fwrite($outputStream, $extra);
-        }
-        if (0 < $commentLength) {
-            // file comment (variable size)
-            fwrite($outputStream, $entry->getComment());
-        }
-        return true;
-    }
-
-    public function release()
-    {
-        unset($this->entries);
-        unset($this->modifiedEntries);
-    }
-
-    function __destruct()
-    {
-        $this->release();
-    }
-
-}
--- a/src/PhpZip/Model/EndOfCentralDirectory.php
+++ b/src/PhpZip/Model/EndOfCentralDirectory.php
@@ -1,419 +0,0 @@
-<?php
-namespace PhpZip\Model;
-
-use PhpZip\Exception\InvalidArgumentException;
-use PhpZip\Exception\ZipException;
-use PhpZip\Mapper\OffsetPositionMapper;
-use PhpZip\Mapper\PositionMapper;
-use PhpZip\Util\PackUtil;
-
-/**
- * Read End of Central Directory
- *
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class EndOfCentralDirectory
-{
-    /** Zip64 End Of Central Directory Record. */
-    const ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIG = 0x06064B50;
-    /** Zip64 End Of Central Directory Locator. */
-    const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG = 0x07064B50;
-    /** End Of Central Directory Record signature. */
-    const END_OF_CENTRAL_DIRECTORY_RECORD_SIG = 0x06054B50;
-    /**
-     * The minimum length of the End Of Central Directory Record.
-     *
-     * end of central dir signature    4
-     * number of this disk             2
-     * number of the disk with the
-     * start of the central directory  2
-     * total number of entries in the
-     * central directory on this disk  2
-     * total number of entries in
-     * the central directory           2
-     * size of the central directory   4
-     * offset of start of central      *
-     * directory with respect to       *
-     * the starting disk number        4
-     * zipfile comment length          2
-     */
-    const END_OF_CENTRAL_DIRECTORY_RECORD_MIN_LEN = 22;
-    /**
-     * The length of the Zip64 End Of Central Directory Locator.
-     * zip64 end of central dir locator
-     * signature                       4
-     * number of the disk with the
-     * start of the zip64 end of
-     * central directory               4
-     * relative offset of the zip64
-     * end of central directory record 8
-     * total number of disks           4
-     */
-    const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_LEN = 20;
-    /**
-     * The minimum length of the Zip64 End Of Central Directory Record.
-     *
-     * zip64 end of central dir
-     * signature                        4
-     * size of zip64 end of central
-     * directory record                 8
-     * version made by                  2
-     * version needed to extract        2
-     * number of this disk              4
-     * number of the disk with the
-     * start of the central directory   4
-     * total number of entries in the
-     * central directory on this disk   8
-     * total number of entries in
-     * the central directory            8
-     * size of the central directory    8
-     * offset of start of central
-     * directory with respect to
-     * the starting disk number         8
-     */
-    const ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_MIN_LEN = 56;
-    /**
-     * @var string|null The archive comment.
-     */
-    private $comment;
-    /**
-     * @var int The number of bytes in the preamble of this ZIP file.
-     */
-    private $preamble;
-    /**
-     * @var int The number of bytes in the postamble of this ZIP file.
-     */
-    private $postamble;
-    /**
-     * @var PositionMapper Maps offsets specified in the ZIP file to real offsets in the file.
-     */
-    private $mapper;
-    /**
-     * @var int
-     */
-    private $centralDirectoryEntriesSize;
-    /**
-     * @var bool
-     */
-    private $zip64 = false;
-    /**
-     * @var string|null
-     */
-    private $newComment;
-    /**
-     * @var bool
-     */
-    private $modified;
-
-    /**
-     * EndOfCentralDirectory constructor.
-     */
-    public function __construct()
-    {
-        $this->mapper = new PositionMapper();
-    }
-
-    /**
-     * Positions the file pointer at the first Central File Header.
-     * Performs some means to check that this is really a ZIP file.
-     *
-     * @param resource $inputStream
-     * @throws ZipException If the file is not compatible to the ZIP File
-     *         Format Specification.
-     */
-    public function findCentralDirectory($inputStream)
-    {
-        // Search for End of central directory record.
-        $stats = fstat($inputStream);
-        $size = $stats['size'];
-        $max = $size - self::END_OF_CENTRAL_DIRECTORY_RECORD_MIN_LEN;
-        $min = $max >= 0xffff ? $max - 0xffff : 0;
-        for ($endOfCentralDirRecordPos = $max; $endOfCentralDirRecordPos >= $min; $endOfCentralDirRecordPos--) {
-            fseek($inputStream, $endOfCentralDirRecordPos, SEEK_SET);
-            // end of central dir signature    4 bytes  (0x06054b50)
-            if (self::END_OF_CENTRAL_DIRECTORY_RECORD_SIG !== unpack('V', fread($inputStream, 4))[1])
-                continue;
-
-            // number of this disk                        - 2 bytes
-            // number of the disk with the start of the
-            //        central directory                   - 2 bytes
-            // total number of entries in the central
-            //        directory on this disk              - 2 bytes
-            // total number of entries in the central
-            //        directory                           - 2 bytes
-            // size of the central directory              - 4 bytes
-            // offset of start of central directory with
-            //        respect to the starting disk number - 4 bytes
-            // ZIP file comment length                    - 2 bytes
-            $data = unpack(
-                'vdiskNo/vcdDiskNo/vcdEntriesDisk/vcdEntries/VcdSize/VcdPos/vcommentLength',
-                fread($inputStream, 18)
-            );
-
-            if (0 !== $data['diskNo'] || 0 !== $data['cdDiskNo'] || $data['cdEntriesDisk'] !== $data['cdEntries']) {
-                throw new ZipException(
-                    "ZIP file spanning/splitting is not supported!"
-                );
-            }
-            // .ZIP file comment       (variable size)
-            if (0 < $data['commentLength']) {
-                $this->comment = fread($inputStream, $data['commentLength']);
-            }
-            $this->preamble = $endOfCentralDirRecordPos;
-            $this->postamble = $size - ftell($inputStream);
-
-            // Check for ZIP64 End Of Central Directory Locator.
-            $endOfCentralDirLocatorPos = $endOfCentralDirRecordPos - self::ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_LEN;
-
-            fseek($inputStream, $endOfCentralDirLocatorPos, SEEK_SET);
-            // zip64 end of central dir locator
-            // signature                       4 bytes  (0x07064b50)
-            if (
-                0 > $endOfCentralDirLocatorPos ||
-                ftell($inputStream) === $size ||
-                self::ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG !== unpack('V', fread($inputStream, 4))[1]
-            ) {
-                // Seek and check first CFH, probably requiring an offset mapper.
-                $offset = $endOfCentralDirRecordPos - $data['cdSize'];
-                fseek($inputStream, $offset, SEEK_SET);
-                $offset -= $data['cdPos'];
-                if (0 !== $offset) {
-                    $this->mapper = new OffsetPositionMapper($offset);
-                }
-                $this->centralDirectoryEntriesSize = $data['cdEntries'];
-                return;
-            }
-
-            // number of the disk with the
-            // start of the zip64 end of
-            // central directory               4 bytes
-            $zip64EndOfCentralDirectoryRecordDisk = unpack('V', fread($inputStream, 4))[1];
-            // relative offset of the zip64
-            // end of central directory record 8 bytes
-            $zip64EndOfCentralDirectoryRecordPos = PackUtil::unpackLongLE(fread($inputStream, 8));
-            // total number of disks           4 bytes
-            $totalDisks = unpack('V', fread($inputStream, 4))[1];
-            if (0 !== $zip64EndOfCentralDirectoryRecordDisk || 1 !== $totalDisks) {
-                throw new ZipException("ZIP file spanning/splitting is not supported!");
-            }
-            fseek($inputStream, $zip64EndOfCentralDirectoryRecordPos, SEEK_SET);
-            // zip64 end of central dir
-            // signature                       4 bytes  (0x06064b50)
-            $zip64EndOfCentralDirSig = unpack('V', fread($inputStream, 4))[1];
-            if (self::ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIG !== $zip64EndOfCentralDirSig) {
-                throw new ZipException("Expected ZIP64 End Of Central Directory Record!");
-            }
-            // size of zip64 end of central
-            // directory record                8 bytes
-            // version made by                 2 bytes
-            // version needed to extract       2 bytes
-            fseek($inputStream, 12, SEEK_CUR);
-            // number of this disk             4 bytes
-            $diskNo = unpack('V', fread($inputStream, 4))[1];
-            // number of the disk with the
-            // start of the central directory  4 bytes
-            $cdDiskNo = unpack('V', fread($inputStream, 4))[1];
-            // total number of entries in the
-            // central directory on this disk  8 bytes
-            $cdEntriesDisk = PackUtil::unpackLongLE(fread($inputStream, 8));
-            // total number of entries in the
-            // central directory               8 bytes
-            $cdEntries = PackUtil::unpackLongLE(fread($inputStream, 8));
-            if (0 !== $diskNo || 0 !== $cdDiskNo || $cdEntriesDisk !== $cdEntries) {
-                throw new ZipException("ZIP file spanning/splitting is not supported!");
-            }
-            if ($cdEntries < 0 || 0x7fffffff < $cdEntries) {
-                throw new ZipException("Total Number Of Entries In The Central Directory out of range!");
-            }
-            // size of the central directory   8 bytes
-            fseek($inputStream, 8, SEEK_CUR);
-            // offset of start of central
-            // directory with respect to
-            // the starting disk number        8 bytes
-            $cdPos = PackUtil::unpackLongLE(fread($inputStream, 8));
-            // zip64 extensible data sector    (variable size)
-            fseek($inputStream, $cdPos, SEEK_SET);
-            $this->preamble = $zip64EndOfCentralDirectoryRecordPos;
-            $this->centralDirectoryEntriesSize = $cdEntries;
-            $this->zip64 = true;
-            return;
-        }
-        // Start recovering file entries from min.
-        $this->preamble = $min;
-        $this->postamble = $size - $min;
-        $this->centralDirectoryEntriesSize = 0;
-    }
-
-    /**
-     * @return null|string
-     */
-    public function getComment()
-    {
-        return $this->comment;
-    }
-
-    /**
-     * @return int
-     */
-    public function getCentralDirectoryEntriesSize()
-    {
-        return $this->centralDirectoryEntriesSize;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isZip64()
-    {
-        return $this->zip64;
-    }
-
-    /**
-     * @return int
-     */
-    public function getPreamble()
-    {
-        return $this->preamble;
-    }
-
-    /**
-     * @return int
-     */
-    public function getPostamble()
-    {
-        return $this->postamble;
-    }
-
-    /**
-     * @return PositionMapper
-     */
-    public function getMapper()
-    {
-        return $this->mapper;
-    }
-
-    /**
-     * @param int $preamble
-     */
-    public function setPreamble($preamble)
-    {
-        $this->preamble = $preamble;
-    }
-
-    /**
-     * Set archive comment
-     * @param string|null $comment
-     * @throws InvalidArgumentException
-     */
-    public function setComment($comment = null)
-    {
-        if (null !== $comment && strlen($comment) !== 0) {
-            $comment = (string)$comment;
-            $length = strlen($comment);
-            if (0x0000 > $length || $length > 0xffff) {
-                throw new InvalidArgumentException('Length comment out of range');
-            }
-        }
-        $this->modified = $comment !== $this->comment;
-        $this->newComment = $comment;
-    }
-
-    /**
-     * Write end of central directory.
-     *
-     * @param resource $outputStream Output stream
-     * @param int $centralDirectoryEntries Size entries
-     * @param int $centralDirectoryOffset Offset central directory
-     */
-    public function writeEndOfCentralDirectory($outputStream, $centralDirectoryEntries, $centralDirectoryOffset)
-    {
-        $position = ftell($outputStream);
-        $centralDirectorySize = $position - $centralDirectoryOffset;
-        $centralDirectoryEntriesZip64 = $centralDirectoryEntries > 0xffff;
-        $centralDirectorySizeZip64 = $centralDirectorySize > 0xffffffff;
-        $centralDirectoryOffsetZip64 = $centralDirectoryOffset > 0xffffffff;
-        $centralDirectoryEntries16 = $centralDirectoryEntriesZip64 ? 0xffff : (int)$centralDirectoryEntries;
-        $centralDirectorySize32 = $centralDirectorySizeZip64 ? 0xffffffff : $centralDirectorySize;
-        $centralDirectoryOffset32 = $centralDirectoryOffsetZip64 ? 0xffffffff : $centralDirectoryOffset;
-        $zip64 // ZIP64 extensions?
-            = $centralDirectoryEntriesZip64
-            || $centralDirectorySizeZip64
-            || $centralDirectoryOffsetZip64;
-        if ($zip64) {
-            // relative offset of the zip64 end of central directory record
-            $zip64EndOfCentralDirectoryOffset = $position;
-            // zip64 end of central dir
-            // signature                       4 bytes  (0x06064b50)
-            fwrite($outputStream, pack('V', self::ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_SIG));
-            // size of zip64 end of central
-            // directory record                8 bytes
-            fwrite($outputStream, PackUtil::packLongLE(self::ZIP64_END_OF_CENTRAL_DIRECTORY_RECORD_MIN_LEN - 12));
-            // version made by                 2 bytes
-            // version needed to extract       2 bytes
-            //                                 due to potential use of BZIP2 compression
-            // number of this disk             4 bytes
-            // number of the disk with the
-            // start of the central directory  4 bytes
-            fwrite($outputStream, pack('vvVV', 63, 46, 0, 0));
-            // total number of entries in the
-            // central directory on this disk  8 bytes
-            fwrite($outputStream, PackUtil::packLongLE($centralDirectoryEntries));
-            // total number of entries in the
-            // central directory               8 bytes
-            fwrite($outputStream, PackUtil::packLongLE($centralDirectoryEntries));
-            // size of the central directory   8 bytes
-            fwrite($outputStream, PackUtil::packLongLE($centralDirectorySize));
-            // offset of start of central
-            // directory with respect to
-            // the starting disk number        8 bytes
-            fwrite($outputStream, PackUtil::packLongLE($centralDirectoryOffset));
-            // zip64 extensible data sector    (variable size)
-            //
-            // zip64 end of central dir locator
-            // signature                       4 bytes  (0x07064b50)
-            // number of the disk with the
-            // start of the zip64 end of
-            // central directory               4 bytes
-            fwrite($outputStream, pack('VV', self::ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG, 0));
-            // relative offset of the zip64
-            // end of central directory record 8 bytes
-            fwrite($outputStream, PackUtil::packLongLE($zip64EndOfCentralDirectoryOffset));
-            // total number of disks           4 bytes
-            fwrite($outputStream, pack('V', 1));
-        }
-        $comment = $this->modified ? $this->newComment : $this->comment;
-        $commentLength = strlen($comment);
-        fwrite(
-            $outputStream,
-            pack('VvvvvVVv',
-                // end of central dir signature    4 bytes  (0x06054b50)
-                self::END_OF_CENTRAL_DIRECTORY_RECORD_SIG,
-                // number of this disk             2 bytes
-                0,
-                // number of the disk with the
-                // start of the central directory  2 bytes
-                0,
-                // total number of entries in the
-                // central directory on this disk  2 bytes
-                $centralDirectoryEntries16,
-                // total number of entries in
-                // the central directory           2 bytes
-                $centralDirectoryEntries16,
-                // size of the central directory   4 bytes
-                $centralDirectorySize32,
-                // offset of start of central
-                // directory with respect to
-                // the starting disk number        4 bytes
-                $centralDirectoryOffset32,
-                // .ZIP file comment length        2 bytes
-                $commentLength
-            )
-        );
-        if ($commentLength > 0) {
-            // .ZIP file comment       (variable size)
-            fwrite($outputStream, $comment);
-        }
-    }
-
-}
--- a/src/PhpZip/Model/Entry/ZipAbstractEntry.php
+++ b/src/PhpZip/Model/Entry/ZipAbstractEntry.php
@@ -1,953 +0,0 @@
-<?php
-
-namespace PhpZip\Model\Entry;
-
-use PhpZip\Exception\InvalidArgumentException;
-use PhpZip\Exception\ZipException;
-use PhpZip\Extra\DefaultExtraField;
-use PhpZip\Extra\ExtraField;
-use PhpZip\Extra\ExtraFields;
-use PhpZip\Extra\WinZipAesEntryExtraField;
-use PhpZip\Model\CentralDirectory;
-use PhpZip\Model\ZipEntry;
-use PhpZip\Util\DateTimeConverter;
-use PhpZip\Util\PackUtil;
-use PhpZip\ZipFile;
-
-/**
- * Abstract ZIP entry.
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-abstract class ZipAbstractEntry implements ZipEntry
-{
-    /**
-     * @var CentralDirectory
-     */
-    private $centralDirectory;
-
-    /**
-     * @var int Bit flags for init state.
-     */
-    private $init;
-
-    /**
-     * @var string Entry name (filename in archive)
-     */
-    private $name;
-    /**
-     * @var int Made by platform
-     */
-    private $platform;
-    /**
-     * @var int
-     */
-    private $versionNeededToExtract = 20;
-    /**
-     * @var int
-     */
-    private $general;
-    /**
-     * @var int Compression method
-     */
-    private $method;
-    /**
-     * @var int Dos time
-     */
-    private $dosTime;
-    /**
-     * @var int Crc32
-     */
-    private $crc;
-    /**
-     * @var int Compressed size
-     */
-    private $compressedSize = self::UNKNOWN;
-    /**
-     * @var int Uncompressed size
-     */
-    private $size = self::UNKNOWN;
-    /**
-     * @var int External attributes
-     */
-    private $externalAttributes;
-    /**
-     * @var int Relative Offset Of Local File Header.
-     */
-    private $offset = self::UNKNOWN;
-    /**
-     * The map of Extra Fields.
-     * Maps from Header ID [Integer] to Extra Field [ExtraField].
-     * Should be null or may be empty if no Extra Fields are used.
-     *
-     * @var ExtraFields
-     */
-    private $fields;
-    /**
-     * @var string Comment field.
-     */
-    private $comment;
-    /**
-     * @var string Entry password for read or write encryption data.
-     */
-    private $password;
-    /**
-     * Encryption method.
-     * @see ZipFile::ENCRYPTION_METHOD_TRADITIONAL
-     * @see ZipFile::ENCRYPTION_METHOD_WINZIP_AES
-     * @var int
-     */
-    private $encryptionMethod = ZipFile::ENCRYPTION_METHOD_TRADITIONAL;
-
-    /**
-     * @var int
-     */
-    private $compressionLevel = ZipFile::LEVEL_DEFAULT_COMPRESSION;
-
-    /**
-     * @param int $mask
-     * @return bool
-     */
-    private function isInit($mask)
-    {
-        return 0 !== ($this->init & $mask);
-    }
-
-    /**
-     * @param int $mask
-     * @param bool $init
-     */
-    private function setInit($mask, $init)
-    {
-        if ($init) {
-            $this->init |= $mask;
-        } else {
-            $this->init &= ~$mask;
-        }
-    }
-
-    /**
-     * @return CentralDirectory
-     */
-    public function getCentralDirectory()
-    {
-        return $this->centralDirectory;
-    }
-
-    /**
-     * @param CentralDirectory $centralDirectory
-     * @return ZipEntry
-     */
-    public function setCentralDirectory(CentralDirectory $centralDirectory)
-    {
-        $this->centralDirectory = $centralDirectory;
-        return $this;
-    }
-
-    /**
-     * Returns the ZIP entry name.
-     *
-     * @return string
-     */
-    public function getName()
-    {
-        return $this->name;
-    }
-
-    /**
-     * Set entry name.
-     *
-     * @param string $name New entry name
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setName($name)
-    {
-        $length = strlen($name);
-        if (0x0000 > $length || $length > 0xffff) {
-            throw new ZipException('Illegal zip entry name parameter');
-        }
-        $this->setGeneralPurposeBitFlag(self::GPBF_UTF8, true);
-        $this->name = $name;
-        return $this;
-    }
-
-    /**
-     * @return int Get platform
-     */
-    public function getPlatform()
-    {
-        return $this->isInit(self::BIT_PLATFORM) ? $this->platform & 0xffff : self::UNKNOWN;
-    }
-
-    /**
-     * Set platform
-     *
-     * @param int $platform
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setPlatform($platform)
-    {
-        $known = self::UNKNOWN !== $platform;
-        if ($known) {
-            if (0x00 > $platform || $platform > 0xff) {
-                throw new ZipException("Platform out of range");
-            }
-            $this->platform = $platform;
-        } else {
-            $this->platform = 0;
-        }
-        $this->setInit(self::BIT_PLATFORM, $known);
-        return $this;
-    }
-
-    /**
-     * Version needed to extract.
-     *
-     * @return int
-     */
-    public function getVersionNeededToExtract()
-    {
-        return $this->versionNeededToExtract;
-    }
-
-    /**
-     * Set version needed to extract.
-     *
-     * @param int $version
-     * @return ZipEntry
-     */
-    public function setVersionNeededToExtract($version)
-    {
-        $this->versionNeededToExtract = $version;
-        return $this;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isZip64ExtensionsRequired()
-    {
-        // Offset MUST be considered in decision about ZIP64 format - see
-        // description of Data Descriptor in ZIP File Format Specification!
-        return 0xffffffff <= $this->getCompressedSize()
-            || 0xffffffff <= $this->getSize()
-            || 0xffffffff <= $this->getOffset();
-    }
-
-    /**
-     * Returns the compressed size of this entry.
-     *
-     * @see int
-     */
-    public function getCompressedSize()
-    {
-        return $this->compressedSize;
-    }
-
-    /**
-     * Sets the compressed size of this entry.
-     *
-     * @param int $compressedSize The Compressed Size.
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setCompressedSize($compressedSize)
-    {
-        if (self::UNKNOWN != $compressedSize) {
-            $compressedSize = sprintf('%u', $compressedSize);
-            if (0 > $compressedSize || $compressedSize > 0x7fffffffffffffff) {
-                throw new ZipException("Compressed size out of range - " . $this->name);
-            }
-        }
-        $this->compressedSize = $compressedSize;
-        return $this;
-    }
-
-    /**
-     * Returns the uncompressed size of this entry.
-     *
-     * @see ZipEntry::setCompressedSize
-     */
-    public function getSize()
-    {
-        return $this->size;
-    }
-
-    /**
-     * Sets the uncompressed size of this entry.
-     *
-     * @param int $size The (Uncompressed) Size.
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setSize($size)
-    {
-        if (self::UNKNOWN != $size) {
-            $size = sprintf('%u', $size);
-            if (0 > $size || $size > 0x7fffffffffffffff) {
-                throw new ZipException("Uncompressed Size out of range - " . $this->name);
-            }
-        }
-        $this->size = $size;
-        return $this;
-    }
-
-    /**
-     * Return relative Offset Of Local File Header.
-     *
-     * @return int
-     */
-    public function getOffset()
-    {
-        return $this->offset;
-    }
-
-    /**
-     * @param int $offset
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setOffset($offset)
-    {
-        $offset = sprintf('%u', $offset);
-        if (0 > $offset || $offset > 0x7fffffffffffffff) {
-            throw new ZipException("Offset out of range - " . $this->name);
-        }
-        $this->offset = $offset;
-        return $this;
-    }
-
-    /**
-     * Returns true if and only if this ZIP entry represents a directory entry
-     * (i.e. end with '/').
-     *
-     * @return bool
-     */
-    public function isDirectory()
-    {
-        return $this->name[strlen($this->name) - 1] === '/';
-    }
-
-    /**
-     * Returns the General Purpose Bit Flags.
-     *
-     * @return bool
-     */
-    public function getGeneralPurposeBitFlags()
-    {
-        return $this->general & 0xffff;
-    }
-
-    /**
-     * Sets the General Purpose Bit Flags.
-     *
-     * @var int general
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setGeneralPurposeBitFlags($general)
-    {
-        if (0x0000 > $general || $general > 0xffff) {
-            throw new ZipException('general out of range');
-        }
-        $this->general = $general;
-        return $this;
-    }
-
-    /**
-     * Returns the indexed General Purpose Bit Flag.
-     *
-     * @param int $mask
-     * @return bool
-     */
-    public function getGeneralPurposeBitFlag($mask)
-    {
-        return 0 !== ($this->general & $mask);
-    }
-
-    /**
-     * Sets the indexed General Purpose Bit Flag.
-     *
-     * @param int $mask
-     * @param bool $bit
-     * @return ZipEntry
-     */
-    public function setGeneralPurposeBitFlag($mask, $bit)
-    {
-        if ($bit)
-            $this->general |= $mask;
-        else
-            $this->general &= ~$mask;
-        return $this;
-    }
-
-    /**
-     * Returns true if and only if this ZIP entry is encrypted.
-     *
-     * @return bool
-     */
-    public function isEncrypted()
-    {
-        return $this->getGeneralPurposeBitFlag(self::GPBF_ENCRYPTED);
-    }
-
-    /**
-     * Sets the encryption property to false and removes any other
-     * encryption artifacts.
-     *
-     * @return ZipEntry
-     */
-    public function clearEncryption()
-    {
-        $this->setEncrypted(false);
-        if (null !== $this->fields) {
-            $field = $this->fields->get(WinZipAesEntryExtraField::getHeaderId());
-            if (null !== $field) {
-                /**
-                 * @var WinZipAesEntryExtraField $field
-                 */
-                $this->removeExtraField(WinZipAesEntryExtraField::getHeaderId());
-            }
-            if (self::METHOD_WINZIP_AES === $this->getMethod()) {
-                $this->setMethod(null === $field ? self::UNKNOWN : $field->getMethod());
-            }
-        }
-        $this->password = null;
-        return $this;
-    }
-
-    /**
-     * Sets the encryption flag for this ZIP entry.
-     *
-     * @param bool $encrypted
-     * @return ZipEntry
-     */
-    public function setEncrypted($encrypted)
-    {
-        $this->setGeneralPurposeBitFlag(self::GPBF_ENCRYPTED, $encrypted);
-        return $this;
-    }
-
-    /**
-     * Returns the compression method for this entry.
-     *
-     * @return int
-     */
-    public function getMethod()
-    {
-        return $this->isInit(self::BIT_METHOD) ? $this->method & 0xffff : self::UNKNOWN;
-    }
-
-    /**
-     * Sets the compression method for this entry.
-     *
-     * @param int $method
-     * @return ZipEntry
-     * @throws ZipException If method is not STORED, DEFLATED, BZIP2 or UNKNOWN.
-     */
-    public function setMethod($method)
-    {
-        if (0x0000 > $method || $method > 0xffff) {
-            throw new ZipException('method out of range');
-        }
-        switch ($method) {
-            case self::METHOD_WINZIP_AES:
-                $this->method = $method;
-                $this->setInit(self::BIT_METHOD, true);
-                $this->setEncryptionMethod(ZipFile::ENCRYPTION_METHOD_WINZIP_AES);
-                break;
-
-            case ZipFile::METHOD_STORED:
-            case ZipFile::METHOD_DEFLATED:
-            case ZipFile::METHOD_BZIP2:
-                $this->method = $method;
-                $this->setInit(self::BIT_METHOD, true);
-                break;
-
-            case self::UNKNOWN:
-                $this->method = ZipFile::METHOD_STORED;
-                $this->setInit(self::BIT_METHOD, false);
-                break;
-
-            default:
-                throw new ZipException($this->name . " (unsupported compression method $method)");
-        }
-        return $this;
-    }
-
-    /**
-     * Get Unix Timestamp
-     *
-     * @return int
-     */
-    public function getTime()
-    {
-        if (!$this->isInit(self::BIT_DATE_TIME)) {
-            return self::UNKNOWN;
-        }
-        return DateTimeConverter::toUnixTimestamp($this->getDosTime());
-    }
-
-    /**
-     * Set time from unix timestamp.
-     *
-     * @param int $unixTimestamp
-     * @return ZipEntry
-     */
-    public function setTime($unixTimestamp)
-    {
-        $known = self::UNKNOWN != $unixTimestamp;
-        if ($known) {
-            $this->dosTime = DateTimeConverter::toDosTime($unixTimestamp);
-        } else {
-            $this->dosTime = 0;
-        }
-        $this->setInit(self::BIT_DATE_TIME, $known);
-        return $this;
-    }
-
-    /**
-     * Get Dos Time
-     *
-     * @return int
-     */
-    public function getDosTime()
-    {
-        return $this->dosTime & 0xffffffff;
-    }
-
-    /**
-     * Set Dos Time
-     * @param int $dosTime
-     * @throws ZipException
-     */
-    public function setDosTime($dosTime)
-    {
-        $dosTime = sprintf('%u', $dosTime);
-        if (0x00000000 > $dosTime || $dosTime > 0xffffffff) {
-            throw new ZipException('DosTime out of range');
-        }
-        $this->dosTime = $dosTime;
-        $this->setInit(self::BIT_DATE_TIME, true);
-    }
-
-    /**
-     * Returns the external file attributes.
-     *
-     * @return int The external file attributes.
-     */
-    public function getExternalAttributes()
-    {
-        if (!$this->isInit(self::BIT_EXTERNAL_ATTR)) {
-            return $this->isDirectory() ? 0x10 : 0;
-        }
-        return $this->externalAttributes & 0xffffffff;
-    }
-
-    /**
-     * Sets the external file attributes.
-     *
-     * @param int $externalAttributes the external file attributes.
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setExternalAttributes($externalAttributes)
-    {
-        $known = self::UNKNOWN != $externalAttributes;
-        if ($known) {
-            $externalAttributes = sprintf('%u', $externalAttributes);
-            if (0x00000000 > $externalAttributes || $externalAttributes > 0xffffffff) {
-                throw new ZipException("external file attributes out of range - " . $this->name);
-            }
-            $this->externalAttributes = $externalAttributes;
-        } else {
-            $this->externalAttributes = 0;
-        }
-        $this->setInit(self::BIT_EXTERNAL_ATTR, $known);
-        return $this;
-    }
-
-    /**
-     * Return extra field from header id.
-     *
-     * @param int $headerId
-     * @return ExtraField|null
-     */
-    public function getExtraField($headerId)
-    {
-        return $this->fields === null ? null : $this->fields->get($headerId);
-    }
-
-    /**
-     * Add extra field.
-     *
-     * @param ExtraField $field
-     * @return ExtraField
-     * @throws ZipException
-     */
-    public function addExtraField($field)
-    {
-        if (null === $field) {
-            throw new ZipException("extra field null");
-        }
-        if (null === $this->fields) {
-            $this->fields = new ExtraFields();
-        }
-        return $this->fields->add($field);
-    }
-
-    /**
-     * Return exists extra field from header id.
-     *
-     * @param int $headerId
-     * @return bool
-     */
-    public function hasExtraField($headerId)
-    {
-        return $this->fields === null ? false : $this->fields->has($headerId);
-    }
-
-    /**
-     * Remove extra field from header id.
-     *
-     * @param int $headerId
-     * @return ExtraField|null
-     */
-    public function removeExtraField($headerId)
-    {
-        return null !== $this->fields ? $this->fields->remove($headerId) : null;
-    }
-
-    /**
-     * Returns a protective copy of the serialized Extra Fields.
-     *
-     * @return string A new byte array holding the serialized Extra Fields.
-     *                null is never returned.
-     */
-    public function getExtra()
-    {
-        return $this->getExtraFields(false);
-    }
-
-    /**
-     * @param bool $zip64
-     * @return string
-     * @throws ZipException
-     */
-    private function getExtraFields($zip64)
-    {
-        if ($zip64) {
-            $field = $this->composeZip64ExtraField();
-            if (null !== $field) {
-                if (null === $this->fields) {
-                    $this->fields = new ExtraFields();
-                }
-                $this->fields->add($field);
-            }
-        } else {
-            assert(null === $this->fields || null === $this->fields->get(ExtraField::ZIP64_HEADER_ID));
-        }
-        return null === $this->fields ? null : $this->fields->getExtra();
-    }
-
-    /**
-     * Composes a ZIP64 Extended Information Extra Field from the properties
-     * of this entry.
-     * If no ZIP64 Extended Information Extra Field is required it is removed
-     * from the collection of Extra Fields.
-     *
-     * @return ExtraField|null
-     */
-    private function composeZip64ExtraField()
-    {
-        $handle = fopen('php://memory', 'r+b');
-        // Write out Uncompressed Size.
-        $size = $this->getSize();
-        if (0xffffffff <= $size) {
-            fwrite($handle, PackUtil::packLongLE($size));
-        }
-        // Write out Compressed Size.
-        $compressedSize = $this->getCompressedSize();
-        if (0xffffffff <= $compressedSize) {
-            fwrite($handle, PackUtil::packLongLE($compressedSize));
-        }
-        // Write out Relative Header Offset.
-        $offset = $this->getOffset();
-        if (0xffffffff <= $offset) {
-            fwrite($handle, PackUtil::packLongLE($offset));
-        }
-        // Create ZIP64 Extended Information Extra Field from serialized data.
-        $field = null;
-        if (ftell($handle) > 0) {
-            $field = new DefaultExtraField(ExtraField::ZIP64_HEADER_ID);
-            $field->readFrom($handle, 0, ftell($handle));
-        } else {
-            $field = null;
-        }
-        return $field;
-    }
-
-    /**
-     * Sets the serialized Extra Fields by making a protective copy.
-     * Note that this method parses the serialized Extra Fields according to
-     * the ZIP File Format Specification and limits its size to 64 KB.
-     * Therefore, this property cannot not be used to hold arbitrary
-     * (application) data.
-     * Consider storing such data in a separate entry instead.
-     *
-     * @param string $data The byte array holding the serialized Extra Fields.
-     * @throws ZipException if the serialized Extra Fields exceed 64 KB
-     * @return ZipEntry
-     *         or do not conform to the ZIP File Format Specification
-     */
-    public function setExtra($data)
-    {
-        if (null !== $data) {
-            $length = strlen($data);
-            if (0x0000 > $length || $length > 0xffff) {
-                throw new ZipException("Extra Fields too large");
-            }
-        }
-        if (null === $data || strlen($data) <= 0) {
-            $this->fields = null;
-        } else {
-            $this->setExtraFields($data, false);
-        }
-        return $this;
-    }
-
-    /**
-     * @param string $data
-     * @param bool $zip64
-     */
-    private function setExtraFields($data, $zip64)
-    {
-        if (null === $this->fields) {
-            $this->fields = new ExtraFields();
-        }
-        $handle = fopen('php://memory', 'r+b');
-        fwrite($handle, $data);
-        rewind($handle);
-
-        $this->fields->readFrom($handle, 0, strlen($data));
-        $result = false;
-        if ($zip64) {
-            $result = $this->parseZip64ExtraField();
-        }
-        if ($result) {
-            $this->fields->remove(ExtraField::ZIP64_HEADER_ID);
-            if ($this->fields->size() <= 0) {
-                if (0 !== $this->fields->size()) {
-                    $this->fields = null;
-                }
-            }
-        }
-        fclose($handle);
-    }
-
-    /**
-     * Parses the properties of this entry from the ZIP64 Extended Information
-     * Extra Field, if present.
-     * The ZIP64 Extended Information Extra Field is not removed.
-     *
-     * @return bool
-     * @throws ZipException
-     */
-    private function parseZip64ExtraField()
-    {
-        if (null === $this->fields) {
-            return false;
-        }
-        $ef = $this->fields->get(ExtraField::ZIP64_HEADER_ID);
-        if (null === $ef) {
-            return false;
-        }
-        $dataBlockHandle = $ef->getDataBlock();
-        $off = 0;
-        // Read in Uncompressed Size.
-        $size = $this->getSize();
-        if (0xffffffff <= $size) {
-            assert(0xffffffff === $size);
-            fseek($dataBlockHandle, $off);
-            $this->setSize(PackUtil::unpackLongLE(fread($dataBlockHandle, 8)));
-            $off += 8;
-        }
-        // Read in Compressed Size.
-        $compressedSize = $this->getCompressedSize();
-        if (0xffffffff <= $compressedSize) {
-            assert(0xffffffff === $compressedSize);
-            fseek($dataBlockHandle, $off);
-            $this->setCompressedSize(PackUtil::unpackLongLE(fread($dataBlockHandle, 8)));
-            $off += 8;
-        }
-        // Read in Relative Header Offset.
-        $offset = $this->getOffset();
-        if (0xffffffff <= $offset) {
-            assert(0xffffffff, $offset);
-            fseek($dataBlockHandle, $off);
-            $this->setOffset(PackUtil::unpackLongLE(fread($dataBlockHandle, 8)));
-            //$off += 8;
-        }
-        fclose($dataBlockHandle);
-        return true;
-    }
-
-    /**
-     * Returns comment entry
-     *
-     * @return string
-     */
-    public function getComment()
-    {
-        return null != $this->comment ? $this->comment : "";
-    }
-
-    /**
-     * Set entry comment.
-     *
-     * @param $comment
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setComment($comment)
-    {
-        if (null !== $comment) {
-            $commentLength = strlen($comment);
-            if (0x0000 > $commentLength || $commentLength > 0xffff) {
-                throw new ZipException("Comment too long");
-            }
-        }
-        $this->setGeneralPurposeBitFlag(self::GPBF_UTF8, true);
-        $this->comment = $comment;
-        return $this;
-    }
-
-    /**
-     * @return bool
-     */
-    public function isDataDescriptorRequired()
-    {
-        return self::UNKNOWN == ($this->getCrc() | $this->getCompressedSize() | $this->getSize());
-    }
-
-    /**
-     * Return crc32 content or 0 for WinZip AES v2
-     *
-     * @return int
-     */
-    public function getCrc()
-    {
-        return $this->crc & 0xffffffff;
-    }
-
-    /**
-     * Set crc32 content.
-     *
-     * @param int $crc
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setCrc($crc)
-    {
-        $crc = sprintf('%u', $crc);
-        if (0x00000000 > $crc || $crc > 0xffffffff) {
-            throw new ZipException("CRC-32 out of range - " . $this->name);
-        }
-        $this->crc = $crc;
-        $this->setInit(self::BIT_CRC, true);
-        return $this;
-    }
-
-    /**
-     * @return string
-     */
-    public function getPassword()
-    {
-        return $this->password;
-    }
-
-    /**
-     * Set password and encryption method from entry
-     *
-     * @param string $password
-     * @param null|int $encryptionMethod
-     * @return ZipEntry
-     */
-    public function setPassword($password, $encryptionMethod = null)
-    {
-        $this->password = $password;
-        if (null !== $encryptionMethod) {
-            $this->setEncryptionMethod($encryptionMethod);
-        }
-        $this->setEncrypted(!empty($this->password));
-        return $this;
-    }
-
-    /**
-     * @return int
-     */
-    public function getEncryptionMethod()
-    {
-        return $this->encryptionMethod;
-    }
-
-    /**
-     * @return int
-     */
-    public function getCompressionLevel()
-    {
-        return $this->compressionLevel;
-    }
-
-    /**
-     * @param int $compressionLevel
-     * @return ZipEntry
-     * @throws InvalidArgumentException
-     */
-    public function setCompressionLevel($compressionLevel = ZipFile::LEVEL_DEFAULT_COMPRESSION)
-    {
-        if ($compressionLevel < ZipFile::LEVEL_DEFAULT_COMPRESSION ||
-            $compressionLevel > ZipFile::LEVEL_BEST_COMPRESSION
-        ) {
-            throw new InvalidArgumentException('Invalid compression level. Minimum level ' .
-                ZipFile::LEVEL_DEFAULT_COMPRESSION . '. Maximum level ' . ZipFile::LEVEL_BEST_COMPRESSION);
-        }
-        $this->compressionLevel = $compressionLevel;
-        return $this;
-    }
-
-    /**
-     * Set encryption method
-     *
-     * @see ZipFile::ENCRYPTION_METHOD_TRADITIONAL
-     * @see ZipFile::ENCRYPTION_METHOD_WINZIP_AES
-     *
-     * @param int $encryptionMethod
-     * @return ZipEntry
-     * @throws ZipException
-     */
-    public function setEncryptionMethod($encryptionMethod)
-    {
-        if (
-            ZipFile::ENCRYPTION_METHOD_TRADITIONAL !== $encryptionMethod &&
-            ZipFile::ENCRYPTION_METHOD_WINZIP_AES !== $encryptionMethod
-        ) {
-            throw new ZipException('Invalid encryption method');
-        }
-        $this->encryptionMethod = $encryptionMethod;
-        $this->setEncrypted(true);
-        return $this;
-    }
-
-    /**
-     * Clone extra fields
-     */
-    function __clone()
-    {
-        $this->fields = $this->fields !== null ? clone $this->fields : null;
-    }
-}
--- a/src/PhpZip/Model/Entry/ZipNewEmptyDirEntry.php
+++ b/src/PhpZip/Model/Entry/ZipNewEmptyDirEntry.php
@@ -1,26 +0,0 @@
-<?php
-namespace PhpZip\Model\Entry;
-
-use PhpZip\Exception\ZipException;
-
-/**
- * New zip entry from empty dir.
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class ZipNewEmptyDirEntry extends ZipNewEntry
-{
-
-    /**
-     * Returns an string content of the given entry.
-     *
-     * @return null|string
-     * @throws ZipException
-     */
-    public function getEntryContent()
-    {
-        return null;
-    }
-}
--- a/src/PhpZip/Model/Entry/ZipNewEntry.php
+++ b/src/PhpZip/Model/Entry/ZipNewEntry.php
@@ -1,268 +0,0 @@
-<?php
-namespace PhpZip\Model\Entry;
-
-use PhpZip\Crypto\TraditionalPkwareEncryptionEngine;
-use PhpZip\Crypto\WinZipAesEngine;
-use PhpZip\Exception\ZipException;
-use PhpZip\Extra\WinZipAesEntryExtraField;
-use PhpZip\Model\ZipEntry;
-use PhpZip\Util\PackUtil;
-use PhpZip\ZipFile;
-
-/**
- * Abstract class for new zip entry.
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-abstract class ZipNewEntry extends ZipAbstractEntry
-{
-    /**
-     * Default compression level for bzip2
-     */
-    const LEVEL_DEFAULT_BZIP2_COMPRESSION = 4;
-
-    /**
-     * Version needed to extract.
-     *
-     * @return int
-     */
-    public function getVersionNeededToExtract()
-    {
-        $method = $this->getMethod();
-        return self::METHOD_WINZIP_AES === $method ? 51 :
-            (ZipFile::METHOD_BZIP2 === $method ? 46 :
-                ($this->isZip64ExtensionsRequired() ? 45 :
-                    (ZipFile::METHOD_DEFLATED === $method || $this->isDirectory() ? 20 : 10)
-                )
-            );
-    }
-
-    /**
-     * Write local file header, encryption header, file data and data descriptor to output stream.
-     *
-     * @param resource $outputStream
-     * @throws ZipException
-     */
-    public function writeEntry($outputStream)
-    {
-        $nameLength = strlen($this->getName());
-        $size = $nameLength + strlen($this->getExtra()) + strlen($this->getComment());
-        if (0xffff < $size) {
-            throw new ZipException($this->getName()
-                . " (the total size of "
-                . $size
-                . " bytes for the name, extra fields and comment exceeds the maximum size of "
-                . 0xffff . " bytes)");
-        }
-
-        if (self::UNKNOWN === $this->getPlatform()) {
-            $this->setPlatform(self::PLATFORM_UNIX);
-        }
-        if (self::UNKNOWN === $this->getTime()) {
-            $this->setTime(time());
-        }
-        $method = $this->getMethod();
-        if (self::UNKNOWN === $method) {
-            $this->setMethod($method = ZipFile::METHOD_DEFLATED);
-        }
-        $skipCrc = false;
-
-        $encrypted = $this->isEncrypted();
-        $dd = $this->isDataDescriptorRequired();
-        // Compose General Purpose Bit Flag.
-        // See appendix D of PKWARE's ZIP File Format Specification.
-        $utf8 = true;
-        $general = ($encrypted ? self::GPBF_ENCRYPTED : 0)
-            | ($dd ? self::GPBF_DATA_DESCRIPTOR : 0)
-            | ($utf8 ? self::GPBF_UTF8 : 0);
-
-        $entryContent = $this->getEntryContent();
-
-        $this->setSize(strlen($entryContent));
-        $this->setCrc(crc32($entryContent));
-
-        if ($encrypted && null === $this->getPassword()) {
-            throw new ZipException("Can not password from entry " . $this->getName());
-        }
-
-        if (
-            $encrypted &&
-            (
-                self::METHOD_WINZIP_AES === $method ||
-                $this->getEncryptionMethod() === ZipFile::ENCRYPTION_METHOD_WINZIP_AES
-            )
-        ) {
-            $field = null;
-            $method = $this->getMethod();
-            $keyStrength = 256; // bits
-
-            $compressedSize = $this->getCompressedSize();
-
-            if (self::METHOD_WINZIP_AES === $method) {
-                /**
-                 * @var WinZipAesEntryExtraField $field
-                 */
-                $field = $this->getExtraField(WinZipAesEntryExtraField::getHeaderId());
-                if (null !== $field) {
-                    $method = $field->getMethod();
-                    if (self::UNKNOWN !== $compressedSize) {
-                        $compressedSize -= $field->getKeyStrength() / 2 // salt value
-                            + 2   // password verification value
-                            + 10; // authentication code
-                    }
-                    $this->setMethod($method);
-                }
-            }
-            if (null === $field) {
-                $field = new WinZipAesEntryExtraField();
-            }
-            $field->setKeyStrength($keyStrength);
-            $field->setMethod($method);
-            $size = $this->getSize();
-            if (20 <= $size && ZipFile::METHOD_BZIP2 !== $method) {
-                $field->setVendorVersion(WinZipAesEntryExtraField::VV_AE_1);
-            } else {
-                $field->setVendorVersion(WinZipAesEntryExtraField::VV_AE_2);
-                $skipCrc = true;
-            }
-            $this->addExtraField($field);
-            if (self::UNKNOWN !== $compressedSize) {
-                $compressedSize += $field->getKeyStrength() / 2 // salt value
-                    + 2   // password verification value
-                    + 10; // authentication code
-                $this->setCompressedSize($compressedSize);
-            }
-            if ($skipCrc) {
-                $this->setCrc(0);
-            }
-        }
-
-        switch ($method) {
-            case ZipFile::METHOD_STORED:
-                break;
-            case ZipFile::METHOD_DEFLATED:
-                $entryContent = gzdeflate($entryContent, $this->getCompressionLevel());
-                break;
-            case ZipFile::METHOD_BZIP2:
-                $compressionLevel = $this->getCompressionLevel() === ZipFile::LEVEL_DEFAULT_COMPRESSION ?
-                    self::LEVEL_DEFAULT_BZIP2_COMPRESSION :
-                    $this->getCompressionLevel();
-                $entryContent = bzcompress($entryContent, $compressionLevel);
-                if (is_int($entryContent)) {
-                    throw new ZipException('Error bzip2 compress. Error code: ' . $entryContent);
-                }
-                break;
-            default:
-                throw new ZipException($this->getName() . " (unsupported compression method " . $method . ")");
-        }
-
-        if ($encrypted) {
-            if ($this->getEncryptionMethod() === ZipFile::ENCRYPTION_METHOD_WINZIP_AES) {
-                if ($skipCrc) {
-                    $this->setCrc(0);
-                }
-                $this->setMethod(self::METHOD_WINZIP_AES);
-
-                /**
-                 * @var WinZipAesEntryExtraField $field
-                 */
-                $field = $this->getExtraField(WinZipAesEntryExtraField::getHeaderId());
-                $winZipAesEngine = new WinZipAesEngine($this, $field);
-                $entryContent = $winZipAesEngine->encrypt($entryContent);
-            } elseif ($this->getEncryptionMethod() === ZipFile::ENCRYPTION_METHOD_TRADITIONAL) {
-                $zipCryptoEngine = new TraditionalPkwareEncryptionEngine($this);
-                $entryContent = $zipCryptoEngine->encrypt($entryContent);
-            }
-        }
-
-        $compressedSize = strlen($entryContent);
-        $this->setCompressedSize($compressedSize);
-
-        $offset = ftell($outputStream);
-
-        // Commit changes.
-        $this->setGeneralPurposeBitFlags($general);
-        $this->setOffset($offset);
-
-        $extra = $this->getExtra();
-
-        // zip align
-        $padding = 0;
-        $zipAlign = $this->getCentralDirectory()->getZipAlign();
-        $extraLength = strlen($extra);
-        if ($zipAlign !== null && !$this->isEncrypted() && $this->getMethod() === ZipFile::METHOD_STORED) {
-            $padding =
-                (
-                    $zipAlign -
-                    (
-                        $offset +
-                        ZipEntry::LOCAL_FILE_HEADER_MIN_LEN +
-                        $nameLength + $extraLength
-                    ) % $zipAlign
-                ) % $zipAlign;
-        }
-
-        fwrite(
-            $outputStream,
-            pack(
-                'VvvvVVVVvv',
-                // local file header signature     4 bytes  (0x04034b50)
-                self::LOCAL_FILE_HEADER_SIG,
-                // version needed to extract       2 bytes
-                $this->getVersionNeededToExtract(),
-                // general purpose bit flag        2 bytes
-                $general,
-                // compression method              2 bytes
-                $this->getMethod(),
-                // last mod file time              2 bytes
-                // last mod file date              2 bytes
-                $this->getDosTime(),
-                // crc-32                          4 bytes
-                $dd ? 0 : $this->getCrc(),
-                // compressed size                 4 bytes
-                $dd ? 0 : $this->getCompressedSize(),
-                // uncompressed size               4 bytes
-                $dd ? 0 : $this->getSize(),
-                // file name length                2 bytes
-                $nameLength,
-                // extra field length              2 bytes
-                $extraLength + $padding
-            )
-        );
-        fwrite($outputStream, $this->getName());
-        if ($extraLength > 0) {
-            fwrite($outputStream, $extra);
-        }
-
-        if ($padding > 0) {
-            fwrite($outputStream, str_repeat(chr(0), $padding));
-        }
-
-        if (null !== $entryContent) {
-            fwrite($outputStream, $entryContent);
-        }
-
-        assert(self::UNKNOWN !== $this->getCrc());
-        assert(self::UNKNOWN !== $this->getSize());
-        if ($this->getGeneralPurposeBitFlag(self::GPBF_DATA_DESCRIPTOR)) {
-            // data descriptor signature       4 bytes  (0x08074b50)
-            // crc-32                          4 bytes
-            fwrite($outputStream, pack('VV', self::DATA_DESCRIPTOR_SIG, $this->getCrc()));
-            // compressed size                 4 or 8 bytes
-            // uncompressed size               4 or 8 bytes
-            if ($this->isZip64ExtensionsRequired()) {
-                fwrite($outputStream, PackUtil::packLongLE($compressedSize));
-                fwrite($outputStream, PackUtil::packLongLE($this->getSize()));
-            } else {
-                fwrite($outputStream, pack('VV', $this->getCompressedSize(), $this->getSize()));
-            }
-        } elseif ($this->getCompressedSize() != $compressedSize) {
-            throw new ZipException($this->getName()
-                . " (expected compressed entry size of "
-                . $this->getCompressedSize() . " bytes, but is actually " . $compressedSize . " bytes)");
-        }
-    }
-
-}
--- a/src/PhpZip/Model/Entry/ZipNewStreamEntry.php
+++ b/src/PhpZip/Model/Entry/ZipNewStreamEntry.php
@@ -1,55 +0,0 @@
-<?php
-namespace PhpZip\Model\Entry;
-
-use PhpZip\Exception\InvalidArgumentException;
-use PhpZip\Exception\ZipException;
-
-/**
- * New zip entry from stream.
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class ZipNewStreamEntry extends ZipNewEntry
-{
-    /**
-     * @var resource
-     */
-    private $stream;
-
-    /**
-     * ZipNewStreamEntry constructor.
-     * @param resource $stream
-     * @throws InvalidArgumentException
-     */
-    public function __construct($stream)
-    {
-        if (!is_resource($stream)) {
-            throw new InvalidArgumentException('stream is not resource');
-        }
-        $this->stream = $stream;
-    }
-
-    /**
-     * Returns an string content of the given entry.
-     *
-     * @return null|string
-     * @throws ZipException
-     */
-    public function getEntryContent()
-    {
-        return stream_get_contents($this->stream, -1, 0);
-    }
-
-    /**
-     * Release stream resource.
-     */
-    function __destruct()
-    {
-        if (null !== $this->stream) {
-            fclose($this->stream);
-            $this->stream = null;
-        }
-    }
-}
--- a/src/PhpZip/Model/Entry/ZipNewStringEntry.php
+++ b/src/PhpZip/Model/Entry/ZipNewStringEntry.php
@@ -1,39 +0,0 @@
-<?php
-namespace PhpZip\Model\Entry;
-
-use PhpZip\Exception\ZipException;
-
-/**
- * New zip entry from string.
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class ZipNewStringEntry extends ZipNewEntry
-{
-    /**
-     * @var string
-     */
-    private $entryContent;
-
-    /**
-     * ZipNewStringEntry constructor.
-     * @param string $entryContent
-     */
-    public function __construct($entryContent)
-    {
-        $this->entryContent = $entryContent;
-    }
-
-    /**
-     * Returns an string content of the given entry.
-     *
-     * @return null|string
-     * @throws ZipException
-     */
-    public function getEntryContent()
-    {
-        return $this->entryContent;
-    }
-}
--- a/src/PhpZip/Model/Entry/ZipReadEntry.php
+++ b/src/PhpZip/Model/Entry/ZipReadEntry.php
@@ -1,330 +0,0 @@
-<?php
-namespace PhpZip\Model\Entry;
-
-use PhpZip\Crypto\TraditionalPkwareEncryptionEngine;
-use PhpZip\Crypto\WinZipAesEngine;
-use PhpZip\Exception\Crc32Exception;
-use PhpZip\Exception\InvalidArgumentException;
-use PhpZip\Exception\ZipCryptoException;
-use PhpZip\Exception\ZipException;
-use PhpZip\Exception\ZipUnsupportMethod;
-use PhpZip\Extra\WinZipAesEntryExtraField;
-use PhpZip\Model\CentralDirectory;
-use PhpZip\Model\ZipEntry;
-use PhpZip\ZipFile;
-
-/**
- * This class is used to represent a ZIP file entry.
- *
- * @see https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT .ZIP File Format Specification
- * @author Ne-Lexa alexey@nelexa.ru
- * @license MIT
- */
-class ZipReadEntry extends ZipAbstractEntry
-{
-    /**
-     * Max size cached content in memory.
-     */
-    const MAX_SIZE_CACHED_CONTENT_IN_MEMORY = 3145728; // 3 mb
-    /**
-     * @var resource
-     */
-    private $inputStream;
-    /**
-     * @var string
-     */
-    private $charset;
-    /**
-     * @var string|resource Cached entry content.
-     */
-    private $entryContent;
-
-    /**
-     * ZipFileEntry constructor.
-     * @param $inputStream
-     */
-    public function __construct($inputStream)
-    {
-        $this->inputStream = $inputStream;
-        $this->readZipEntry($inputStream);
-    }
-
-    /**
-     * @param resource $inputStream
-     * @throws InvalidArgumentException
-     */
-    private function readZipEntry($inputStream)
-    {
-        // central file header signature   4 bytes  (0x02014b50)
-        $fileHeaderSig = unpack('V', fread($inputStream, 4))[1];
-        if (CentralDirectory::CENTRAL_FILE_HEADER_SIG !== $fileHeaderSig) {
-            throw new InvalidArgumentException("Corrupt zip file. Can not read zip entry.");
-        }
-
-        // version made by                 2 bytes
-        // version needed to extract       2 bytes
-        // general purpose bit flag        2 bytes
-        // compression method              2 bytes
-        // last mod file time              2 bytes
-        // last mod file date              2 bytes
-        // crc-32                          4 bytes
-        // compressed size                 4 bytes
-        // uncompressed size               4 bytes
-        // file name length                2 bytes
-        // extra field length              2 bytes
-        // file comment length             2 bytes
-        // disk number start               2 bytes
-        // internal file attributes        2 bytes
-        // external file attributes        4 bytes
-        // relative offset of local header 4 bytes
-        $data = unpack(
-            'vversionMadeBy/vversionNeededToExtract/vgpbf/vrawMethod/VrawTime/VrawCrc/VrawCompressedSize/' .
-            'VrawSize/vfileLength/vextraLength/vcommentLength/VrawInternalAttributes/VrawExternalAttributes/VlfhOff',
-            fread($inputStream, 42)
-        );
-
-        $utf8 = 0 !== ($data['gpbf'] & self::GPBF_UTF8);
-        if ($utf8) {
-            $this->charset = "UTF-8";
-        }
-
-        // See appendix D of PKWARE's ZIP File Format Specification.
-        $name = fread($inputStream, $data['fileLength']);
-
-        $this->setName($name);
-        $this->setVersionNeededToExtract($data['versionNeededToExtract']);
-        $this->setPlatform($data['versionMadeBy'] >> 8);
-        $this->setGeneralPurposeBitFlags($data['gpbf']);
-        $this->setMethod($data['rawMethod']);
-        $this->setDosTime($data['rawTime']);
-        $this->setCrc($data['rawCrc']);
-        $this->setCompressedSize($data['rawCompressedSize']);
-        $this->setSize($data['rawSize']);
-        $this->setExternalAttributes($data['rawExternalAttributes']);
-        $this->setOffset($data['lfhOff']); // must be unmapped!
-        if (0 < $data['extraLength']) {
-            $this->setExtra(fread($inputStream, $data['extraLength']));
-        }
-        if (0 < $data['commentLength']) {
-            $this->setComment(fread($inputStream, $data['commentLength']));
-        }
-    }
-
-    /**
-     * Returns an string content of the given entry.
-     *
-     * @return string
-     * @throws ZipException
-     */
-    public function getEntryContent()
-    {
-        if (null === $this->entryContent) {
-            if ($this->isDirectory()) {
-                $this->entryContent = null;
-                return $this->entryContent;
-            }
-            $isEncrypted = $this->isEncrypted();
-            $password = $this->getPassword();
-            if ($isEncrypted && empty($password)) {
-                throw new ZipException("Not set password");
-            }
-
-            $pos = $this->getOffset();
-            assert(self::UNKNOWN !== $pos);
-            $startPos = $pos = $this->getCentralDirectory()->getEndOfCentralDirectory()->getMapper()->map($pos);
-            fseek($this->inputStream, $startPos);
-
-            // local file header signature     4 bytes  (0x04034b50)
-            if (self::LOCAL_FILE_HEADER_SIG !== unpack('V', fread($this->inputStream, 4))[1]) {
-                throw new ZipException($this->getName() . " (expected Local File Header)");
-            }
-            fseek($this->inputStream, $pos + ZipEntry::LOCAL_FILE_HEADER_FILE_NAME_LENGTH_POS);
-            // file name length                2 bytes
-            // extra field length              2 bytes
-            $data = unpack('vfileLength/vextraLength', fread($this->inputStream, 4));
-            $pos += ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + $data['fileLength'] + $data['extraLength'];
-
-            assert(self::UNKNOWN !== $this->getCrc());
-
-            $method = $this->getMethod();
-
-            fseek($this->inputStream, $pos);
-
-            // Get raw entry content
-            $content = '';
-            if ($this->getCompressedSize() > 0) {
-                $content = fread($this->inputStream, $this->getCompressedSize());
-            }
-
-            // Strong Encryption Specification - WinZip AES
-            if ($this->isEncrypted()) {
-                if (self::METHOD_WINZIP_AES === $method) {
-                    $winZipAesEngine = new WinZipAesEngine($this);
-                    $content = $winZipAesEngine->decrypt($content);
-                    // Disable redundant CRC-32 check.
-                    $isEncrypted = false;
-
-                    /**
-                     * @var WinZipAesEntryExtraField $field
-                     */
-                    $field = $this->getExtraField(WinZipAesEntryExtraField::getHeaderId());
-                    $method = $field->getMethod();
-                    $this->setEncryptionMethod(ZipFile::ENCRYPTION_METHOD_WINZIP_AES);
-                } else {
-                    // Traditional PKWARE Decryption
-                    $zipCryptoEngine = new TraditionalPkwareEncryptionEngine($this);
-                    $content = $zipCryptoEngine->decrypt($content);
-
-                    $this->setEncryptionMethod(ZipFile::ENCRYPTION_METHOD_TRADITIONAL);
-                }
-            }
-            if ($isEncrypted) {
-                // Check CRC32 in the Local File Header or Data Descriptor.
-                $localCrc = null;
-                if ($this->getGeneralPurposeBitFlag(self::GPBF_DATA_DESCRIPTOR)) {
-                    // The CRC32 is in the Data Descriptor after the compressed size.
-                    // Note the Data Descriptor's Signature is optional:
-                    // All newer apps should write it (and so does TrueVFS),
-                    // but older apps might not.
-                    fseek($this->inputStream, $pos + $this->getCompressedSize());
-                    $localCrc = unpack('V', fread($this->inputStream, 4))[1];
-                    if (self::DATA_DESCRIPTOR_SIG === $localCrc) {
-                        $localCrc = unpack('V', fread($this->inputStream, 4))[1];
-                    }
-                } else {
-                    fseek($this->inputStream, $startPos + 14);
-                    // The CRC32 in the Local File Header.
-                    $localCrc = unpack('V', fread($this->inputStream, 4))[1];
-                }
-                if ($this->getCrc() !== $localCrc) {
-                    throw new Crc32Exception($this->getName(), $this->getCrc(), $localCrc);
-                }
-            }
-
-            switch ($method) {
-                case ZipFile::METHOD_STORED:
-                    break;
-                case ZipFile::METHOD_DEFLATED:
-                    $content = gzinflate($content);
-                    break;
-                case ZipFile::METHOD_BZIP2:
-                    if (!extension_loaded('bz2')) {
-                        throw new ZipException('Extension bzip2 not install');
-                    }
-                    $content = bzdecompress($content);
-                    break;
-                default:
-                    throw new ZipUnsupportMethod($this->getName()
-                        . " (compression method "
-                        . $method
-                        . " is not supported)");
-            }
-            if ($isEncrypted) {
-                $localCrc = crc32($content);
-                if ($this->getCrc() !== $localCrc) {
-                    if ($this->isEncrypted()) {
-                        throw new ZipCryptoException("Wrong password");
-                    }
-                    throw new Crc32Exception($this->getName(), $this->getCrc(), $localCrc);
-                }
-            }
-            if ($this->getSize() < self::MAX_SIZE_CACHED_CONTENT_IN_MEMORY) {
-                $this->entryContent = $content;
-            } else {
-                $this->entryContent = fopen('php://temp', 'rb');
-                fwrite($this->entryContent, $content);
-            }
-            return $content;
-        }
-        if (is_resource($this->entryContent)) {
-            return stream_get_contents($this->entryContent, -1, 0);
-        }
-        return $this->entryContent;
-    }
-
-    /**
-     * Write local file header, encryption header, file data and data descriptor to output stream.
-     *
-     * @param resource $outputStream
-     */
-    public function writeEntry($outputStream)
-    {
-        $pos = $this->getOffset();
-        assert(ZipEntry::UNKNOWN !== $pos);
-        $pos = $this->getCentralDirectory()->getEndOfCentralDirectory()->getMapper()->map($pos);
-        $pos += ZipEntry::LOCAL_FILE_HEADER_FILE_NAME_LENGTH_POS;
-
-        $this->setOffset(ftell($outputStream));
-        // zip align
-        $padding = 0;
-        $zipAlign = $this->getCentralDirectory()->getZipAlign();
-        $extra = $this->getExtra();
-        $extraLength = strlen($extra);
-        $nameLength = strlen($this->getName());
-        if ($zipAlign !== null && !$this->isEncrypted() && $this->getMethod() === ZipFile::METHOD_STORED) {
-            $padding =
-                (
-                    $zipAlign -
-                    ($this->getOffset() + ZipEntry::LOCAL_FILE_HEADER_MIN_LEN + $nameLength + $extraLength)
-                    % $zipAlign
-                ) % $zipAlign;
-        }
-        $dd = $this->isDataDescriptorRequired();
-
-        fwrite(
-            $outputStream,
-            pack(
-                'VvvvVVVVvv',
-                // local file header signature     4 bytes  (0x04034b50)
-                self::LOCAL_FILE_HEADER_SIG,
-                // version needed to extract       2 bytes
-                $this->getVersionNeededToExtract(),
-                // general purpose bit flag        2 bytes
-                $this->getGeneralPurposeBitFlags(),
-                // compression method              2 bytes
-                $this->getMethod(),
-                // last mod file time              2 bytes
-                // last mod file date              2 bytes
-                $this->getDosTime(),
-                // crc-32                          4 bytes
-                $dd ? 0 : $this->getCrc(),
-                // compressed size                 4 bytes
-                $dd ? 0 : $this->getCompressedSize(),
-                // uncompressed size               4 bytes
-                $dd ? 0 : $this->getSize(),
-                $nameLength,
-                // extra field length              2 bytes
-                $extraLength + $padding
-            )
-        );
-        fwrite($outputStream, $this->getName());
-        if ($extraLength > 0) {
-            fwrite($outputStream, $extra);
-        }
-
-        if ($padding > 0) {
-            fwrite($outputStream, str_repeat(chr(0), $padding));
-        }
-
-        fseek($this->inputStream, $pos);
-        $data = unpack('vfileLength/vextraLength', fread($this->inputStream, 4));
-        fseek($this->inputStream, $data['fileLength'] + $data['extraLength'], SEEK_CUR);
-
-        $length = $this->getCompressedSize();
-        if ($this->getGeneralPurposeBitFlag(ZipEntry::GPBF_DATA_DESCRIPTOR)) {
-            $length += 12;
-            if ($this->isZip64ExtensionsRequired()) {
-                $length += 8;
-            }
-        }
-        stream_copy_to_stream($this->inputStream, $outputStream, $length);
-    }
-
-    function __destruct()
-    {
-        if (null !== $this->entryContent && is_resource($this->entryContent)) {
-            fclose($this->entryContent);
-        }
-    }
-
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ne-Lexa	330c724ce6	fix psalm	2022-06-19 11:27:45 +03:00
Ne-Lexa	4130739a21	Merge tag '4.0.2' into develop Tagging version 4.0.2 4.0.2	2022-06-17 14:17:46 +03:00
Ne-Lexa	88a1b6549b	Merge branch 'release/4.0.2'	2022-06-17 14:17:46 +03:00
Ne-Lexa	9e1d4a1d7a	Merge pull request #82 from mbardelmeijer/patch-1 Remove ftruncate for saveAsStream	2021-12-12 13:42:46 +03:00
Ne-Lexa	66168de897	Merge tag '4.0.1' into develop 4.0.1 version	2021-12-12 12:50:55 +03:00
Ne-Lexa	a18f80db50	Merge branch 'hotfix/4.0.1'	2021-12-12 12:50:45 +03:00
Ne-Lexa	bfff5f475a	cs fix	2021-12-12 12:50:30 +03:00
Ne-Lexa	83dd71e602	update dependencies	2021-12-12 12:46:29 +03:00
Michel Bardelmeijer	0251dbf5c7	Remove ftruncate for saveAsStream	2021-09-06 20:28:28 +02:00
Ne-Lexa	f216617486	change php version for coverage	2021-02-25 22:46:16 +03:00
Ne-Lexa	58f821040f	update build	2021-02-25 21:42:14 +03:00
Ne-Lexa	f0c59a458d	update build	2021-02-25 21:33:48 +03:00
Ne-Lexa	d0228d388a	disabled JIT for tests on php 8	2021-02-25 21:28:27 +03:00
Ne-Lexa	1a762284da	disabled JIT for tests on php 8	2021-02-25 21:26:47 +03:00
Ne-Lexa	0be0d32fff	fix build	2021-02-25 21:04:19 +03:00
Ne-Lexa	f0e26007c1	Merge tag '4.0.0' into develop Tagging version 4.0.0 4.0.0	2021-02-24 15:51:19 +03:00
Ne-Lexa	668afcf81a	Merge branch 'release/4.0.0'	2021-02-24 15:51:19 +03:00
Ne-Lexa	a11c6367b4	added method `outputAsSymfonyResponse`, rename method `outputAsResponse` to `outputAsPsr7Response`	2021-02-24 15:37:11 +03:00
Ne-Lexa	e8418d57b1	Merge branch 'feature/php8' into develop	2021-02-24 12:11:34 +03:00
Ne-Lexa	4a436569da	update README	2021-02-24 12:06:08 +03:00
Ne-Lexa	ac899a02e0	update readme	2021-02-24 09:53:24 +03:00
Ne-Lexa	28d33ab687	build: run all tests (incl. very slow)	2021-02-23 20:07:37 +03:00
Ne-Lexa	8f43a3a75f	fix static analysis config	2021-02-23 19:57:13 +03:00
Ne-Lexa	00dd097b2d	added static analysis	2021-02-23 19:45:39 +03:00
Ne-Lexa	a85288d34b	added build on macos	2021-02-23 15:55:08 +03:00
Ne-Lexa	620065ac5b	disabled jit on php 8.0 test	2021-02-23 15:37:03 +03:00
Ne-Lexa	34074a8024	update docs and build	2021-02-23 13:34:41 +03:00
Ne-Lexa	f799eca6de	update github actions build	2021-02-22 20:24:13 +03:00
Ne-Lexa	ae04b357fc	update github actions build	2021-02-22 20:00:59 +03:00
Ne-Lexa	f67934f95a	update readme	2021-02-22 19:59:54 +03:00
Ne-Lexa	a65fe4579b	php8 support	2021-02-22 13:12:01 +03:00
Ne-Lexa	44c2041f62	Merge branch 'php8' of https://github.com/odan/php-zip into feature/php8	2021-02-18 09:47:51 +03:00
Daniel Opitz	bcc66edad3	Add PHP 7.2 to build matrix	2021-01-09 18:49:36 +01:00
Daniel Opitz	85b3ea84b6	Fix cs	2021-01-09 18:25:45 +01:00
Daniel Opitz	4ecb0c4ee6	Add PHP 8 support	2021-01-09 18:16:56 +01:00
wapplay	501b52f6fc	Merge branch 'release/3.3.3'	2020-07-12 00:01:42 +03:00
wapplay	7283fc3402	Merge tag '3.3.3' into develop Tagging version 3.3.3 3.3.3	2020-07-12 00:01:42 +03:00
wapplay	d9022e80c5	LICENSE file added	2020-07-11 23:48:23 +03:00
wapplay	c10c425f7e	Improved Windows compatibility, fix #54	2020-07-11 23:04:33 +03:00
wapplay	0655e282e9	Merge branch 'feature/overwrite' into develop	2020-07-11 22:21:37 +03:00
wapplay	391a55f378	Merge branch 'release/3.3.2'	2020-06-22 18:05:21 +03:00
wapplay	b64e9ac328	Merge tag '3.3.2' into develop Tagging version 3.3.2 3.3.2	2020-06-22 18:05:21 +03:00
Ne-Lexa	f503fc164e	Merge pull request #60 from Araqel/master removed extra commas from .phpstorm.meta.php	2020-06-22 18:02:56 +03:00
Araqel Araqelyan	8ce666fb5e	removed extra commas from .phpstorm.meta.php	2020-06-22 18:53:58 +04:00
wapplay	dbddcda001	#54 overwriting open zip archive fixed	2020-05-04 14:13:39 +03:00
wapplay	52ce79d4d2	Merge branch 'release/3.3.1'	2020-04-01 16:33:45 +03:00
wapplay	3942bf2005	Merge tag '3.3.1' into develop Tagging version 3.3.1 3.3.1	2020-04-01 16:33:45 +03:00
Ne-Lexa	decf4f5095	Merge pull request #47 from chx/chx-patch-1 Do not pin random_compat version	2020-04-01 16:29:06 +03:00
chx	70d8b8200b	Do not pin random_compat version	2020-03-23 09:49:26 -07:00
Ne-Lexa	8fdc21eece	Merge branch 'release/3.3.0'	2020-02-04 12:01:18 +03:00
Ne-Lexa	74c0a49057	Merge tag '3.3.0' into develop Tagging version 3.3.0 3.3.0	2020-02-04 12:01:18 +03:00
Ne-Lexa	ae6d47f47a	removed test ZipInfo::__toString() (depends on time zone)	2020-02-04 11:58:47 +03:00
Ne-Lexa	b3b676e3af	Merge branch 'release/3.3.0'	2020-02-04 11:47:43 +03:00
Ne-Lexa	f3d769739b	Merge tag '3.2.2' into develop Tagging hotfix 3.2.2 3.2.2 # Conflicts: # .travis.yml # tests/ZipFileTest.php	2020-02-04 11:36:29 +03:00
Ne-Lexa	074443dbc4	Merge branch 'hotfix/3.2.2'	2020-02-04 11:29:58 +03:00
Ne-Lexa	cbb693213e	fix replace contents by file	2020-02-04 11:18:32 +03:00
Ne-Lexa	820c63c30f	ZipInfo tests	2020-01-31 13:42:19 +03:00
Ne-Lexa	2235de6b35	Merge branch 'feature/zipcontainer-override-support' into develop	2020-01-31 12:13:16 +03:00
Ne-Lexa	6e33ed08ef	run php 7.4 in xenial	2020-01-22 16:26:24 +03:00
Ne-Lexa	79e77a8c88	fix close container in ZipFile::close()	2020-01-22 16:07:22 +03:00
Ne-Lexa	8dcde47072	Added a new option for extracting unix symlinks. Added new parameter to get the list of extracted files.	2020-01-22 12:53:16 +03:00
Ne-Lexa	47161bdb02	zip extra fields tests	2020-01-22 12:48:47 +03:00
Ne-Lexa	943cf3e777	Fixed problem with cloning a zip container.	2020-01-22 12:48:15 +03:00
Ne-Lexa	5ec656fde4	Implemented the ability to override the instance of ZipContainer. ZipContainer will be cloned before writing the zip file. Tested custom ZipWriter, ZipReader, ZipContainer and ZipFile.	2020-01-21 14:13:47 +03:00
Ne-Lexa	d305ab68bc	Merge branch 'hotfix/3.2.1'	2020-01-14 16:44:56 +03:00
Ne-Lexa	e0da8c94be	Merge tag '3.2.1' into develop Tagging hotfix 3.2.1 3.2.1	2020-01-14 16:44:56 +03:00
Ne-Lexa	8487dac9df	zip extra tests, php 32-bit compat	2020-01-14 16:31:22 +03:00
Ne-Lexa	d21fdb35bb	fix#13 fix#16 fix#27 fix#31 fix#41 Tagging version 3.2.0 3.2.0 - Fix memory leak problem - Add new methods: `getEntry()`, `getEntries()`, `addSplFile()`, `addFromFinder()` - Fix large zip files problem	2020-01-09 17:41:47 +03:00
Ne-Lexa	25d5ddcbff	Merge branch 'release/3.2.0'	2020-01-09 17:39:56 +03:00
Ne-Lexa	f426871549	Merge branch 'feature/nextversion' into develop	2020-01-09 17:33:10 +03:00
Ne-Lexa	fd1fbf3ad6	fix deprecation use	2020-01-09 17:33:02 +03:00
Ne-Lexa	971747f5e7	fix coverage	2020-01-09 13:11:13 +03:00
Ne-Lexa	77f2841724	removed config for php nightly (php 8.0-dev)	2020-01-09 13:00:23 +03:00
Ne-Lexa	c82e303002	configure phpunit flags	2020-01-09 12:57:28 +03:00
Ne-Lexa	61e9d96439	fix travis syntax	2020-01-09 12:53:47 +03:00
Ne-Lexa	800afffffa	fix travis env	2020-01-09 12:50:03 +03:00
Ne-Lexa	1a04a5cdd9	matrix config	2020-01-09 12:48:47 +03:00
Ne-Lexa	6c49dd54c8	fix test	2020-01-09 12:05:02 +03:00
wapplay	a16b0e7c15	minor fixes, ZipEntry tests	2020-01-06 11:53:17 +03:00
wapplay	70bb598fa6	php5.5 compat	2020-01-04 00:46:07 +03:00
wapplay	27b8a3d32f	replaced abandoned package	2020-01-04 00:20:43 +03:00
wapplay	75578fd181	fix php 5.5 compat	2020-01-04 00:13:54 +03:00
wapplay	8efbfd67f4	fix php 5.5 compat, fix append stream filter	2020-01-03 23:52:52 +03:00
Ne-Lexa	ca6c4fee6e	fix travis	2019-12-30 19:05:11 +03:00
Ne-Lexa	9d42215088	exclude zip64 tests	2019-12-30 18:59:22 +03:00
Ne-Lexa	9ca14707d4	adds coverage	2019-12-30 18:56:58 +03:00
Ne-Lexa	28bddadac3	fix syntax error for php 5	2019-12-30 18:55:35 +03:00
Ne-Lexa	f377b889b5	solving problems with lack of memory, the new ZipReader and ZipWriter class, adds `.phpstorm.meta.php` #13 #16 #27 #31 #41	2019-12-30 18:47:37 +03:00
Ne-Lexa	28e220718c	Merge tag '3.1.15' into develop fix #42 ZipFile::outputAsAttachment() gives empty zip	2019-12-11 15:27:49 +03:00
Ne-Lexa	3b769793fc	Merge branch 'hotfix/3.1.15'	2019-12-11 15:26:23 +03:00
Ne-Lexa	7cbf992492	fix #42	2019-12-11 15:21:28 +03:00
Ne-Lexa	3ef867cde4	Merge tag '3.1.14' into develop fix unknown zip software version	2019-12-09 12:18:20 +03:00
Ne-Lexa	c420f191dd	Merge branch 'hotfix/3.1.14'	2019-12-09 12:17:55 +03:00
Ne-Lexa	50015f25f3	fix unknown software version	2019-12-09 12:13:56 +03:00
Ne-Lexa	36b1af0263	Merge tag '3.1.13' into develop improved compatibility with php 7.4 and php-32 bit, minor bug fixes	2019-12-09 11:23:00 +03:00
Ne-Lexa	f2d2954bee	Merge branch 'hotfix/3.1.13'	2019-12-09 11:20:56 +03:00
wapplay	725959d98f	fix encryption	2019-12-07 20:16:40 +03:00
wapplay	f82a57e662	fix duplicates	2019-12-07 19:40:36 +03:00
wapplay	a20e9e054d	use random_compat	2019-12-06 23:23:44 +03:00
Ne-Lexa	95e3312e60	refactoring zip64, add property softwareVersion, internal attrs, extracted os	2019-12-06 17:36:22 +03:00
Ne-Lexa	e2c058840c	fixed for php 32-bit	2019-12-06 12:09:37 +03:00
wapplay	e03c963dc1	refactoring	2019-12-06 08:32:33 +03:00
wapplay	c0786f5947	set travis dist	2019-12-05 23:52:17 +03:00
Ne-Lexa	3bafe01ff0	php cs fix	2019-12-05 19:36:11 +03:00
wapplay	558bb04066	Merge tag '3.1.12' into develop Tagging hotfix 3.1.12 3.1.12	2019-07-25 23:08:42 +03:00
wapplay	ca068fa78f	Merge branch 'hotfix/3.1.12'	2019-07-25 23:08:42 +03:00
wapplay	a84d2f9eff	fix issue #39	2019-07-25 23:03:28 +03:00
Ne-Lexa	97db60a52d	Merge pull request #36 from chrisgraham/develop Fixed slightly confusing language regarding setPassword	2019-04-04 11:37:51 +03:00
Chris Graham	4134ca8daa	Fixed slightly confusing language regarding setPassword	2019-04-02 16:53:33 -05:00
Ne-Lexa	e7528b2974	Merge tag '3.1.11' into develop Tagging hotfix 3.1.11 3.1.11	2019-03-13 15:41:56 +03:00
Ne-Lexa	19e17fb730	Merge branch 'hotfix/3.1.11'	2019-03-13 15:41:56 +03:00
Ne-Lexa	d8f913ac67	removed nightly PHP (8.0-dev) from travis	2019-03-13 15:37:01 +03:00
Ne-Lexa	1d1c8559cd	update travis config	2019-03-13 15:29:40 +03:00
Ne-Lexa	e1108f9a24	Added .gitattributes to exclude tests from the release version #34	2019-03-13 15:28:38 +03:00
Ne-Lexa	96d269b4ca	Merge tag '3.1.10' into develop Tagging hotfix 3.1.10 3.1.10	2019-03-13 15:16:08 +03:00
Ne-Lexa	53da7053ba	Merge branch 'hotfix/3.1.10'	2019-03-13 15:16:08 +03:00
Ne-Lexa	e8745e0379	fix #34	2019-03-13 15:15:52 +03:00
Ne-Lexa	b3277fcc5c	Replaced the execution operator `backticks` with the function call `exec` in tests	2019-03-13 15:14:01 +03:00
Ne-Lexa	4aa9711e00	Merge tag '3.1.9' into develop Tagging version 3.1.9 3.1.9	2018-11-02 15:15:08 +03:00
Ne-Lexa	c9871c9f80	Merge branch 'release-3.1.9'	2018-11-02 15:15:08 +03:00
Ne-Lexa	650fab4bad	Merge branch 'master' into develop	2018-11-02 15:14:52 +03:00
Ne-Lexa	fd9750c4f3	Merge pull request #26 from belgattitude/fix/non-seekable-streams Re-enable support for remote streams, fix #25	2018-11-02 15:11:54 +03:00
Sébastien Vanvelthem	e903642893	Re-enable support for remote streams, fix #25	2018-11-02 11:53:35 +01:00
wapplay	516d0c1e77	Merge tag '3.1.8' into develop Tagging version 3.1.8 3.1.8	2018-10-21 19:31:21 +03:00
wapplay	9934a860c1	Merge branch 'release/3.1.8'	2018-10-21 19:31:21 +03:00
wapplay	c9f597308e	cs fix	2018-10-21 19:30:45 +03:00
wapplay	837454ba7e	Added additional check for correct decompression	2018-10-21 19:25:13 +03:00
wapplay	680a9d92c1	Merge branch 'hotfix/3.1.7'	2018-10-21 01:54:45 +03:00
wapplay	04a92e7904	Merge tag '3.1.7' into develop Tagging hotfix 3.1.7 3.1.7	2018-10-21 01:54:45 +03:00
wapplay	e4e3a7504e	Test streamWrapper extract (issue #24 )	2018-10-21 01:54:30 +03:00
wapplay	d8bb1be43b	Fix #24 Change fread for variable size reads	2018-10-21 01:32:01 +03:00
Ne-Lexa	c163f0583e	update pull request template	2018-10-18 10:46:49 +03:00
Ne-Lexa	116a617744	added github templates	2018-10-18 10:42:57 +03:00
Ne-Lexa	e207086a75	Merge tag '3.1.6' into develop Tagging version 3.1.6 3.1.6	2018-10-11 10:54:30 +03:00
Ne-Lexa	9bb20cc15e	Merge branch 'release-3.1.6'	2018-10-11 10:54:30 +03:00
Ne-Lexa	7e84f97473	resolve merge conflict	2018-10-11 10:49:53 +03:00
Ne-Lexa	a13f4cc32f	Merge branch 'master' into develop # Conflicts: # src/PhpZip/ZipFile.php # tests/PhpZip/ZipFileTest.php	2018-10-11 10:39:05 +03:00
Ne-Lexa	c863c18869	Fix #22 Adding links to files, not open handles	2018-10-10 16:53:17 +03:00
wapplay	ad3bac6f96	cp866 to utf8 converter	2018-10-10 10:34:06 +03:00
wapplay	d2e94ac9cd	update REAMDE	2018-10-10 07:43:29 +03:00
wapplay	3f0c6a7bd8	add php 7.2 in travis config	2018-10-10 07:41:43 +03:00
wapplay	062762ed09	update README	2018-10-10 07:41:19 +03:00
wapplay	e1866215a6	cs-fix	2018-10-09 10:17:54 +03:00
wapplay	f9e6a73587	PHP-doc updated (@throws added everywhere) and minor refactoring done.	2018-10-09 10:06:04 +03:00
wapplay	59773d62a8	Merge branch 'litlife-patch-1' into develop	2018-10-09 09:55:45 +03:00
wapplay	9417d7dc95	Merge branch 'patch-1' of https://github.com/litlife/php-zip into litlife-patch-1	2018-10-09 09:55:13 +03:00
Ne-Lexa	45905eacf0	Merge pull request #21 from MohannadNaj/rewording Rewording some exceptions messages	2018-05-08 07:23:02 +03:00
MohannadNaj	aa8846b944	Rewording some exceptions messages	2018-05-08 03:40:39 +03:00
Ne-Lexa	6058c289a4	Merge tag '3.1.5' into develop version 3.1.5	2018-04-25 12:44:40 +03:00
Ne-Lexa	251ce11bdc	Merge branch 'hotfix/3.1.5'	2018-04-25 12:44:11 +03:00
Ne-Lexa	f969e59319	Updated ZipFile::outputAsResponse() to conform to PSR standard	2018-04-25 12:43:37 +03:00
Frederik Buus Sauer	6808e4ffdc	Lowered requirement to support PHP 5.5	2018-04-12 11:25:12 +02:00
Frederik Buus Sauer	91f08b9f55	Updated composer.json regarding unit tests, and corrected PSR implementation	2018-04-12 11:10:45 +02:00
litlife	8de3a70571	Файлы при записывании в кеш не могут считаться Привет! Спасибо за такой прекрасный модуль для работы с архивами! Нашел такой глюк. При превышении размера 524288 файлы записывается в php://temp. При запросе данных из кеша stream_get_contents ничего не выводит. В fopen mode поменял на r+b, что включился режим записи. При запросе данных из stream нужно установить указатель в начало файла, поэтому перед ним вставил функцию rewind($this->entryContent);	2018-04-09 18:09:19 +03:00
Ne-Lexa	bdd5423f67	Merge tag '3.1.4' into develop Tagging version 3.1.4 3.1.4	2018-02-01 09:52:40 +03:00
Ne-Lexa	d0cf7f7d1d	Merge branch 'hotfix/3.1.4'	2018-02-01 09:52:40 +03:00
Ne-Lexa	9f0d151f5e	Fixed installing the package on the MAC (illegal byte sequence unzip). close issue #11	2018-02-01 09:52:35 +03:00
Ne-Lexa	e58cf0f337	Merge tag '3.1.3' into develop Tagging version 3.1.3 3.1.3	2017-12-06 15:43:25 +03:00
Ne-Lexa	171d4a8e4c	Merge branch 'hotfix/3.1.3'	2017-12-06 15:43:25 +03:00
Ne-Lexa	aa09b24d02	added an additional test of the encrypted archive	2017-12-06 15:28:17 +03:00
Ne-Lexa	c34f90ac18	fix bug issues #9	2017-12-06 15:09:50 +03:00
Ne-Lexa	fb1a9ced88	Merge tag '3.1.2' into develop Tagging version 3.1.2 3.1.2	2017-11-17 11:13:15 +03:00
Ne-Lexa	7d73ac417f	Merge branch 'hotfix/3.1.2'	2017-11-17 11:13:15 +03:00
Ne-Lexa	4979829fad	Fixed the call `array_fill()` with the number of elements 0 for PHP 5.5	2017-11-17 11:08:20 +03:00
Ne-Lexa	a3083b821c	Changed the algorithm for adding paddings to zipalign. Now we will use the special field ExtraField c ID 0xD935, which was implemented by Google in the apksigner library. Now this field corresponds to the ZIP standard for storing ExtraField records, and not just filling with zero bytes, as in the zipalign console utility.	2017-11-17 10:54:22 +03:00
Ne-Lexa	a1da1f0069	Added an event that runs before the archive is saved or output.	2017-11-15 16:24:14 +03:00
Ne-Lexa	d67fc4db7d	Merge branch 'hotfix/3.1.1'	2017-11-15 10:48:35 +03:00
Ne-Lexa	f29fed2753	Merge tag '3.1.1' into develop Tagging version 3.1.1 3.1.1	2017-11-15 10:48:35 +03:00
Ne-Lexa	ba2e314ca2	Fix resave aligned archive	2017-11-15 10:48:29 +03:00
Ne-Lexa	0788892831	Merge branch 'release/3.1.0'	2017-11-14 15:27:09 +03:00
Ne-Lexa	03998d79a9	Merge tag '3.1.0' into develop Tagging version 3.1.0 3.1.0	2017-11-14 15:27:09 +03:00
Ne-Lexa	ab41e70d5c	Added changes to changelog.	2017-11-14 15:26:44 +03:00
Ne-Lexa	23addc5695	Merge branch 'feature/zipmodel' into develop # Conflicts: # .travis.yml # README.md # src/PhpZip/Model/Entry/ZipReadEntry.php # tests/PhpZip/ZipFileTest.php	2017-11-14 14:55:33 +03:00
Ne-Lexa	d32b000855	Rename methods `removePassword()` to `disableEncryption()`	2017-11-14 14:47:46 +03:00
Ne-Lexa	e62e51efb5	issue #8 - Support inline Content-Disposition and empty output filename.	2017-11-14 14:03:44 +03:00
Ne-Lexa	02afaae56c	Skipped some tests for php 32-bit platform.	2017-11-14 11:39:16 +03:00
Ne-Lexa	0d4b101510	Skipped some tests for php 32-bit platform.	2017-11-14 11:28:02 +03:00
wapplay-home-linux	1b1495eee8	Skipped some tests for a users with root privileges	2017-11-14 09:16:11 +03:00
wapplay-home-linux	129e69c293	fixed some errors tests for php-32 bit platform	2017-11-14 08:47:25 +03:00
wapplay-home-linux	ec919808d0	Revert "travis try install zipalign" This reverts commit `8880275`	2017-11-13 15:50:19 +03:00
wapplay-home-linux	88802754b3	travis try install zipalign	2017-11-13 15:47:24 +03:00
wapplay-home-linux	2f87d4f5ab	update readme	2017-11-13 15:40:05 +03:00
wapplay-home-linux	452c5920dd	Add ZipModel for all changes.	2017-11-13 15:33:37 +03:00
wapplay-home-linux	dcd6ab933b	Merge tag '3.0.3' into develop Tagging version 3.0.3 3.0.3	2017-11-11 17:21:12 +03:00
wapplay-home-linux	a72db0aa7d	Merge tag '3.0.2' into develop Tagging version 3.0.2 3.0.2	2017-10-30 23:32:11 +03:00
Ne-Lexa	6812423c89	Merge tag '3.0.1' into develop Tagging version 3.0.1 3.0.1	2017-03-15 19:03:17 +03:00
Ne-Lexa	c49ec503c8	Merge tag '3.0.0' into develop Tagging version 3.0.0 3.0.0	2017-03-15 15:35:18 +03:00