first pass of Open Async

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "csharpier": {
-      "version": "1.2.5",
+      "version": "1.2.1",
       "commands": [
         "csharpier"
       ],

.github/COPILOT_AGENT_README.md

@@ -0,0 +1,15 @@
+# Copilot Coding Agent Configuration
+
+This repository includes a minimal opt-in configuration and CI workflow to allow the GitHub Copilot coding agent to open and validate PRs.
+
+- .copilot-agent.yml: opt-in config for automated agents
+- .github/agents/copilot-agent.yml: detailed agent policy configuration
+- .github/workflows/dotnetcore.yml: CI runs on PRs touching the solution, source, or tests to validate changes
+- AGENTS.md: general instructions for Copilot coding agent with project-specific guidelines
+
+Maintainers can adjust the allowed paths or disable the agent by editing or removing .copilot-agent.yml.
+
+Notes:
+- The agent can create, modify, and delete files within the allowed paths (src, tests, README.md, AGENTS.md)
+- All changes require review before merge
+- If build/test paths are different, update the workflow accordingly; this workflow targets SharpCompress.sln and the SharpCompress.Test test project.

.github/prompts/plan-async.prompt.md

@@ -1,25 +0,0 @@
-# Plan: Implement Missing Async Functionality in SharpCompress
-
-SharpCompress has async support for low-level stream operations and Reader/Writer APIs, but critical entry points (Archive.Open, factory methods, initialization) remain synchronous. This plan adds async overloads for all user-facing I/O operations and fixes existing async bugs, enabling full end-to-end async workflows.
-
-## Steps
-
-1. **Add async factory methods** to [ArchiveFactory.cs](src/SharpCompress/Factories/ArchiveFactory.cs), [ReaderFactory.cs](src/SharpCompress/Factories/ReaderFactory.cs), and [WriterFactory.cs](src/SharpCompress/Factories/WriterFactory.cs) with `OpenAsync` and `CreateAsync` overloads accepting `CancellationToken`
-
-2. **Implement async Open methods** on concrete archive types ([ZipArchive.cs](src/SharpCompress/Archives/Zip/ZipArchive.cs), [TarArchive.cs](src/SharpCompress/Archives/Tar/TarArchive.cs), [RarArchive.cs](src/SharpCompress/Archives/Rar/RarArchive.cs), [GZipArchive.cs](src/SharpCompress/Archives/GZip/GZipArchive.cs), [SevenZipArchive.cs](src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs)) and reader types ([ZipReader.cs](src/SharpCompress/Readers/Zip/ZipReader.cs), [TarReader.cs](src/SharpCompress/Readers/Tar/TarReader.cs), etc.)
-
-3. **Convert archive initialization logic to async** including header reading, volume loading, and format signature detection across archive constructors and internal initialization methods
-
-4. **Fix LZMA decoder async bugs** in [LzmaStream.cs](src/SharpCompress/Compressors/LZMA/LzmaStream.cs), [Decoder.cs](src/SharpCompress/Compressors/LZMA/Decoder.cs), and [OutWindow.cs](src/SharpCompress/Compressors/LZMA/OutWindow.cs) to enable true async 7Zip support and remove `NonDisposingStream` workaround
-
-5. **Complete Rar async implementation** by converting `UnpackV2017` methods to async in [UnpackV2017.cs](src/SharpCompress/Compressors/Rar/UnpackV2017.cs) and updating Rar20 decompression
-
-6. **Add comprehensive async tests** covering all new async entry points, cancellation scenarios, and concurrent operations across all archive formats in test files
-
-## Further Considerations
-
-1. **Breaking changes** - Should new async methods be added alongside existing sync methods (non-breaking), or should sync methods eventually be deprecated? Recommend additive approach for backward compatibility.
-
-2. **Performance impact** - Header parsing for formats like Zip/Tar is often small; consider whether truly async parsing adds value vs sync parsing wrapped in Task, or make it conditional based on stream type (network vs file).
-
-3. **7Zip complexity** - The LZMA async bug fix (Step 4) may be challenging due to state management in the decoder; consider whether to scope it separately or implement a simpler workaround that maintains correctness.

.github/prompts/plan-for-next.prompt.md

@@ -1,123 +0,0 @@
-# Plan: Modernize SharpCompress Public API
-
-Based on comprehensive analysis, the API has several inconsistencies around factory patterns, async support, format capabilities, and options classes. Most improvements can be done incrementally without breaking changes.
-
-## Steps
-
-1. **Standardize factory patterns** by deprecating format-specific static `Open` methods in [Archives/Zip/ZipArchive.cs](src/SharpCompress/Archives/Zip/ZipArchive.cs), [Archives/Tar/TarArchive.cs](src/SharpCompress/Archives/Tar/TarArchive.cs), etc. in favor of centralized [Factories/ArchiveFactory.cs](src/SharpCompress/Factories/ArchiveFactory.cs)
-
-2. **Complete async implementation** in [Writers/Zip/ZipWriter.cs](src/SharpCompress/Writers/Zip/ZipWriter.cs) and other writers that currently use sync-over-async, implementing true async I/O throughout the writer hierarchy
-
-3. **Unify options classes** by making [Common/ExtractionOptions.cs](src/SharpCompress/Common/ExtractionOptions.cs) inherit from `OptionsBase` and adding progress reporting to extraction methods consistently
-
-4. **Clarify GZip semantics** in [Archives/GZip/GZipArchive.cs](src/SharpCompress/Archives/GZip/GZipArchive.cs) by adding XML documentation explaining single-entry limitation and relationship to GZip compression used in Tar.gz
-
-## Further Considerations
-
-1. **Breaking changes roadmap** - Should we plan a major version (2.0) to remove deprecated factory methods, clean up `ArchiveType` enum (remove Arc/Arj or add full support), and consolidate naming patterns?
-
-2. **Progress reporting consistency** - Should `IProgress<ArchiveExtractionProgress<IEntry>>` be added to all extraction extension methods or consolidated into options classes?
-
-## Detailed Analysis
-
-### Factory Pattern Issues
-
-Three different factory patterns exist with overlapping functionality:
-
-1. **Static Factories**: ArchiveFactory, ReaderFactory, WriterFactory
-2. **Instance Factories**: IArchiveFactory, IReaderFactory, IWriterFactory
-3. **Format-specific static methods**: Each archive class has static `Open` methods
-
-**Example confusion:**
-```csharp
-// Three ways to open a Zip archive - which is recommended?
-var archive1 = ArchiveFactory.Open("file.zip");
-var archive2 = ZipArchive.Open("file.zip");
-var archive3 = ArchiveFactory.AutoFactory.Open(fileInfo, options);
-```
-
-### Async Support Gaps
-
-Base `IWriter` interface has async methods, but writer implementations provide minimal async support. Most writers just call synchronous methods:
-
-```csharp
-public virtual async Task WriteAsync(...)
-{
-    // Default implementation calls synchronous version
-    Write(filename, source, modificationTime);
-    await Task.CompletedTask.ConfigureAwait(false);
-}
-```
-
-Real async implementations only in:
-- `TarWriter` - Proper async implementation
-- Most other writers use sync-over-async
-
-### GZip Archive Special Case
-
-GZip is treated as both a compression format and an archive format, but only supports single-entry archives:
-
-```csharp
-protected override GZipArchiveEntry CreateEntryInternal(...)
-{
-    if (Entries.Any())
-    {
-        throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
-    }
-    // ...
-}
-```
-
-### Options Class Hierarchy
-
-```
-OptionsBase (LeaveStreamOpen, ArchiveEncoding)
-  ├─ ReaderOptions (LookForHeader, Password, DisableCheckIncomplete, BufferSize, ExtensionHint, Progress)
-  ├─ WriterOptions (CompressionType, CompressionLevel, Progress)
-  │   ├─ ZipWriterOptions (ArchiveComment, UseZip64)
-  │   ├─ TarWriterOptions (FinalizeArchiveOnClose, HeaderFormat)
-  │   └─ GZipWriterOptions (no additional properties)
-  └─ ExtractionOptions (standalone - Overwrite, ExtractFullPath, PreserveFileTime, PreserveAttributes)
-```
-
-**Issues:**
-- `ExtractionOptions` doesn't inherit from `OptionsBase` - no encoding support during extraction
-- Progress reporting inconsistency between readers and extraction
-- Obsolete properties (`ChecksumIsValid`, `Version`) with unclear migration path
-
-### Implementation Priorities
-
-**High Priority (Non-Breaking):**
-1. Add API usage guide (Archive vs Reader, factory recommendations, async best practices)
-2. Fix progress reporting consistency
-3. Complete async implementation in writers
-
-**Medium Priority (Next Major Version):**
-1. Unify factory pattern - deprecate format-specific static `Open` methods
-2. Clean up options classes - make `ExtractionOptions` inherit from `OptionsBase`
-3. Clarify archive types - remove Arc/Arj from `ArchiveType` enum or add full support
-4. Standardize naming across archive types
-
-**Low Priority:**
-1. Add BZip2 archive support similar to GZipArchive
-2. Complete obsolete property cleanup with migration guide
-
-### Backward Compatibility Strategy
-
-**Safe (Non-Breaking) Changes:**
-- Add new methods to interfaces (use default implementations)
-- Add new options properties (with defaults)
-- Add new factory methods
-- Improve async implementations
-- Add progress reporting support
-
-**Breaking Changes to Avoid:**
-- ❌ Removing format-specific `Open` methods (deprecate instead)
-- ❌ Changing `LeaveStreamOpen` default (currently `true`)
-- ❌ Removing obsolete properties before major version bump
-- ❌ Changing return types or signatures of existing methods
-
-**Deprecation Pattern:**
-- Use `[Obsolete]` for one major version
-- Use `[EditorBrowsable(EditorBrowsableState.Never)]` in next major version
-- Remove in following major version

.github/workflows/NUGET_RELEASE.md

@@ -1,155 +0,0 @@
-# NuGet Release Workflow
-
-This document describes the automated NuGet release workflow for SharpCompress.
-
-## Overview
-
-The `nuget-release.yml` workflow automatically builds, tests, and publishes SharpCompress packages to NuGet.org when:
-- Changes are pushed to the `master` or `release` branch
-- A version tag (format: `MAJOR.MINOR.PATCH`) is pushed
-
-The workflow runs on both Windows and Ubuntu, but only the Windows build publishes to NuGet.
-
-## How It Works
-
-### Version Determination
-
-The workflow automatically determines the version based on whether the commit is tagged using C# code in the build project:
-
-1. **Tagged Release (Stable)**:
-   - If the current commit has a version tag (e.g., `0.42.1`)
-   - Uses the tag as the version number
-   - Published as a stable release
-
-2. **Untagged Release (Prerelease)**:
-   - If the current commit is NOT tagged
-   - Creates a prerelease version based on the next minor version
-   - Format: `{NEXT_MINOR_VERSION}-beta.{COMMIT_COUNT}`
-   - Example: `0.43.0-beta.123` (if last tag is 0.42.x)
-   - Published as a prerelease to NuGet.org (Windows build only)
-
-### Workflow Steps
-
-The workflow runs on a matrix of operating systems (Windows and Ubuntu):
-
-1. **Checkout**: Fetches the repository with full history for version detection
-2. **Setup .NET**: Installs .NET 10.0
-3. **Determine Version**: Runs `determine-version` build target to check for tags and determine version
-4. **Update Version**: Runs `update-version` build target to update the version in the project file
-5. **Build and Test**: Runs the full build and test suite on both platforms
-6. **Upload Artifacts**: Uploads the generated `.nupkg` files as workflow artifacts (separate for each OS)
-7. **Push to NuGet**: (Windows only) Runs `push-to-nuget` build target to publish the package to NuGet.org using the API key
-
-All version detection, file updates, and publishing logic is implemented in C# in the `build/Program.cs` file using build targets.
-
-## Setup Requirements
-
-### 1. NuGet API Key Secret
-
-The workflow requires a `NUGET_API_KEY` secret to be configured in the repository settings:
-
-1. Go to https://www.nuget.org/account/apikeys
-2. Create a new API key with "Push" permission for the SharpCompress package
-3. In GitHub, go to: **Settings** → **Secrets and variables** → **Actions**
-4. Create a new secret named `NUGET_API_KEY` with the API key value
-
-### 2. Branch Protection (Recommended)
-
-Consider enabling branch protection rules for the `release` branch to ensure:
-- Code reviews are required before merging
-- Status checks pass before merging
-- Only authorized users can push to the branch
-
-## Usage
-
-### Creating a Stable Release
-
-There are two ways to trigger a stable release:
-
-**Method 1: Push tag to trigger workflow**
-1. Ensure all changes are committed on the `master` or `release` branch
-2. Create and push a version tag:
-   ```bash
-   git checkout master  # or release
-   git tag 0.43.0
-   git push origin 0.43.0
-   ```
-3. The workflow will automatically trigger, build, test, and publish `SharpCompress 0.43.0` to NuGet.org (Windows build)
-
-**Method 2: Tag after pushing to branch**
-1. Ensure all changes are merged and pushed to the `master` or `release` branch
-2. Create and push a version tag on the already-pushed commit:
-   ```bash
-   git checkout master  # or release
-   git tag 0.43.0
-   git push origin 0.43.0
-   ```
-3. The workflow will automatically trigger, build, test, and publish `SharpCompress 0.43.0` to NuGet.org (Windows build)
-
-### Creating a Prerelease
-
-1. Push changes to the `master` or `release` branch without tagging:
-   ```bash
-   git checkout master  # or release
-   git push origin master  # or release
-   ```
-2. The workflow will automatically:
-   - Build and test the project on both Windows and Ubuntu
-   - Publish a prerelease version like `0.43.0-beta.456` to NuGet.org (Windows build)
-
-## Troubleshooting
-
-### Workflow Fails to Push to NuGet
-
-- **Check the API Key**: Ensure `NUGET_API_KEY` is set correctly in repository secrets
-- **Check API Key Permissions**: Verify the API key has "Push" permission for SharpCompress
-- **Check API Key Expiration**: NuGet API keys may expire; create a new one if needed
-
-### Version Conflict
-
-If you see "Package already exists" errors:
-- The workflow uses `--skip-duplicate` flag to handle this gracefully
-- If you need to republish the same version, delete it from NuGet.org first (if allowed)
-
-### Build or Test Failures
-
-- The workflow will not push to NuGet if build or tests fail
-- Check the workflow logs in GitHub Actions for details
-- Fix the issues and push again
-
-## Manual Package Creation
-
-If you need to create a package manually without publishing:
-
-```bash
-dotnet run --project build/build.csproj -- publish
-```
-
-The package will be created in the `artifacts/` directory.
-
-## Build Targets
-
-The workflow uses the following C# build targets defined in `build/Program.cs`:
-
-- **determine-version**: Detects version from git tags and outputs VERSION and PRERELEASE variables
-- **update-version**: Updates VersionPrefix, AssemblyVersion, and FileVersion in the project file
-- **push-to-nuget**: Pushes the generated NuGet packages to NuGet.org (requires NUGET_API_KEY)
-
-These targets can be run manually for testing:
-
-```bash
-# Determine the version
-dotnet run --project build/build.csproj -- determine-version
-
-# Update version in project file
-VERSION=0.43.0 dotnet run --project build/build.csproj -- update-version
-
-# Push to NuGet (requires NUGET_API_KEY environment variable)
-NUGET_API_KEY=your-key dotnet run --project build/build.csproj -- push-to-nuget
-```
-
-## Related Files
-
-- `.github/workflows/nuget-release.yml` - The workflow definition
-- `build/Program.cs` - Build script with version detection and publishing logic
-- `src/SharpCompress/SharpCompress.csproj` - Project file with version information

.github/workflows/TESTING.md

@@ -1,120 +0,0 @@
-# Testing Guide for NuGet Release Workflow
-
-This document describes how to test the NuGet release workflow.
-
-## Testing Strategy
-
-Since this workflow publishes to NuGet.org and requires repository secrets, testing should be done carefully. The workflow runs on both Windows and Ubuntu, but only the Windows build publishes to NuGet.
-
-## Pre-Testing Checklist
-
-- [x] Workflow YAML syntax validated
-- [x] Version determination logic tested locally
-- [x] Version update logic tested locally
-- [x] Build script works (`dotnet run --project build/build.csproj`)
-
-## Manual Testing Steps
-
-### 1. Test Prerelease Publishing (Recommended First Test)
-
-This tests the workflow on untagged commits to the master or release branch.
-
-**Steps:**
-1. Ensure `NUGET_API_KEY` secret is configured in repository settings
-2. Create a test commit on the `master` or `release` branch (e.g., update a comment or README)
-3. Push to the `master` or `release` branch
-4. Monitor the GitHub Actions workflow at: https://github.com/adamhathcock/sharpcompress/actions
-5. Verify:
-   - Workflow triggers and runs successfully on both Windows and Ubuntu
-   - Version is determined correctly (e.g., `0.43.0-beta.XXX` if last tag is 0.42.x)
-   - Build and tests pass on both platforms
-   - Package artifacts are uploaded for both platforms
-   - Package is pushed to NuGet.org as prerelease (Windows build only)
-
-**Expected Outcome:**
-- A new prerelease package appears on NuGet.org: https://www.nuget.org/packages/SharpCompress/
-- Package version follows pattern: `{NEXT_MINOR_VERSION}-beta.{COMMIT_COUNT}`
-
-### 2. Test Tagged Release Publishing
-
-This tests the workflow when a version tag is pushed.
-
-**Steps:**
-1. Prepare the `master` or `release` branch with all desired changes
-2. Create a version tag (must be a pure semantic version like `MAJOR.MINOR.PATCH`):
-   ```bash
-   git checkout master  # or release
-   git tag 0.42.2
-   git push origin 0.42.2
-   ```
-3. Monitor the GitHub Actions workflow
-4. Verify:
-   - Workflow triggers and runs successfully on both Windows and Ubuntu
-   - Version is determined as the tag (e.g., `0.42.2`)
-   - Build and tests pass on both platforms
-   - Package artifacts are uploaded for both platforms
-   - Package is pushed to NuGet.org as stable release (Windows build only)
-
-**Expected Outcome:**
-- A new stable release package appears on NuGet.org
-- Package version matches the tag
-
-### 3. Test Duplicate Package Handling
-
-This tests the `--skip-duplicate` flag behavior.
-
-**Steps:**
-1. Push to the `release` branch without making changes
-2. Monitor the workflow
-3. Verify:
-   - Workflow runs but NuGet push is skipped with "duplicate" message
-   - No errors occur
-
-### 4. Test Build Failure Handling
-
-This tests that failed builds don't publish packages.
-
-**Steps:**
-1. Introduce a breaking change in a test or code
-2. Push to the `release` branch
-3. Verify:
-   - Workflow runs and detects the failure
-   - Build or test step fails
-   - NuGet push step is skipped
-   - No package is published
-
-## Verification
-
-After each test, verify:
-
-1. **GitHub Actions Logs**: Check the workflow logs for any errors or warnings
-2. **NuGet.org**: Verify the package appears with correct version and metadata
-3. **Artifacts**: Download and inspect the uploaded artifacts
-
-## Rollback/Cleanup
-
-If testing produces unwanted packages:
-
-1. **Prerelease packages**: Can be unlisted on NuGet.org (Settings → Unlist)
-2. **Stable packages**: Cannot be deleted, only unlisted (use test versions)
-3. **Tags**: Can be deleted with:
-   ```bash
-   git tag -d 0.42.2
-   git push origin :refs/tags/0.42.2
-   ```
-
-## Known Limitations
-
-- NuGet.org does not allow re-uploading the same version
-- Deleted packages on NuGet.org reserve the version number
-- The workflow requires the `NUGET_API_KEY` secret to be set
-
-## Success Criteria
-
-The workflow is considered successful if:
-
-- ✅ Prerelease versions are published correctly with beta suffix
-- ✅ Tagged versions are published as stable releases
-- ✅ Build and test failures prevent publishing
-- ✅ Duplicate packages are handled gracefully
-- ✅ Workflow logs are clear and informative

.github/workflows/dotnetcore.yml

@@ -0,0 +1,25 @@
+name: SharpCompress
+on:
+  push:
+    branches:
+      - 'master'
+  pull_request:
+    types: [ opened, synchronize, reopened, ready_for_review ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest, ubuntu-latest]
+
+    steps:
+    - uses: actions/checkout@v6
+    - uses: actions/setup-dotnet@v5
+      with:
+        dotnet-version: 10.0.x
+    - run: dotnet run --project build/build.csproj
+    - uses: actions/upload-artifact@v5
+      with:
+        name: ${{ matrix.os }}-sharpcompress.nupkg
+        path: artifacts/*

.github/workflows/nuget-release.yml

@@ -1,61 +0,0 @@
-name: NuGet Release
-
-on:
-  push:
-    branches:
-      - 'master'
-      - 'release'
-    tags:
-      - '[0-9]+.[0-9]+.[0-9]+'
-  pull_request:
-    branches:
-      - 'master'
-      - 'release'
-
-permissions:
-  contents: read
-
-jobs:
-  build-and-publish:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [windows-latest, ubuntu-latest]
-    
-    steps:
-    - uses: actions/checkout@v6
-      with:
-        fetch-depth: 0  # Fetch all history for versioning
-    
-    - uses: actions/setup-dotnet@v5
-      with:
-        dotnet-version: 10.0.x
-    
-    # Determine version using C# build target
-    - name: Determine Version
-      id: version
-      run: dotnet run --project build/build.csproj -- determine-version
-    
-    # Update version in project file using C# build target
-    - name: Update Version in Project
-      run: dotnet run --project build/build.csproj -- update-version
-      env:
-        VERSION: ${{ steps.version.outputs.version }}
-    
-    # Build and test
-    - name: Build and Test
-      run: dotnet run --project build/build.csproj
-    
-    # Upload artifacts for verification
-    - name: Upload NuGet Package
-      uses: actions/upload-artifact@v6
-      with:
-        name: ${{ matrix.os }}-nuget-package
-        path: artifacts/*.nupkg
-    
-    # Push to NuGet.org using C# build target (Windows only, not on PRs)
-    - name: Push to NuGet
-      if: success() && matrix.os == 'windows-latest' && github.event_name != 'pull_request'
-      run: dotnet run --project build/build.csproj -- push-to-nuget
-      env:
-        NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }}

.gitignore

@@ -15,8 +15,8 @@ tests/TestArchives/*/Scratch
 tests/TestArchives/*/Scratch2
 .vs
 tools
+.vscode
 .idea/
-artifacts/
 
 .DS_Store
 *.snupkg

.vscode/extensions.json

@@ -1,9 +0,0 @@
-{
-  "recommendations": [
-    "ms-dotnettools.csdevkit",
-    "ms-dotnettools.csharp",
-    "ms-dotnettools.vscode-dotnet-runtime",
-    "csharpier.csharpier-vscode",
-    "formulahendry.dotnet-test-explorer"
-  ]
-}

.vscode/launch.json

@@ -1,97 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Debug Tests (net10.0)",
-      "type": "coreclr",
-      "request": "launch",
-      "preLaunchTask": "build",
-      "program": "dotnet",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net10.0",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    },
-    {
-      "name": "Debug Specific Test (net10.0)",
-      "type": "coreclr",
-      "request": "launch",
-      "preLaunchTask": "build",
-      "program": "dotnet",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net10.0",
-        "--no-build",
-        "--filter",
-        "FullyQualifiedName~${input:testName}"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    },
-    {
-      "name": "Debug Performance Tests",
-      "type": "coreclr",
-      "request": "launch",
-      "preLaunchTask": "build",
-      "program": "dotnet",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/tests/SharpCompress.Performance/SharpCompress.Performance.csproj",
-        "--no-build"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    },
-    {
-      "name": "Debug Build Script",
-      "type": "coreclr",
-      "request": "launch",
-      "program": "dotnet",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/build/build.csproj",
-        "--",
-        "${input:buildTarget}"
-      ],
-      "cwd": "${workspaceFolder}",
-      "console": "internalConsole",
-      "stopAtEntry": false
-    }
-  ],
-  "inputs": [
-    {
-      "id": "testName",
-      "type": "promptString",
-      "description": "Enter test name or pattern (e.g., TestMethodName or ClassName)",
-      "default": ""
-    },
-    {
-      "id": "buildTarget",
-      "type": "pickString",
-      "description": "Select build target",
-      "options": [
-        "clean",
-        "restore",
-        "build",
-        "test",
-        "format",
-        "publish",
-        "default"
-      ],
-      "default": "build"
-    }
-  ]
-}

.vscode/settings.json

@@ -1,29 +0,0 @@
-{
-  "dotnet.defaultSolution": "SharpCompress.sln",
-  "files.exclude": {
-    "**/bin": true,
-    "**/obj": true
-  },
-  "files.watcherExclude": {
-    "**/bin/**": true,
-    "**/obj/**": true,
-    "**/artifacts/**": true
-  },
-  "search.exclude": {
-    "**/bin": true,
-    "**/obj": true,
-    "**/artifacts": true
-  },
-  "editor.formatOnSave": false,
-  "[csharp]": {
-    "editor.defaultFormatter": "csharpier.csharpier-vscode",
-    "editor.formatOnSave": true,
-    "editor.codeActionsOnSave": {
-      "source.fixAll": "explicit"
-    }
-  },
-  "csharpier.enableDebugLogs": false,
-  "omnisharp.enableRoslynAnalyzers": true,
-  "omnisharp.enableEditorConfigSupport": true,
-  "dotnet-test-explorer.testProjectPath": "tests/**/*.csproj"
-}

.vscode/tasks.json

@@ -1,178 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "build",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "build",
-        "${workspaceFolder}/SharpCompress.sln",
-        "/property:GenerateFullPaths=true",
-        "/consoleloggerparameters:NoSummary;ForceNoAlign"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": {
-        "kind": "build",
-        "isDefault": true
-      }
-    },
-    {
-      "label": "build-release",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "build",
-        "${workspaceFolder}/SharpCompress.sln",
-        "-c",
-        "Release",
-        "/property:GenerateFullPaths=true",
-        "/consoleloggerparameters:NoSummary;ForceNoAlign"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "build"
-    },
-    {
-      "label": "build-library",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "build",
-        "${workspaceFolder}/src/SharpCompress/SharpCompress.csproj",
-        "/property:GenerateFullPaths=true",
-        "/consoleloggerparameters:NoSummary;ForceNoAlign"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "build"
-    },
-    {
-      "label": "restore",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "restore",
-        "${workspaceFolder}/SharpCompress.sln"
-      ],
-      "problemMatcher": "$msCompile"
-    },
-    {
-      "label": "clean",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "clean",
-        "${workspaceFolder}/SharpCompress.sln"
-      ],
-      "problemMatcher": "$msCompile"
-    },
-    {
-      "label": "test",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": {
-        "kind": "test",
-        "isDefault": true
-      },
-      "dependsOn": "build"
-    },
-    {
-      "label": "test-net10",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net10.0",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "test",
-      "dependsOn": "build"
-    },
-    {
-      "label": "test-net48",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "test",
-        "${workspaceFolder}/tests/SharpCompress.Test/SharpCompress.Test.csproj",
-        "-f",
-        "net48",
-        "--no-build",
-        "--verbosity=normal"
-      ],
-      "problemMatcher": "$msCompile",
-      "group": "test",
-      "dependsOn": "build"
-    },
-    {
-      "label": "format",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "csharpier",
-        "."
-      ],
-      "problemMatcher": []
-    },
-    {
-      "label": "format-check",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "csharpier",
-        "check",
-        "."
-      ],
-      "problemMatcher": []
-    },
-    {
-      "label": "run-build-script",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/build/build.csproj"
-      ],
-      "problemMatcher": "$msCompile"
-    },
-    {
-      "label": "pack",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "pack",
-        "${workspaceFolder}/src/SharpCompress/SharpCompress.csproj",
-        "-c",
-        "Release",
-        "-o",
-        "${workspaceFolder}/artifacts/"
-      ],
-      "problemMatcher": "$msCompile",
-      "dependsOn": "build-release"
-    },
-    {
-      "label": "performance-tests",
-      "command": "dotnet",
-      "type": "process",
-      "args": [
-        "run",
-        "--project",
-        "${workspaceFolder}/tests/SharpCompress.Performance/SharpCompress.Performance.csproj",
-        "-c",
-        "Release"
-      ],
-      "problemMatcher": "$msCompile"
-    }
-  ]
-}

AGENTS.md

@@ -28,38 +28,14 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 
 ## Code Formatting
 
-**Copilot agents: You MUST run the `format` task after making code changes to ensure consistency.**
-
 - Use CSharpier for code formatting to ensure consistent style across the project
 - CSharpier is configured as a local tool in `.config/dotnet-tools.json`
-
-### Commands
-
-1. **Restore tools** (first time only):
-   ```bash
-   dotnet tool restore
-   ```
-
-2. **Check if files are formatted correctly** (doesn't modify files):
-   ```bash
-   dotnet csharpier check .
-   ```
-   - Exit code 0: All files are properly formatted
-   - Exit code 1: Some files need formatting (will show which files and differences)
-
-3. **Format files** (modifies files):
-   ```bash
-   dotnet csharpier format .
-   ```
-   - Formats all files in the project to match CSharpier style
-   - Run from project root directory
-
-4. **Configure your IDE** to format on save using CSharpier for the best experience
-
-### Additional Notes
+- Restore tools with: `dotnet tool restore`
+- Format files from the project root with: `dotnet csharpier .`
+- **Run `dotnet csharpier .` from the project root after making code changes before committing**
+- Configure your IDE to format on save using CSharpier for the best experience
 - The project also uses `.editorconfig` for editor settings (indentation, encoding, etc.)
 - Let CSharpier handle code style while `.editorconfig` handles editor behavior
-- Always run `dotnet csharpier check .` before committing to verify formatting
 
 ## Project Setup and Structure
 
@@ -73,30 +49,6 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 - Use `dotnet test` to run tests
 - Solution file: `SharpCompress.sln`
 
-### Directory Structure
-```
-src/SharpCompress/
-  ├── Archives/        # IArchive implementations (Zip, Tar, Rar, 7Zip, GZip)
-  ├── Readers/         # IReader implementations (forward-only)
-  ├── Writers/         # IWriter implementations (forward-only)
-  ├── Compressors/     # Low-level compression streams (BZip2, Deflate, LZMA, etc.)
-  ├── Factories/       # Format detection and factory pattern
-  ├── Common/          # Shared types (ArchiveType, Entry, Options)
-  ├── Crypto/          # Encryption implementations
-  └── IO/              # Stream utilities and wrappers
-
-tests/SharpCompress.Test/
-  ├── Zip/, Tar/, Rar/, SevenZip/, GZip/, BZip2/  # Format-specific tests
-  ├── TestBase.cs      # Base test class with helper methods
-  └── TestArchives/    # Test data (not checked into main test project)
-```
-
-### Factory Pattern
-All format types implement factory interfaces (`IArchiveFactory`, `IReaderFactory`, `IWriterFactory`) for auto-detection:
-- `ReaderFactory.Open()` - Auto-detects format by probing stream
-- `WriterFactory.Open()` - Creates writer for specified `ArchiveType`
-- Factories located in: `src/SharpCompress/Factories/`
-
 ## Nullable Reference Types
 
 - Declare variables non-nullable, and check for `null` at entry points.
@@ -164,18 +116,3 @@ SharpCompress supports multiple archive and compression formats:
 - Use test archives from `tests/TestArchives` directory for consistency.
 - Test stream disposal and `LeaveStreamOpen` behavior.
 - Test edge cases: empty archives, large files, corrupted archives, encrypted archives.
-
-### Test Organization
-- Base class: `TestBase` - Provides `TEST_ARCHIVES_PATH`, `SCRATCH_FILES_PATH`, temp directory management
-- Framework: xUnit with AwesomeAssertions
-- Test archives: `tests/TestArchives/` - Use existing archives, don't create new ones unnecessarily
-- Match naming style of nearby test files
-
-## Common Pitfalls
-
-1. **Don't mix Archive and Reader APIs** - Archive needs seekable stream, Reader doesn't
-2. **Solid archives (Rar, 7Zip)** - Use `ExtractAllEntries()` for best performance, not individual entry extraction
-3. **Stream disposal** - Always set `LeaveStreamOpen` explicitly when needed (default is to close)
-4. **Tar + non-seekable stream** - Must provide file size or it will throw
-5. **Multi-framework differences** - Some features differ between .NET Framework and modern .NET (e.g., Mono.Posix)
-6. **Format detection** - Use `ReaderFactory.Open()` for auto-detection, test with actual archive files

Directory.Packages.props

@@ -1,19 +1,21 @@
 <Project>
   <ItemGroup>
-    <PackageVersion Include="Bullseye" Version="6.1.0" />
+    <PackageVersion Include="Bullseye" Version="6.0.0" />
     <PackageVersion Include="AwesomeAssertions" Version="9.3.0" />
     <PackageVersion Include="Glob" Version="1.1.9" />
-    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.15" />
+    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.14" />
     <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
-    <PackageVersion Include="SimpleExec" Version="13.0.0" />
-    <PackageVersion Include="System.Text.Encoding.CodePages" Version="10.0.0" />
+    <PackageVersion Include="SimpleExec" Version="12.0.0" />
     <PackageVersion Include="System.Buffers" Version="4.6.1" />
     <PackageVersion Include="System.Memory" Version="4.6.3" />
+    <PackageVersion Include="System.Text.Encoding.CodePages" Version="10.0.0" />
     <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.102" />
-    <GlobalPackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
+    <PackageVersion Include="ZstdSharp.Port" Version="0.8.6" />
+    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
   </ItemGroup>
 </Project>

FORMATS.md

@@ -10,10 +10,7 @@
 
 | Archive Format         | Compression Format(s)                             | Compress/Decompress | Archive API     | Reader API | Writer API    |
 | ---------------------- | ------------------------------------------------- | ------------------- | --------------- | ---------- | ------------- |
-| Ace                    | None                                              | Decompress          | N/A             | AceReader  | N/A           |
-| Arc                    | None, Packed, Squeezed, Crunched                  | Decompress          | N/A             | ArcReader  | N/A           |
-| Arj                    | None                                              | Decompress          | N/A             | ArjReader  | N/A           |
-| Rar                    | Rar                                               | Decompress          | RarArchive      | RarReader  | N/A           |
+| Rar                    | Rar                                               | Decompress (1)      | RarArchive      | RarReader  | N/A           |
 | Zip (2)                | None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd                           | Both                | ZipArchive      | ZipReader  | ZipWriter     | 
 | Tar                    | None                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.GZip               | DEFLATE                                           | Both                | TarArchive      | TarReader  | TarWriter (3) |
@@ -27,7 +24,7 @@
 1. SOLID Rars are only supported in the RarReader API.
 2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading. See [Zip Format Notes](#zip-format-notes) for details on multi-volume archives and streaming behavior.
 3. The Tar format requires a file size in the header. If no size is specified to the TarWriter and the stream is not seekable, then an exception will be thrown.
-4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API. See [7Zip Format Notes](#7zip-format-notes) for details on async extraction behavior.
+4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API
 5. LZip has no support for extra data like the file name or timestamp. There is a default filename used when looking at the entry Key on the archive.
 
 ### Zip Format Notes
@@ -35,18 +32,6 @@
 - Multi-volume/split ZIP archives require ZipArchive (seekable streams) as ZipReader cannot seek across volume files.
 - ZipReader processes entries from LocalEntry headers (which include directory entries ending with `/`) and intentionally skips DirectoryEntry headers from the central directory, as they are redundant in streaming mode - all entry data comes from LocalEntry headers which ZipReader has already processed.
 
-### 7Zip Format Notes
-
-- **Async Extraction Performance**: When using async extraction methods (e.g., `ExtractAllEntries()` with `MoveToNextEntryAsync()`), each file creates its own decompression stream to avoid state corruption in the LZMA decoder. This is less efficient than synchronous extraction, which can reuse a single decompression stream for multiple files in the same folder.
-  
-  **Performance Impact**: For archives with many small files in the same compression folder, async extraction will be slower than synchronous extraction because it must:
-  1. Create a new LZMA decoder for each file
-  2. Skip through the decompressed data to reach each file's starting position
-  
-  **Recommendation**: For best performance with 7Zip archives, use synchronous extraction methods (`MoveToNextEntry()` and `WriteEntryToDirectory()`) when possible. Use async methods only when you need to avoid blocking the thread (e.g., in UI applications or async-only contexts).
-  
-  **Technical Details**: 7Zip archives group files into "folders" (compression units), where all files in a folder share one continuous LZMA-compressed stream. The LZMA decoder maintains internal state (dictionary window, decoder positions) that assumes sequential, non-interruptible processing. Async operations can yield control during awaits, which would corrupt this shared state. To avoid this, async extraction creates a fresh decoder stream for each file.
-
 ## Compression Streams
 
 For those who want to directly compress/decompress bits. The single file formats are represented here as well. However, BZip2, LZip and XZ have no metadata (GZip has a little) so using them without something like a Tar file makes little sense.

OLD_CHANGELOG.md

@@ -1,142 +0,0 @@
-
-# Version Log
-
-* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
-
-## Version 0.18
-
-* [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
-
-## Version 0.17.1
-
-* Fix - [Bug Fix for .NET Core on Windows](https://github.com/adamhathcock/sharpcompress/pull/257)
-
-## Version 0.17.0
-
-* New - Full LZip support! Can read and write LZip files and Tars inside LZip files. [Make LZip a first class citizen. #241](https://github.com/adamhathcock/sharpcompress/issues/241)
-* New - XZ read support! Can read XZ files and Tars inside XZ files. [XZ in SharpCompress #91](https://github.com/adamhathcock/sharpcompress/issues/94)
-* Fix - [Regression - zip file writing on seekable streams always assumed stream start was 0. Introduced with Zip64 writing.](https://github.com/adamhathcock/sharpcompress/issues/244)
-* Fix - [Zip files with post-data descriptors can be properly skipped via decompression](https://github.com/adamhathcock/sharpcompress/issues/162)
-
-## Version 0.16.2
-
-* Fix [.NET 3.5 should support files and cryptography (was a regression from 0.16.0)](https://github.com/adamhathcock/sharpcompress/pull/251)
-* Fix [Zip per entry compression customization wrote the wrong method into the zip archive](https://github.com/adamhathcock/sharpcompress/pull/249)
-
-## Version 0.16.1
-
-* Fix [Preserve compression method when getting a compressed stream](https://github.com/adamhathcock/sharpcompress/pull/235)
-* Fix [RAR entry key normalization fix](https://github.com/adamhathcock/sharpcompress/issues/201)
-
-## Version 0.16.0
-
-* Breaking - [Progress Event Tracking rethink](https://github.com/adamhathcock/sharpcompress/pull/226)
-* Update to VS2017 - [VS2017](https://github.com/adamhathcock/sharpcompress/pull/231) - Framework targets have been changed.
-* New - [Add Zip64 writing](https://github.com/adamhathcock/sharpcompress/pull/211)
-* [Fix invalid/mismatching Zip version flags.](https://github.com/adamhathcock/sharpcompress/issues/164) - This allows nuget/System.IO.Packaging to read zip files generated by SharpCompress
-* [Fix 7Zip directory hiding](https://github.com/adamhathcock/sharpcompress/pull/215/files)
-* [Verify RAR CRC headers](https://github.com/adamhathcock/sharpcompress/pull/220)
-
-## Version 0.15.2
-
-* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
-
-## Version 0.15.1
-
-* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
-
-## Version 0.15.0
-
-* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
-
-## Version 0.14.1
-
-* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
-* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
-* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
-
-## Version 0.14.0
-
-* [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)
-
-## Version 0.13.1
-
-* [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
-* [Make PpmdProperties lazy to avoid unnecessary allocations.](https://github.com/adamhathcock/sharpcompress/pull/185)
-
-## Version 0.13.0
-
-* Breaking change: Big refactor of Options on API.
-* 7Zip supports Deflate
-
-## Version 0.12.4
-
-* Forward only zip issue fix https://github.com/adamhathcock/sharpcompress/issues/160
-* Try to fix frameworks again by copying targets from JSON.NET
-
-## Version 0.12.3
-
-* 7Zip fixes https://github.com/adamhathcock/sharpcompress/issues/73
-* Maybe all profiles will work with project.json now
-
-## Version 0.12.2
-
-* Support Profile 259 again
-
-## Version 0.12.1
-
-* Support Silverlight 5
-
-## Version 0.12.0
-
-* .NET Core RTM!
-* Bug fix for Tar long paths
-
-## Version 0.11.6
-
-* Bug fix for global header in Tar
-* Writers now have a leaveOpen `bool` overload. They won't close streams if not-requested to.
-
-## Version 0.11.5
-
-* Bug fix in Skip method
-
-## Version 0.11.4
-
-* SharpCompress is now endian neutral (matters for Mono platforms)
-* Fix for Inflate (need to change implementation)
-* Fixes for RAR detection
-
-## Version 0.11.1
-
-* Added Cancel on IReader
-* Removed .NET 2.0 support and LinqBridge dependency
-
-## Version 0.11
-
-* Been over a year, contains mainly fixes from contributors!
-* Possible breaking change: ArchiveEncoding is UTF8 by default now.
-* TAR supports writing long names using longlink
-* RAR Protect Header added
-
-## Version 0.10.3
-
-* Finally fixed Disposal issue when creating a new archive with the Archive API
-
-## Version 0.10.2
-
-* Fixed Rar Header reading for invalid extended time headers.
-* Windows Store assembly is now strong named
-* Known issues with Long Tar names being worked on
-* Updated to VS2013
-* Portable targets SL5 and Windows Phone 8 (up from SL4 and WP7)
-
-## Version 0.10.1
-
-* Fixed 7Zip extraction performance problem
-
-## Version 0.10:
-
-* Added support for RAR Decryption (thanks to https://github.com/hrasyid)
-* Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
-* Built in Release (I think)

README.md

@@ -4,7 +4,7 @@ SharpCompress is a compression library in pure C# for .NET Framework 4.8, .NET 8
 
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 
-**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [USAGE.md](USAGE.md#async-examples) for examples.
+**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [Async Usage](#async-usage) section below.
 
 GitHub Actions Build -
 [![SharpCompress](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml/badge.svg)](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml)
@@ -34,11 +34,235 @@ Hi everyone. I hope you're using SharpCompress and finding it useful. Please giv
 
 Please do not email me directly to ask for help. If you think there is a real issue, please report it here.
 
+## Async Usage
+
+SharpCompress now provides full async/await support for all I/O operations, allowing for better performance and scalability in modern applications.
+
+### Async Reading Examples
+
+Extract entries asynchronously:
+```csharp
+using (Stream stream = File.OpenRead("archive.zip"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            // Async extraction
+            await reader.WriteEntryToDirectoryAsync(
+                @"C:\temp",
+                new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+                cancellationToken
+            );
+        }
+    }
+}
+```
+
+Extract all entries to directory asynchronously:
+```csharp
+using (Stream stream = File.OpenRead("archive.tar.gz"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    await reader.WriteAllToDirectoryAsync(
+        @"C:\temp",
+        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+        cancellationToken
+    );
+}
+```
+
+Open entry stream asynchronously:
+```csharp
+using (var archive = ZipArchive.Open("archive.zip"))
+{
+    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
+    {
+        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+        {
+            // Process stream asynchronously
+            await entryStream.CopyToAsync(outputStream, cancellationToken);
+        }
+    }
+}
+```
+
+### Async Writing Examples
+
+Write files asynchronously:
+```csharp
+using (Stream stream = File.OpenWrite("output.zip"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
+{
+    await writer.WriteAsync("file1.txt", fileStream, DateTime.Now, cancellationToken);
+}
+```
+
+Write all files from directory asynchronously:
+```csharp
+using (Stream stream = File.OpenWrite("output.tar.gz"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
+{
+    await writer.WriteAllAsync(@"D:\files", "*", SearchOption.AllDirectories, cancellationToken);
+}
+```
+
+All async methods support `CancellationToken` for graceful cancellation of long-running operations.
+
 ## Want to contribute?
 
 I'm always looking for help or ideas. Please submit code or email with ideas. Unfortunately, just letting me know you'd like to help is not enough because I really have no overall plan of what needs to be done. I'll definitely accept code submissions and add you as a member of the project!
 
-## Notes
+## TODOs (always lots)
+
+* RAR 5 decryption crc check support
+* 7Zip writing
+* Zip64 (Need writing and extend Reading)
+* Multi-volume Zip support.
+* ZStandard writing
+
+## Version Log
+
+* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
+
+### Version 0.18
+
+* [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
+
+### Version 0.17.1
+
+* Fix - [Bug Fix for .NET Core on Windows](https://github.com/adamhathcock/sharpcompress/pull/257)
+
+### Version 0.17.0
+
+* New - Full LZip support! Can read and write LZip files and Tars inside LZip files. [Make LZip a first class citizen. #241](https://github.com/adamhathcock/sharpcompress/issues/241)
+* New - XZ read support! Can read XZ files and Tars inside XZ files. [XZ in SharpCompress #91](https://github.com/adamhathcock/sharpcompress/issues/94)
+* Fix - [Regression - zip file writing on seekable streams always assumed stream start was 0. Introduced with Zip64 writing.](https://github.com/adamhathcock/sharpcompress/issues/244)
+* Fix - [Zip files with post-data descriptors can be properly skipped via decompression](https://github.com/adamhathcock/sharpcompress/issues/162)
+
+### Version 0.16.2
+
+* Fix [.NET 3.5 should support files and cryptography (was a regression from 0.16.0)](https://github.com/adamhathcock/sharpcompress/pull/251)
+* Fix [Zip per entry compression customization wrote the wrong method into the zip archive](https://github.com/adamhathcock/sharpcompress/pull/249)
+
+### Version 0.16.1
+
+* Fix [Preserve compression method when getting a compressed stream](https://github.com/adamhathcock/sharpcompress/pull/235)
+* Fix [RAR entry key normalization fix](https://github.com/adamhathcock/sharpcompress/issues/201)
+
+### Version 0.16.0
+
+* Breaking - [Progress Event Tracking rethink](https://github.com/adamhathcock/sharpcompress/pull/226)
+* Update to VS2017 - [VS2017](https://github.com/adamhathcock/sharpcompress/pull/231) - Framework targets have been changed.
+* New - [Add Zip64 writing](https://github.com/adamhathcock/sharpcompress/pull/211)
+* [Fix invalid/mismatching Zip version flags.](https://github.com/adamhathcock/sharpcompress/issues/164) - This allows nuget/System.IO.Packaging to read zip files generated by SharpCompress
+* [Fix 7Zip directory hiding](https://github.com/adamhathcock/sharpcompress/pull/215/files)
+* [Verify RAR CRC headers](https://github.com/adamhathcock/sharpcompress/pull/220)
+
+### Version 0.15.2
+
+* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
+
+### Version 0.15.1
+
+* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
+
+### Version 0.15.0
+
+* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
+
+### Version 0.14.1
+
+* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
+* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
+* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
+
+### Version 0.14.0
+
+* [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)
+
+### Version 0.13.1
+
+* [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
+* [Make PpmdProperties lazy to avoid unnecessary allocations.](https://github.com/adamhathcock/sharpcompress/pull/185)
+
+### Version 0.13.0
+
+* Breaking change: Big refactor of Options on API.
+* 7Zip supports Deflate
+
+### Version 0.12.4
+
+* Forward only zip issue fix https://github.com/adamhathcock/sharpcompress/issues/160
+* Try to fix frameworks again by copying targets from JSON.NET
+
+### Version 0.12.3
+
+* 7Zip fixes https://github.com/adamhathcock/sharpcompress/issues/73
+* Maybe all profiles will work with project.json now
+
+### Version 0.12.2
+
+* Support Profile 259 again
+
+### Version 0.12.1
+
+* Support Silverlight 5
+
+### Version 0.12.0
+
+* .NET Core RTM!
+* Bug fix for Tar long paths
+
+### Version 0.11.6
+
+* Bug fix for global header in Tar
+* Writers now have a leaveOpen `bool` overload. They won't close streams if not-requested to.
+
+### Version 0.11.5
+
+* Bug fix in Skip method
+
+### Version 0.11.4
+
+* SharpCompress is now endian neutral (matters for Mono platforms)
+* Fix for Inflate (need to change implementation)
+* Fixes for RAR detection
+
+### Version 0.11.1
+
+* Added Cancel on IReader
+* Removed .NET 2.0 support and LinqBridge dependency
+
+### Version 0.11
+
+* Been over a year, contains mainly fixes from contributors!
+* Possible breaking change: ArchiveEncoding is UTF8 by default now.
+* TAR supports writing long names using longlink
+* RAR Protect Header added
+
+### Version 0.10.3
+
+* Finally fixed Disposal issue when creating a new archive with the Archive API
+
+### Version 0.10.2
+
+* Fixed Rar Header reading for invalid extended time headers.
+* Windows Store assembly is now strong named
+* Known issues with Long Tar names being worked on
+* Updated to VS2013
+* Portable targets SL5 and Windows Phone 8 (up from SL4 and WP7)
+
+### Version 0.10.1
+
+* Fixed 7Zip extraction performance problem
+
+### Version 0.10:
+
+* Added support for RAR Decryption (thanks to https://github.com/hrasyid)
+* Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
+* Built in Release (I think)
 
 XZ implementation based on: https://github.com/sambott/XZ.NET by @sambott
 

SharpCompress.sln

@@ -20,7 +20,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425
 		.editorconfig = .editorconfig
 		Directory.Packages.props = Directory.Packages.props
 		NuGet.config = NuGet.config
-		.github\workflows\nuget-release.yml = .github\workflows\nuget-release.yml
+		.github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml
 		USAGE.md = USAGE.md
 		README.md = README.md
 		FORMATS.md = FORMATS.md

USAGE.md

@@ -87,17 +87,20 @@ memoryStream.Position = 0;
 ### Extract all files from a rar file to a directory using RarArchive
 
 Note: Extracting a solid rar or 7z file needs to be done in sequential order to get acceptable decompression speed.
-`ExtractAllEntries` is primarily intended for solid archives (like solid Rar) or 7Zip archives, where sequential extraction provides the best performance. For general/simple extraction with any supported archive type, use `archive.WriteToDirectory()` instead.
+It is explicitly recommended to use `ExtractAllEntries` when extracting an entire `IArchive` instead of iterating over all its `Entries`.
+Alternatively, use `IArchive.WriteToDirectory`.
 
 ```C#
 using (var archive = RarArchive.Open("Test.rar"))
 {
-    // Simple extraction with RarArchive; this WriteToDirectory pattern works for all archive types
-    archive.WriteToDirectory(@"D:\temp", new ExtractionOptions()
+    using (var reader = archive.ExtractAllEntries())
     {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
+        reader.WriteAllToDirectory(@"D:\temp", new ExtractionOptions()
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        });
+    }
 }
 ```
 
@@ -113,29 +116,6 @@ using (var archive = RarArchive.Open("Test.rar"))
 }
 ```
 
-### Extract solid Rar or 7Zip archives with progress reporting
-
-`ExtractAllEntries` only works for solid archives (Rar) or 7Zip archives. For optimal performance with these archive types, use this method:
-
-```C#
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-var progress = new Progress<ProgressReport>(report =>
-{
-    Console.WriteLine($"Extracting {report.EntryPath}: {report.PercentComplete}%");
-});
-
-using (var archive = RarArchive.Open("archive.rar", new ReaderOptions { Progress = progress })) // Must be solid Rar or 7Zip
-{
-    archive.WriteToDirectory(@"D:\output", new ExtractionOptions()
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
-}
-```
-
 ### Use ReaderFactory to autodetect archive type and Open the entry stream
 
 ```C#
@@ -318,12 +298,14 @@ using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.
 ```C#
 using (var archive = ZipArchive.Open("archive.zip"))
 {
-    // Simple async extraction - works for all archive types
-    await archive.WriteToDirectoryAsync(
-        @"C:\output",
-        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-        cancellationToken
-    );
+    using (var reader = archive.ExtractAllEntries())
+    {
+        await reader.WriteAllToDirectoryAsync(
+            @"C:\output",
+            new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+            cancellationToken
+        );
+    }
 }
 ```
 

build/Program.cs

@@ -1,10 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 using GlobExpressions;
 using static Bullseye.Targets;
 using static SimpleExec.Command;
@@ -14,11 +11,7 @@ const string Restore = "restore";
 const string Build = "build";
 const string Test = "test";
 const string Format = "format";
-const string CheckFormat = "check-format";
 const string Publish = "publish";
-const string DetermineVersion = "determine-version";
-const string UpdateVersion = "update-version";
-const string PushToNuGet = "push-to-nuget";
 
 Target(
     Clean,
@@ -49,20 +42,12 @@ Target(
 Target(
     Format,
     () =>
-    {
-        Run("dotnet", "tool restore");
-        Run("dotnet", "csharpier format .");
-    }
-);
-Target(
-    CheckFormat,
-    () =>
     {
         Run("dotnet", "tool restore");
         Run("dotnet", "csharpier check .");
     }
 );
-Target(Restore, [CheckFormat], () => Run("dotnet", "restore"));
+Target(Restore, [Format], () => Run("dotnet", "restore"));
 
 Target(
     Build,
@@ -76,7 +61,7 @@ Target(
 Target(
     Test,
     [Build],
-    ["net10.0", "net48"],
+    ["net8.0", "net48"],
     framework =>
     {
         IEnumerable<string> GetFiles(string d)
@@ -105,200 +90,6 @@ Target(
     }
 );
 
-Target(
-    DetermineVersion,
-    async () =>
-    {
-        var (version, isPrerelease) = await GetVersion();
-        Console.WriteLine($"VERSION={version}");
-        Console.WriteLine($"PRERELEASE={isPrerelease.ToString().ToLower()}");
-
-        // Write to environment file for GitHub Actions
-        var githubOutput = Environment.GetEnvironmentVariable("GITHUB_OUTPUT");
-        if (!string.IsNullOrEmpty(githubOutput))
-        {
-            File.AppendAllText(githubOutput, $"version={version}\n");
-            File.AppendAllText(githubOutput, $"prerelease={isPrerelease.ToString().ToLower()}\n");
-        }
-    }
-);
-
-Target(
-    UpdateVersion,
-    async () =>
-    {
-        var version = Environment.GetEnvironmentVariable("VERSION");
-        if (string.IsNullOrEmpty(version))
-        {
-            var (detectedVersion, _) = await GetVersion();
-            version = detectedVersion;
-        }
-
-        Console.WriteLine($"Updating project file with version: {version}");
-
-        var projectPath = "src/SharpCompress/SharpCompress.csproj";
-        var content = File.ReadAllText(projectPath);
-
-        // Get base version (without prerelease suffix)
-        var baseVersion = version.Split('-')[0];
-
-        // Update VersionPrefix
-        content = Regex.Replace(
-            content,
-            @"<VersionPrefix>[^<]*</VersionPrefix>",
-            $"<VersionPrefix>{version}</VersionPrefix>"
-        );
-
-        // Update AssemblyVersion
-        content = Regex.Replace(
-            content,
-            @"<AssemblyVersion>[^<]*</AssemblyVersion>",
-            $"<AssemblyVersion>{baseVersion}</AssemblyVersion>"
-        );
-
-        // Update FileVersion
-        content = Regex.Replace(
-            content,
-            @"<FileVersion>[^<]*</FileVersion>",
-            $"<FileVersion>{baseVersion}</FileVersion>"
-        );
-
-        File.WriteAllText(projectPath, content);
-        Console.WriteLine($"Updated VersionPrefix to: {version}");
-        Console.WriteLine($"Updated AssemblyVersion and FileVersion to: {baseVersion}");
-    }
-);
-
-Target(
-    PushToNuGet,
-    () =>
-    {
-        var apiKey = Environment.GetEnvironmentVariable("NUGET_API_KEY");
-        if (string.IsNullOrEmpty(apiKey))
-        {
-            Console.WriteLine(
-                "NUGET_API_KEY environment variable is not set. Skipping NuGet push."
-            );
-            return;
-        }
-
-        var packages = Directory.GetFiles("artifacts", "*.nupkg");
-        if (packages.Length == 0)
-        {
-            Console.WriteLine("No packages found in artifacts directory.");
-            return;
-        }
-
-        foreach (var package in packages)
-        {
-            Console.WriteLine($"Pushing {package} to NuGet.org");
-            try
-            {
-                // Note: API key is passed via command line argument which is standard practice for dotnet nuget push
-                // The key is already in an environment variable and not displayed in normal output
-                Run(
-                    "dotnet",
-                    $"nuget push \"{package}\" --api-key {apiKey} --source https://api.nuget.org/v3/index.json --skip-duplicate"
-                );
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Failed to push {package}: {ex.Message}");
-                throw;
-            }
-        }
-    }
-);
-
 Target("default", [Publish], () => Console.WriteLine("Done!"));
 
 await RunTargetsAndExitAsync(args);
-
-static async Task<(string version, bool isPrerelease)> GetVersion()
-{
-    // Check if current commit has a version tag
-    var currentTag = (await GetGitOutput("tag", "--points-at HEAD"))
-        .Split('\n', StringSplitOptions.RemoveEmptyEntries)
-        .FirstOrDefault(tag => Regex.IsMatch(tag.Trim(), @"^\d+\.\d+\.\d+$"));
-
-    if (!string.IsNullOrEmpty(currentTag))
-    {
-        // Tagged release - use the tag as version
-        var version = currentTag.Trim();
-        Console.WriteLine($"Building tagged release version: {version}");
-        return (version, false);
-    }
-    else
-    {
-        // Not tagged - create prerelease version
-        var allTags = (await GetGitOutput("tag", "--list"))
-            .Split('\n', StringSplitOptions.RemoveEmptyEntries)
-            .Where(tag => Regex.IsMatch(tag.Trim(), @"^\d+\.\d+\.\d+$"))
-            .Select(tag => tag.Trim())
-            .ToList();
-
-        var lastTag = allTags.OrderBy(tag => Version.Parse(tag)).LastOrDefault() ?? "0.0.0";
-        var lastVersion = Version.Parse(lastTag);
-
-        // Determine version increment based on branch
-        var currentBranch = await GetCurrentBranch();
-        Version nextVersion;
-
-        if (currentBranch == "release")
-        {
-            // Release branch: increment patch version
-            nextVersion = new Version(lastVersion.Major, lastVersion.Minor, lastVersion.Build + 1);
-            Console.WriteLine($"Building prerelease for release branch (patch increment)");
-        }
-        else
-        {
-            // Master or other branches: increment minor version
-            nextVersion = new Version(lastVersion.Major, lastVersion.Minor + 1, 0);
-            Console.WriteLine($"Building prerelease for {currentBranch} branch (minor increment)");
-        }
-
-        // Use commit count since the last version tag if available; otherwise, fall back to total count
-        var revListArgs = allTags.Any() ? $"--count {lastTag}..HEAD" : "--count HEAD";
-        var commitCount = (await GetGitOutput("rev-list", revListArgs)).Trim();
-
-        var version = $"{nextVersion}-beta.{commitCount}";
-        Console.WriteLine($"Building prerelease version: {version}");
-        return (version, true);
-    }
-}
-
-static async Task<string> GetCurrentBranch()
-{
-    // In GitHub Actions, GITHUB_REF_NAME contains the branch name
-    var githubRefName = Environment.GetEnvironmentVariable("GITHUB_REF_NAME");
-    if (!string.IsNullOrEmpty(githubRefName))
-    {
-        return githubRefName;
-    }
-
-    // Fallback to git command for local builds
-    try
-    {
-        var (output, _) = await ReadAsync("git", "branch --show-current");
-        return output.Trim();
-    }
-    catch (Exception ex)
-    {
-        Console.WriteLine($"Warning: Could not determine current branch: {ex.Message}");
-        return "unknown";
-    }
-}
-
-static async Task<string> GetGitOutput(string command, string args)
-{
-    try
-    {
-        // Use SimpleExec's Read to execute git commands in a cross-platform way
-        var (output, _) = await ReadAsync("git", $"{command} {args}");
-        return output;
-    }
-    catch (Exception ex)
-    {
-        throw new Exception($"Git command failed: git {command} {args}\n{ex.Message}", ex);
-    }
-}

build/packages.lock.json

@@ -4,9 +4,9 @@
     "net10.0": {
       "Bullseye": {
         "type": "Direct",
-        "requested": "[6.1.0, )",
-        "resolved": "6.1.0",
-        "contentHash": "fltnAJDe0BEX5eymXGUq+il2rSUA0pHqUonNDRH2TrvRu8SkU17mYG0IVpdmG2ibtfhdjNrv4CuTCxHOwcozCA=="
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "vgwwXfzs7jJrskWH7saHRMgPzziq/e86QZNWY1MnMxd7e+De7E7EX4K3C7yrvaK9y02SJoLxNxcLG/q5qUAghw=="
       },
       "Glob": {
         "type": "Direct",
@@ -14,45 +14,11 @@
         "resolved": "1.1.9",
         "contentHash": "AfK5+ECWYTP7G3AAdnU8IfVj+QpGjrh9GC2mpdcJzCvtQ4pnerAGwHsxJ9D4/RnhDUz2DSzd951O/lQjQby2Sw=="
       },
-      "Microsoft.NETFramework.ReferenceAssemblies": {
-        "type": "Direct",
-        "requested": "[1.0.3, )",
-        "resolved": "1.0.3",
-        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
-        "dependencies": {
-          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
-        }
-      },
-      "Microsoft.SourceLink.GitHub": {
-        "type": "Direct",
-        "requested": "[10.0.102, )",
-        "resolved": "10.0.102",
-        "contentHash": "Oxq3RCIJSdtpIU4hLqO7XaDe/Ra3HS9Wi8rJl838SAg6Zu1iQjerA0+xXWBgUFYbgknUGCLOU0T+lzMLkvY9Qg==",
-        "dependencies": {
-          "Microsoft.Build.Tasks.Git": "10.0.102",
-          "Microsoft.SourceLink.Common": "10.0.102"
-        }
-      },
       "SimpleExec": {
         "type": "Direct",
-        "requested": "[13.0.0, )",
-        "resolved": "13.0.0",
-        "contentHash": "zcCR1pupa1wI1VqBULRiQKeHKKZOuJhi/K+4V5oO+rHJZlaOD53ViFo1c3PavDoMAfSn/FAXGAWpPoF57rwhYg=="
-      },
-      "Microsoft.Build.Tasks.Git": {
-        "type": "Transitive",
-        "resolved": "10.0.102",
-        "contentHash": "0i81LYX31U6UiXz4NOLbvc++u+/mVDmOt+PskrM/MygpDxkv9THKQyRUmavBpLK6iBV0abNWnn+CQgSRz//Pwg=="
-      },
-      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
-        "type": "Transitive",
-        "resolved": "1.0.3",
-        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
-      },
-      "Microsoft.SourceLink.Common": {
-        "type": "Transitive",
-        "resolved": "10.0.102",
-        "contentHash": "Mk1IMb9q5tahC2NltxYXFkLBtuBvfBoCQ3pIxYQWfzbCE9o1OB9SsHe0hnNGo7lWgTA/ePbFAJLWu6nLL9K17A=="
+        "requested": "[12.0.0, )",
+        "resolved": "12.0.0",
+        "contentHash": "ptxlWtxC8vM6Y6e3h9ZTxBBkOWnWrm/Sa1HT+2i1xcXY3Hx2hmKDZP5RShPf8Xr9D+ivlrXNy57ktzyH8kyt+Q=="
       }
     }
   }

src/SharpCompress/Archives/AbstractArchive.cs

@@ -1,43 +1,58 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public abstract class AbstractArchive<TEntry, TVolume> : IArchive
+public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
-    private readonly LazyReadOnlyCollection<TVolume> _lazyVolumes;
-    private readonly LazyReadOnlyCollection<TEntry> _lazyEntries;
     private bool _disposed;
-    private readonly SourceStream? _sourceStream;
+    protected SourceStream? SourceStream { get; internal set; }
 
+    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
+    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
+
+    public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
+    public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
     protected ReaderOptions ReaderOptions { get; }
 
+    protected Lazy<IReadOnlyCollection<TVolume>> LazyVolumes { get; internal set; }
+    protected Lazy<IReadOnlyCollection<TEntry>> LazyEntries { get; internal set; }
+
     internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
     {
         Type = type;
         ReaderOptions = sourceStream.ReaderOptions;
-        _sourceStream = sourceStream;
-        _lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(_sourceStream));
-        _lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+        SourceStream = sourceStream;
+        LazyVolumes = new Lazy<IReadOnlyCollection<TVolume>>(() => LoadVolumes(SourceStream).ToList());
+        LazyEntries = new Lazy<IReadOnlyCollection<TEntry>>(() => LoadEntries(Volumes).ToList());
     }
 
     internal AbstractArchive(ArchiveType type)
     {
         Type = type;
         ReaderOptions = new();
-        _lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
-        _lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
+        LazyVolumes = new Lazy<IReadOnlyCollection<TVolume>>(() => Enumerable.Empty<TVolume>().ToList());
+        LazyEntries = new Lazy<IReadOnlyCollection<TEntry>>(() => Enumerable.Empty<TEntry>().ToList());
     }
 
     public ArchiveType Type { get; }
 
+    void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) =>
+        EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+
+    void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry) =>
+        EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+
     private static Stream CheckStreams(Stream stream)
     {
         if (!stream.CanSeek || !stream.CanRead)
@@ -50,12 +65,12 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
     /// <summary>
     /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
     /// </summary>
-    public virtual ICollection<TEntry> Entries => _lazyEntries;
+    public virtual ICollection<TEntry> Entries => LazyEntries.Value;
 
     /// <summary>
     /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
     /// </summary>
-    public ICollection<TVolume> Volumes => _lazyVolumes;
+    public ICollection<TVolume> Volumes => LazyVolumes.Value;
 
     /// <summary>
     /// The total size of the files compressed in the archive.
@@ -71,29 +86,63 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
 
     protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream sourceStream);
     protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
+    protected virtual Task<IReadOnlyCollection<TEntry>> LoadEntriesAsync(IEnumerable<TVolume> volumes, CancellationToken cancellationToken)
+    {
+        return Task.FromResult<IReadOnlyCollection<TEntry>>(LoadEntries(volumes).ToList());
+    }
+    protected virtual Task<IReadOnlyCollection<TVolume>> LoadVolumesAsync(SourceStream sourceStream, CancellationToken cancellationToken)
+    {
+        return Task.FromResult<IReadOnlyCollection<TVolume>>(LoadVolumes(sourceStream).ToList());
+    }
 
     IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
 
-    IEnumerable<IVolume> IArchive.Volumes => _lazyVolumes.Cast<IVolume>();
+    IEnumerable<IVolume> IArchive.Volumes => LazyVolumes.Value.Cast<IVolume>();
 
     public virtual void Dispose()
     {
         if (!_disposed)
         {
-            _lazyVolumes.ForEach(v => v.Dispose());
-            _lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
-            _sourceStream?.Dispose();
+            LazyVolumes.Value.ForEach(v => v.Dispose());
+            LazyEntries.Value.Cast<Entry>().ForEach(x => x.Close());
+            SourceStream?.Dispose();
 
             _disposed = true;
         }
     }
 
-    private void EnsureEntriesLoaded()
+    void IArchiveExtractionListener.EnsureEntriesLoaded()
     {
-        _lazyEntries.EnsureFullyLoaded();
-        _lazyVolumes.EnsureFullyLoaded();
+        LazyEntries.Value.EnsureFullyLoaded();
+        LazyVolumes.Value.EnsureFullyLoaded();
     }
 
+    void IExtractionListener.FireCompressedBytesRead(
+        long currentPartCompressedBytes,
+        long compressedReadBytes
+    ) =>
+        CompressedBytesRead?.Invoke(
+            this,
+            new CompressedBytesReadEventArgs(
+                currentFilePartCompressedBytesRead: currentPartCompressedBytes,
+                compressedBytesRead: compressedReadBytes
+            )
+        );
+
+    void IExtractionListener.FireFilePartExtractionBegin(
+        string name,
+        long size,
+        long compressedSize
+    ) =>
+        FilePartExtractionBegin?.Invoke(
+            this,
+            new FilePartExtractionBeginEventArgs(
+                compressedSize: compressedSize,
+                size: size,
+                name: name
+            )
+        );
+
     /// <summary>
     /// Use this method to extract all entries in an archive in order.
     /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
@@ -109,11 +158,11 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
     {
         if (!IsSolid && Type != ArchiveType.SevenZip)
         {
-            throw new SharpCompressException(
+            throw new InvalidOperationException(
                 "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
             );
         }
-        EnsureEntriesLoaded();
+        ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
         return CreateReaderForSolidExtraction();
     }
 
@@ -124,11 +173,6 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
     /// </summary>
     public virtual bool IsSolid => false;
 
-    /// <summary>
-    /// Archive is ENCRYPTED (this means the Archive has password-protected files).
-    /// </summary>
-    public virtual bool IsEncrypted => false;
-
     /// <summary>
     /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
     /// </summary>
@@ -136,7 +180,7 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
     {
         get
         {
-            EnsureEntriesLoaded();
+            ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
             return Entries.All(x => x.IsComplete);
         }
     }

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -2,6 +2,8 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Factories;
 using SharpCompress.IO;
@@ -24,6 +26,25 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
+    /// <summary>
+    /// Opens an Archive for random access
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public static async Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        readerOptions ??= new ReaderOptions();
+        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken);
+        return await factory.OpenAsync(stream, readerOptions, cancellationToken);
+    }
+
     public static IWritableArchive Create(ArchiveType type)
     {
         var factory = Factory
@@ -49,6 +70,22 @@ public static class ArchiveFactory
         return Open(new FileInfo(filePath), options);
     }
 
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static Task<IArchive> OpenAsync(
+        string filePath,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenAsync(new FileInfo(filePath), options, cancellationToken);
+    }
+
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
@@ -61,6 +98,24 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
     }
 
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken);
+        return await factory.OpenAsync(fileInfo, options, cancellationToken);
+    }
+
     /// <summary>
     /// Constructor with IEnumerable FileInfo objects, multi and split support.
     /// </summary>
@@ -87,6 +142,38 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
     }
 
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var filesArray = fileInfos.ToArray();
+        if (filesArray.Length == 0)
+        {
+            throw new InvalidOperationException("No files to open");
+        }
+
+        var fileInfo = filesArray[0];
+        if (filesArray.Length == 1)
+        {
+            return await OpenAsync(fileInfo, options, cancellationToken);
+        }
+
+        fileInfo.NotNull(nameof(fileInfo));
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(fileInfo, cancellationToken);
+        return await factory.OpenAsync(filesArray, options, cancellationToken);
+    }
+
     /// <summary>
     /// Constructor with IEnumerable FileInfo objects, multi and split support.
     /// </summary>
@@ -113,6 +200,38 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
     }
 
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IEnumerable<Stream> streams,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var streamsArray = streams.ToArray();
+        if (streamsArray.Length == 0)
+        {
+            throw new InvalidOperationException("No streams");
+        }
+
+        var firstStream = streamsArray[0];
+        if (streamsArray.Length == 1)
+        {
+            return await OpenAsync(firstStream, options, cancellationToken);
+        }
+
+        firstStream.NotNull(nameof(firstStream));
+        options ??= new ReaderOptions();
+
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(firstStream, cancellationToken);
+        return await factory.OpenAsync(streamsArray, options, cancellationToken);
+    }
+
     /// <summary>
     /// Extract to specific directory, retaining filename
     /// </summary>
@@ -126,6 +245,20 @@ public static class ArchiveFactory
         archive.WriteToDirectory(destinationDirectory, options);
     }
 
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static async Task WriteToDirectoryAsync(
+        string sourceArchive,
+        string destinationDirectory,
+        ExtractionOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var archive = await OpenAsync(sourceArchive, cancellationToken: cancellationToken);
+        await archive.WriteToDirectoryAsync(destinationDirectory, options, cancellationToken);
+    }
+
     private static T FindFactory<T>(FileInfo finfo)
         where T : IFactory
     {
@@ -134,6 +267,17 @@ public static class ArchiveFactory
         return FindFactory<T>(stream);
     }
 
+    private static async Task<T> FindFactoryAsync<T>(
+        FileInfo finfo,
+        CancellationToken cancellationToken
+    )
+        where T : IFactory
+    {
+        finfo.NotNull(nameof(finfo));
+        using Stream stream = finfo.OpenRead();
+        return await FindFactoryAsync<T>(stream, cancellationToken);
+    }
+
     private static T FindFactory<T>(Stream stream)
         where T : IFactory
     {
@@ -166,14 +310,65 @@ public static class ArchiveFactory
         );
     }
 
-    public static bool IsArchive(string filePath, out ArchiveType? type)
+    private static async Task<T> FindFactoryAsync<T>(Stream stream, CancellationToken cancellationToken)
+        where T : IFactory
+    {
+        stream.NotNull(nameof(stream));
+        if (!stream.CanRead || !stream.CanSeek)
+        {
+            throw new ArgumentException("Stream should be readable and seekable");
+        }
+
+        var factories = Factory.Factories.OfType<T>();
+
+        var startPosition = stream.Position;
+
+        foreach (var factory in factories)
+        {
+            stream.Seek(startPosition, SeekOrigin.Begin);
+
+            if (await factory.IsArchiveAsync(stream, cancellationToken).ConfigureAwait(false))
+            {
+                stream.Seek(startPosition, SeekOrigin.Begin);
+
+                return factory;
+            }
+        }
+
+        var extensions = string.Join(", ", factories.Select(item => item.Name));
+
+        throw new InvalidOperationException(
+            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
+        );
+    }
+
+    public static bool IsArchive(
+        string filePath,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         filePath.NotNullOrEmpty(nameof(filePath));
         using Stream s = File.OpenRead(filePath);
-        return IsArchive(s, out type);
+        return IsArchive(s, out type, bufferSize);
     }
 
-    public static bool IsArchive(Stream stream, out ArchiveType? type)
+    public static async Task<(bool, ArchiveType?)> IsArchiveAsync(
+        string filePath,
+        CancellationToken cancellationToken = default,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        using Stream s = File.OpenRead(filePath);
+        return await IsArchiveAsync(s, cancellationToken, bufferSize);
+    }
+
+    public static bool IsArchive(
+        Stream stream,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         type = null;
         stream.NotNull(nameof(stream));
@@ -200,6 +395,36 @@ public static class ArchiveFactory
         return false;
     }
 
+    public static async Task<(bool, ArchiveType?)> IsArchiveAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        stream.NotNull(nameof(stream));
+
+        if (!stream.CanRead || !stream.CanSeek)
+        {
+            throw new ArgumentException("Stream should be readable and seekable");
+        }
+
+        var startPosition = stream.Position;
+
+        foreach (var factory in Factory.Factories)
+        {
+            var isArchive = await factory.IsArchiveAsync(stream, cancellationToken)
+                .ConfigureAwait(false);
+            stream.Position = startPosition;
+
+            if (isArchive)
+            {
+                return (true, factory.KnownArchiveType);
+            }
+        }
+
+        return (false, null);
+    }
+
     /// <summary>
     /// From a passed in archive (zip, rar, 7z, 001), return all parts.
     /// </summary>

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -14,8 +14,11 @@ class AutoArchiveFactory : IArchiveFactory
 
     public IEnumerable<string> GetSupportedExtensions() => throw new NotSupportedException();
 
-    public bool IsArchive(Stream stream, string? password = null) =>
-        throw new NotSupportedException();
+    public bool IsArchive(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => throw new NotSupportedException();
 
     public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
 

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -2,11 +2,13 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
 using SharpCompress.IO;
+using SharpCompress.Polyfills;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
 using SharpCompress.Writers;
@@ -27,6 +29,22 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<GZipArchive> OpenAsync(
+        string filePath,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return await OpenAsync(new FileInfo(filePath), readerOptions ?? new ReaderOptions(), cancellationToken).ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
@@ -44,6 +62,32 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         );
     }
 
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<GZipArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        var archive = new GZipArchive();
+        archive.SourceStream = new SourceStream(
+            fileInfo,
+            i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+            readerOptions ?? new ReaderOptions()
+        );
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<GZipVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<GZipArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     /// <summary>
     /// Constructor with all file parts passed in
     /// </summary>
@@ -65,6 +109,33 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         );
     }
 
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<GZipArchive> OpenAsync(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        var archive = new GZipArchive();
+        archive.SourceStream = new SourceStream(
+            files[0],
+            i => i < files.Length ? files[i] : null,
+            readerOptions ?? new ReaderOptions()
+        );
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<GZipVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<GZipArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     /// <summary>
     /// Constructor with all stream parts passed in
     /// </summary>
@@ -83,6 +154,33 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         );
     }
 
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<GZipArchive> OpenAsync(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        var archive = new GZipArchive();
+        archive.SourceStream = new SourceStream(
+            strms[0],
+            i => i < strms.Length ? strms[i] : null,
+            readerOptions ?? new ReaderOptions()
+        );
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<GZipVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<GZipArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     /// <summary>
     /// Takes a seekable Stream as a source
     /// </summary>
@@ -102,21 +200,62 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         );
     }
 
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<GZipArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        var archive = new GZipArchive();
+        archive.SourceStream = new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions());
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<GZipVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<GZipArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     public static GZipArchive Create() => new();
 
     /// <summary>
-    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    * Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
     /// <param name="sourceStream"></param>
     private GZipArchive(SourceStream sourceStream)
         : base(ArchiveType.GZip, sourceStream) { }
 
+    private GZipArchive()
+        : base(ArchiveType.GZip)
+    {
+        LazyVolumes = new Lazy<IReadOnlyCollection<GZipVolume>>(() => LoadVolumes(SourceStream!).ToList());
+        LazyEntries = new Lazy<IReadOnlyCollection<GZipArchiveEntry>>(() => LoadEntries(Volumes).ToList());
+    }
+
     protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream sourceStream)
     {
         sourceStream.LoadAllParts();
         return sourceStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, 0));
     }
 
+    protected override async Task<IReadOnlyCollection<GZipVolume>> LoadVolumesAsync(SourceStream sourceStream, CancellationToken cancellationToken)
+    {
+        await sourceStream.LoadAllPartsAsync(cancellationToken).ConfigureAwait(false);
+        return sourceStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, 0)).ToList();
+    }
+
     public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
 
     public static bool IsGZipFile(FileInfo fileInfo)
@@ -130,6 +269,25 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         return IsGZipFile(stream);
     }
 
+    public static Task<bool> IsGZipFileAsync(
+        string filePath,
+        CancellationToken cancellationToken = default
+    ) => IsGZipFileAsync(new FileInfo(filePath), cancellationToken);
+
+    public static async Task<bool> IsGZipFileAsync(
+        FileInfo fileInfo,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+
+        using Stream stream = fileInfo.OpenRead();
+        return await IsGZipFileAsync(stream, cancellationToken).ConfigureAwait(false);
+    }
+
     public void SaveTo(string filePath) => SaveTo(new FileInfo(filePath));
 
     public void SaveTo(FileInfo fileInfo)
@@ -167,6 +325,28 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         return true;
     }
 
+    public static async Task<bool> IsGZipFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // read the header on the first read
+        byte[] header = new byte[10];
+
+        // workitem 8501: handle edge case (decompress empty stream)
+        if (!await stream.ReadFullyAsync(header, cancellationToken).ConfigureAwait(false))
+        {
+            return false;
+        }
+
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
     internal GZipArchive()
         : base(ArchiveType.GZip) { }
 
@@ -244,6 +424,17 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         );
     }
 
+    protected override async Task<IReadOnlyCollection<GZipArchiveEntry>> LoadEntriesAsync(IEnumerable<GZipVolume> volumes, CancellationToken cancellationToken)
+    {
+        var list = new List<GZipArchiveEntry>();
+        var stream = volumes.Single().Stream;
+        list.Add(new GZipArchiveEntry(
+            this,
+            new GZipFilePart(stream, ReaderOptions.ArchiveEncoding)
+        ));
+        return list.AsReadOnly();
+    }
+
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
@@ -251,3 +442,4 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         return GZipReader.Open(stream);
     }
 }
+

src/SharpCompress/Archives/IArchive.cs

@@ -7,6 +7,12 @@ namespace SharpCompress.Archives;
 
 public interface IArchive : IDisposable
 {
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+
+    event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
+    event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+
     IEnumerable<IArchiveEntry> Entries { get; }
     IEnumerable<IVolume> Volumes { get; }
 

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -1,4 +1,3 @@
-using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,151 +8,127 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveEntryExtensions
 {
-    /// <param name="archiveEntry">The archive entry to extract.</param>
-    extension(IArchiveEntry archiveEntry)
+    public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
     {
-        /// <summary>
-        /// Extract entry to the specified stream.
-        /// </summary>
-        /// <param name="streamToWriteTo">The stream to write the entry content to.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        public void WriteTo(Stream streamToWriteTo, IProgress<ProgressReport>? progress = null)
+        if (archiveEntry.IsDirectory)
         {
-            if (archiveEntry.IsDirectory)
-            {
-                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-            }
-
-            using var entryStream = archiveEntry.OpenEntryStream();
-            var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
-            sourceStream.CopyTo(streamToWriteTo, Constants.BufferSize);
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
         }
 
-        /// <summary>
-        /// Extract entry to the specified stream asynchronously.
-        /// </summary>
-        /// <param name="streamToWriteTo">The stream to write the entry content to.</param>
-        /// <param name="cancellationToken">Cancellation token.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        public async Task WriteToAsync(
-            Stream streamToWriteTo,
-            IProgress<ProgressReport>? progress = null,
-            CancellationToken cancellationToken = default
-        )
+        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+        streamListener.EnsureEntriesLoaded();
+        streamListener.FireEntryExtractionBegin(archiveEntry);
+        streamListener.FireFilePartExtractionBegin(
+            archiveEntry.Key ?? "Key",
+            archiveEntry.Size,
+            archiveEntry.CompressedSize
+        );
+        var entryStream = archiveEntry.OpenEntryStream();
+        using (entryStream)
         {
-            if (archiveEntry.IsDirectory)
-            {
-                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-            }
-
-            using var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
-            var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
-            await sourceStream
-                .CopyToAsync(streamToWriteTo, Constants.BufferSize, cancellationToken)
-                .ConfigureAwait(false);
+            using Stream s = new ListeningStream(streamListener, entryStream);
+            s.CopyTo(streamToWriteTo);
         }
+        streamListener.FireEntryExtractionEnd(archiveEntry);
     }
 
-    private static Stream WrapWithProgress(
-        Stream source,
-        IArchiveEntry entry,
-        IProgress<ProgressReport>? progress
+    public static async Task WriteToAsync(
+        this IArchiveEntry archiveEntry,
+        Stream streamToWriteTo,
+        CancellationToken cancellationToken = default
     )
     {
-        if (progress is null)
+        if (archiveEntry.IsDirectory)
         {
-            return source;
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
         }
 
-        var entryPath = entry.Key ?? string.Empty;
-        var totalBytes = GetEntrySizeSafe(entry);
-        return new ProgressReportingStream(
-            source,
-            progress,
-            entryPath,
-            totalBytes,
-            leaveOpen: true
+        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+        streamListener.EnsureEntriesLoaded();
+        streamListener.FireEntryExtractionBegin(archiveEntry);
+        streamListener.FireFilePartExtractionBegin(
+            archiveEntry.Key ?? "Key",
+            archiveEntry.Size,
+            archiveEntry.CompressedSize
         );
-    }
-
-    private static long? GetEntrySizeSafe(IArchiveEntry entry)
-    {
-        try
+        var entryStream = archiveEntry.OpenEntryStream();
+        using (entryStream)
         {
-            var size = entry.Size;
-            return size >= 0 ? size : null;
-        }
-        catch (NotImplementedException)
-        {
-            return null;
+            using Stream s = new ListeningStream(streamListener, entryStream);
+            await s.CopyToAsync(streamToWriteTo, 81920, cancellationToken).ConfigureAwait(false);
         }
+        streamListener.FireEntryExtractionEnd(archiveEntry);
     }
 
-    extension(IArchiveEntry entry)
-    {
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public void WriteToDirectory(
-            string destinationDirectory,
-            ExtractionOptions? options = null
-        ) =>
-            ExtractionMethods.WriteEntryToDirectory(
-                entry,
-                destinationDirectory,
-                options,
-                entry.WriteToFile
-            );
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        this IArchiveEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    ) =>
+        ExtractionMethods.WriteEntryToDirectory(
+            entry,
+            destinationDirectory,
+            options,
+            entry.WriteToFile
+        );
 
-        /// <summary>
-        /// Extract to specific directory asynchronously, retaining filename
-        /// </summary>
-        public Task WriteToDirectoryAsync(
-            string destinationDirectory,
-            ExtractionOptions? options = null,
-            CancellationToken cancellationToken = default
-        ) =>
-            ExtractionMethods.WriteEntryToDirectoryAsync(
-                entry,
-                destinationDirectory,
-                options,
-                entry.WriteToFileAsync,
-                cancellationToken
-            );
+    /// <summary>
+    /// Extract to specific directory asynchronously, retaining filename
+    /// </summary>
+    public static Task WriteToDirectoryAsync(
+        this IArchiveEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options = null,
+        CancellationToken cancellationToken = default
+    ) =>
+        ExtractionMethods.WriteEntryToDirectoryAsync(
+            entry,
+            destinationDirectory,
+            options,
+            (x, opt) => entry.WriteToFileAsync(x, opt, cancellationToken),
+            cancellationToken
+        );
 
-        /// <summary>
-        /// Extract to specific file
-        /// </summary>
-        public void WriteToFile(string destinationFileName, ExtractionOptions? options = null) =>
-            ExtractionMethods.WriteEntryToFile(
-                entry,
-                destinationFileName,
-                options,
-                (x, fm) =>
-                {
-                    using var fs = File.Open(destinationFileName, fm);
-                    entry.WriteTo(fs);
-                }
-            );
+    /// <summary>
+    /// Extract to specific file
+    /// </summary>
+    public static void WriteToFile(
+        this IArchiveEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options = null
+    ) =>
+        ExtractionMethods.WriteEntryToFile(
+            entry,
+            destinationFileName,
+            options,
+            (x, fm) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                entry.WriteTo(fs);
+            }
+        );
 
-        /// <summary>
-        /// Extract to specific file asynchronously
-        /// </summary>
-        public Task WriteToFileAsync(
-            string destinationFileName,
-            ExtractionOptions? options = null,
-            CancellationToken cancellationToken = default
-        ) =>
-            ExtractionMethods.WriteEntryToFileAsync(
-                entry,
-                destinationFileName,
-                options,
-                async (x, fm, ct) =>
-                {
-                    using var fs = File.Open(destinationFileName, fm);
-                    await entry.WriteToAsync(fs, null, ct).ConfigureAwait(false);
-                },
-                cancellationToken
-            );
-    }
+    /// <summary>
+    /// Extract to specific file asynchronously
+    /// </summary>
+    public static Task WriteToFileAsync(
+        this IArchiveEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options = null,
+        CancellationToken cancellationToken = default
+    ) =>
+        ExtractionMethods.WriteEntryToFileAsync(
+            entry,
+            destinationFileName,
+            options,
+            async (x, fm) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                await entry.WriteToAsync(fs, cancellationToken).ConfigureAwait(false);
+            },
+            cancellationToken
+        );
 }

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 
@@ -10,159 +10,76 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveExtensions
 {
-    /// <param name="archive">The archive to extract.</param>
-    extension(IArchive archive)
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        this IArchive archive,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    )
     {
-        /// <summary>
-        /// Extract to specific directory with progress reporting
-        /// </summary>
-        /// <param name="destinationDirectory">The folder to extract into.</param>
-        /// <param name="options">Extraction options.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        public void WriteToDirectory(
-            string destinationDirectory,
-            ExtractionOptions? options = null,
-            IProgress<ProgressReport>? progress = null
-        )
+        using var reader = archive.ExtractAllEntries();
+        reader.WriteAllToDirectory(destinationDirectory, options);
+    }
+
+    /// <summary>
+    /// Extracts the archive to the destination directory. Directories will be created as needed.
+    /// </summary>
+    /// <param name="archive">The archive to extract.</param>
+    /// <param name="destination">The folder to extract into.</param>
+    /// <param name="progressReport">Optional progress report callback.</param>
+    /// <param name="cancellationToken">Optional cancellation token.</param>
+    public static void ExtractToDirectory(
+        this IArchive archive,
+        string destination,
+        Action<double>? progressReport = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // Prepare for progress reporting
+        var totalBytes = archive.TotalUncompressSize;
+        var bytesRead = 0L;
+
+        // Tracking for created directories.
+        var seenDirectories = new HashSet<string>();
+
+        // Extract
+        foreach (var entry in archive.Entries)
         {
-            // For solid archives (Rar, 7Zip), use the optimized reader-based approach
-            if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
-            {
-                using var reader = archive.ExtractAllEntries();
-                reader.WriteAllToDirectory(destinationDirectory, options);
-            }
-            else
-            {
-                // For non-solid archives, extract entries directly
-                archive.WriteToDirectoryInternal(destinationDirectory, options, progress);
-            }
-        }
+            cancellationToken.ThrowIfCancellationRequested();
 
-        private void WriteToDirectoryInternal(
-            string destinationDirectory,
-            ExtractionOptions? options,
-            IProgress<ProgressReport>? progress
-        )
-        {
-            // Prepare for progress reporting
-            var totalBytes = archive.TotalUncompressSize;
-            var bytesRead = 0L;
-
-            // Tracking for created directories.
-            var seenDirectories = new HashSet<string>();
-
-            // Extract
-            foreach (var entry in archive.Entries)
+            if (entry.IsDirectory)
             {
-                if (entry.IsDirectory)
+                var dirPath = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
+                if (
+                    Path.GetDirectoryName(dirPath + "/") is { } emptyDirectory
+                    && seenDirectories.Add(dirPath)
+                )
                 {
-                    var dirPath = Path.Combine(
-                        destinationDirectory,
-                        entry.Key.NotNull("Entry Key is null")
-                    );
-                    if (
-                        Path.GetDirectoryName(dirPath + "/") is { } parentDirectory
-                        && seenDirectories.Add(dirPath)
-                    )
-                    {
-                        Directory.CreateDirectory(parentDirectory);
-                    }
-                    continue;
+                    Directory.CreateDirectory(emptyDirectory);
                 }
-
-                // Use the entry's WriteToDirectory method which respects ExtractionOptions
-                entry.WriteToDirectory(destinationDirectory, options);
-
-                // Update progress
-                bytesRead += entry.Size;
-                progress?.Report(
-                    new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes)
-                );
+                continue;
             }
-        }
 
-        /// <summary>
-        /// Extract to specific directory asynchronously with progress reporting and cancellation support
-        /// </summary>
-        /// <param name="destinationDirectory">The folder to extract into.</param>
-        /// <param name="options">Extraction options.</param>
-        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        /// <param name="cancellationToken">Optional cancellation token.</param>
-        public async Task WriteToDirectoryAsync(
-            string destinationDirectory,
-            ExtractionOptions? options = null,
-            IProgress<ProgressReport>? progress = null,
-            CancellationToken cancellationToken = default
-        )
-        {
-            // For solid archives (Rar, 7Zip), use the optimized reader-based approach
-            if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
+            // Create each directory if not already created
+            var path = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
+            if (Path.GetDirectoryName(path) is { } directory)
             {
-                using var reader = archive.ExtractAllEntries();
-                await reader.WriteAllToDirectoryAsync(
-                    destinationDirectory,
-                    options,
-                    cancellationToken
-                );
-            }
-            else
-            {
-                // For non-solid archives, extract entries directly
-                await archive.WriteToDirectoryAsyncInternal(
-                    destinationDirectory,
-                    options,
-                    progress,
-                    cancellationToken
-                );
-            }
-        }
-
-        private async Task WriteToDirectoryAsyncInternal(
-            string destinationDirectory,
-            ExtractionOptions? options,
-            IProgress<ProgressReport>? progress,
-            CancellationToken cancellationToken
-        )
-        {
-            // Prepare for progress reporting
-            var totalBytes = archive.TotalUncompressSize;
-            var bytesRead = 0L;
-
-            // Tracking for created directories.
-            var seenDirectories = new HashSet<string>();
-
-            // Extract
-            foreach (var entry in archive.Entries)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                if (entry.IsDirectory)
+                if (!Directory.Exists(directory) && !seenDirectories.Contains(directory))
                 {
-                    var dirPath = Path.Combine(
-                        destinationDirectory,
-                        entry.Key.NotNull("Entry Key is null")
-                    );
-                    if (
-                        Path.GetDirectoryName(dirPath + "/") is { } parentDirectory
-                        && seenDirectories.Add(dirPath)
-                    )
-                    {
-                        Directory.CreateDirectory(parentDirectory);
-                    }
-                    continue;
+                    Directory.CreateDirectory(directory);
+                    seenDirectories.Add(directory);
                 }
-
-                // Use the entry's WriteToDirectoryAsync method which respects ExtractionOptions
-                await entry
-                    .WriteToDirectoryAsync(destinationDirectory, options, cancellationToken)
-                    .ConfigureAwait(false);
-
-                // Update progress
-                bytesRead += entry.Size;
-                progress?.Report(
-                    new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes)
-                );
             }
+
+            // Write file
+            using var fs = File.OpenWrite(path);
+            entry.WriteTo(fs);
+
+            // Update progress
+            bytesRead += entry.Size;
+            progressReport?.Invoke(bytesRead / (double)totalBytes);
         }
     }
 }

src/SharpCompress/Archives/IArchiveExtractionListener.cs

@@ -0,0 +1,10 @@
+using SharpCompress.Common;
+
+namespace SharpCompress.Archives;
+
+internal interface IArchiveExtractionListener : IExtractionListener
+{
+    void EnsureEntriesLoaded();
+    void FireEntryExtractionBegin(IArchiveEntry entry);
+    void FireEntryExtractionEnd(IArchiveEntry entry);
+}

src/SharpCompress/Archives/IArchiveFactory.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -26,10 +28,34 @@ public interface IArchiveFactory : IFactory
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(Stream stream, ReaderOptions? readerOptions = null);
 
+    /// <summary>
+    /// Opens an Archive for random access.
+    /// </summary>
+    /// <param name="stream">An open, readable and seekable stream.</param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">the cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
     /// <param name="fileInfo">the file to open.</param>
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null);
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo">the file to open.</param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">the cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Archives/IMultiArchiveFactory.cs

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -27,10 +29,34 @@ public interface IMultiArchiveFactory : IFactory
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
 
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">the cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+
     /// <summary>
     /// Constructor with IEnumerable Stream objects, multi and split support.
     /// </summary>
     /// <param name="fileInfos"></param>
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
+
+    /// <summary>
+    /// Constructor with IEnumerable Stream objects, multi and split support.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">the cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -2,6 +2,8 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
@@ -84,8 +86,6 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 
     public override bool IsSolid => Volumes.First().IsSolidArchive;
 
-    public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted;
-
     public virtual int MinVersion => Volumes.First().MinVersion;
     public virtual int MaxVersion => Volumes.First().MaxVersion;
 
@@ -193,6 +193,24 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
         return IsRarFile(stream);
     }
 
+    public static Task<bool> IsRarFileAsync(
+        string filePath,
+        CancellationToken cancellationToken = default
+    ) => IsRarFileAsync(new FileInfo(filePath), cancellationToken);
+
+    public static async Task<bool> IsRarFileAsync(
+        FileInfo fileInfo,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return await IsRarFileAsync(stream, cancellationToken).ConfigureAwait(false);
+    }
+
     public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
     {
         try
@@ -206,5 +224,23 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
         }
     }
 
+    public static async Task<bool> IsRarFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default,
+        ReaderOptions? options = null
+    )
+    {
+        try
+        {
+            await MarkHeader.ReadAsync(stream, true, false, cancellationToken)
+                .ConfigureAwait(false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     #endregion
 }

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -76,7 +76,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV1.Value,
                 FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
         else
@@ -84,7 +84,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV2017.Value,
                 FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
 
@@ -100,7 +100,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV1.Value,
                 FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
         else
@@ -108,7 +108,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV2017.Value,
                 FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
 

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -2,12 +2,14 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.SevenZip;
 using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
+using SharpCompress.Polyfills;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.SevenZip;
@@ -27,6 +29,18 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static Task<SevenZipArchive> OpenAsync(
+        string filePath,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => throw new NotImplementedException();
+
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
@@ -44,6 +58,18 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         );
     }
 
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static Task<SevenZipArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => throw new NotImplementedException();
+
     /// <summary>
     /// Constructor with all file parts passed in
     /// </summary>
@@ -65,6 +91,18 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         );
     }
 
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static Task<SevenZipArchive> OpenAsync(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => throw new NotImplementedException();
+
     /// <summary>
     /// Constructor with all stream parts passed in
     /// </summary>
@@ -86,6 +124,18 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         );
     }
 
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static Task<SevenZipArchive> OpenAsync(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => throw new NotImplementedException();
+
     /// <summary>
     /// Takes a seekable Stream as a source
     /// </summary>
@@ -105,6 +155,18 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         );
     }
 
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static Task<SevenZipArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => throw new NotImplementedException();
+
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
@@ -120,6 +182,11 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
 
     public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
 
+    public static Task<bool> IsSevenZipFileAsync(
+        string filePath,
+        CancellationToken cancellationToken = default
+    ) => IsSevenZipFileAsync(new FileInfo(filePath), cancellationToken);
+
     public static bool IsSevenZipFile(FileInfo fileInfo)
     {
         if (!fileInfo.Exists)
@@ -130,6 +197,19 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         return IsSevenZipFile(stream);
     }
 
+    public static async Task<bool> IsSevenZipFileAsync(
+        FileInfo fileInfo,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return await IsSevenZipFileAsync(stream, cancellationToken).ConfigureAwait(false);
+    }
+
     internal SevenZipArchive()
         : base(ArchiveType.SevenZip) { }
 
@@ -165,6 +245,8 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         return entries;
     }
 
+    protected override Task<IReadOnlyCollection<SevenZipArchiveEntry>> LoadEntriesAsync(IEnumerable<SevenZipVolume> volumes, CancellationToken cancellationToken) => throw new NotImplementedException();
+
     private void LoadFactory(Stream stream)
     {
         if (_database is null)
@@ -176,6 +258,8 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         }
     }
 
+    protected override Task<IReadOnlyCollection<SevenZipVolume>> LoadVolumesAsync(SourceStream sourceStream, CancellationToken cancellationToken) => throw new NotImplementedException();
+
     public static bool IsSevenZipFile(Stream stream)
     {
         try
@@ -188,6 +272,21 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         }
     }
 
+    public static async Task<bool> IsSevenZipFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        try
+        {
+            return await SignatureMatchAsync(stream, cancellationToken).ConfigureAwait(false);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     private static ReadOnlySpan<byte> Signature =>
         new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
 
@@ -198,6 +297,16 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         return signatureBytes.SequenceEqual(Signature);
     }
 
+    private static async Task<bool> SignatureMatchAsync(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var signatureBytes = new byte[6];
+        await stream.ReadFullyAsync(signatureBytes, cancellationToken).ConfigureAwait(false);
+        return signatureBytes.SequenceEqual(Signature.ToArray());
+    }
+
     protected override IReader CreateReaderForSolidExtraction() =>
         new SevenZipReader(ReaderOptions, this);
 
@@ -207,36 +316,15 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
             .GroupBy(x => x.FilePart.Folder)
             .Any(folder => folder.Count() > 1);
 
-    public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted;
-
     public override long TotalSize =>
         _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0;
 
-    internal sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
+    private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
     {
         private readonly SevenZipArchive _archive;
-        private SevenZipEntry? _currentEntry;
-        private Stream? _currentFolderStream;
         private CFolder? _currentFolder;
-
-        /// <summary>
-        /// Enables internal diagnostics for tests.
-        /// When disabled (default), diagnostics properties return null to avoid exposing internal state.
-        /// </summary>
-        internal bool DiagnosticsEnabled { get; set; }
-
-        /// <summary>
-        /// Current folder instance used to decide whether the solid folder stream should be reused.
-        /// Only available when <see cref="DiagnosticsEnabled"/> is true.
-        /// </summary>
-        internal object? DiagnosticsCurrentFolder => DiagnosticsEnabled ? _currentFolder : null;
-
-        /// <summary>
-        /// Current shared folder stream instance.
-        /// Only available when <see cref="DiagnosticsEnabled"/> is true.
-        /// </summary>
-        internal Stream? DiagnosticsCurrentFolderStream =>
-            DiagnosticsEnabled ? _currentFolderStream : null;
+        private Stream? _currentStream;
+        private CFileItem? _currentItem;
 
         internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
             : base(readerOptions, ArchiveType.SevenZip) => this._archive = archive;
@@ -249,170 +337,40 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
             stream.Position = 0;
             foreach (var dir in entries.Where(x => x.IsDirectory))
             {
-                _currentEntry = dir;
                 yield return dir;
             }
-            // For solid archives (entries in the same folder share a compressed stream),
-            // we must iterate entries sequentially and maintain the folder stream state
-            // across entries in the same folder to avoid recreating the decompression
-            // stream for each file, which breaks contiguous streaming.
-            foreach (var entry in entries.Where(x => !x.IsDirectory))
+            foreach (
+                var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder)
+            )
             {
-                _currentEntry = entry;
-                yield return entry;
+                _currentFolder = group.Key;
+                if (group.Key is null)
+                {
+                    _currentStream = Stream.Null;
+                }
+                else
+                {
+                    _currentStream = _archive._database?.GetFolderStream(
+                        stream,
+                        _currentFolder,
+                        new PasswordProvider(Options.Password)
+                    );
+                }
+                foreach (var entry in group)
+                {
+                    _currentItem = entry.FilePart.Header;
+                    yield return entry;
+                }
             }
         }
 
-        protected override EntryStream GetEntryStream()
-        {
-            var entry = _currentEntry.NotNull("currentEntry is not null");
-            if (entry.IsDirectory)
-            {
-                return CreateEntryStream(Stream.Null);
-            }
-
-            var filePart = (SevenZipFilePart)entry.FilePart;
-            if (!filePart.Header.HasStream)
-            {
-                // Entries with no underlying stream (e.g., empty files or anti-items)
-                // should return an empty stream, matching previous behavior.
-                return CreateEntryStream(Stream.Null);
-            }
-
-            var folder = filePart.Folder;
-            // Check if we're starting a new folder - dispose old folder stream if needed
-            if (folder != _currentFolder)
-            {
-                _currentFolderStream?.Dispose();
-                _currentFolderStream = null;
-                _currentFolder = folder;
-            }
-
-            // Create the folder stream once per folder
-            if (_currentFolderStream is null)
-            {
-                _currentFolderStream = _archive._database!.GetFolderStream(
-                    _archive.Volumes.Single().Stream,
-                    folder!,
-                    _archive._database.PasswordProvider
-                );
-            }
-
-            // Wrap with SyncOnlyStream to work around LZMA async bugs
-            // Return a ReadOnlySubStream that reads from the shared folder stream
-            return CreateEntryStream(
-                new SyncOnlyStream(
-                    new ReadOnlySubStream(_currentFolderStream, entry.Size, leaveOpen: true)
+        protected override EntryStream GetEntryStream() =>
+            CreateEntryStream(
+                new ReadOnlySubStream(
+                    _currentStream.NotNull("currentStream is not null"),
+                    _currentItem?.Size ?? 0
                 )
             );
-        }
-
-        public override void Dispose()
-        {
-            _currentFolderStream?.Dispose();
-            _currentFolderStream = null;
-            base.Dispose();
-        }
-    }
-
-    /// <summary>
-    /// WORKAROUND: Forces async operations to use synchronous equivalents.
-    /// This is necessary because the LZMA decoder has bugs in its async implementation
-    /// that cause state corruption (IndexOutOfRangeException, DataErrorException).
-    ///
-    /// The proper fix would be to repair the LZMA decoder's async methods
-    /// (LzmaStream.ReadAsync, Decoder.CodeAsync, OutWindow async operations),
-    /// but that requires deep changes to the decoder state machine.
-    /// </summary>
-    private sealed class SyncOnlyStream : Stream
-    {
-        private readonly Stream _baseStream;
-
-        public SyncOnlyStream(Stream baseStream) => _baseStream = baseStream;
-
-        public override bool CanRead => _baseStream.CanRead;
-        public override bool CanSeek => _baseStream.CanSeek;
-        public override bool CanWrite => _baseStream.CanWrite;
-        public override long Length => _baseStream.Length;
-        public override long Position
-        {
-            get => _baseStream.Position;
-            set => _baseStream.Position = value;
-        }
-
-        public override void Flush() => _baseStream.Flush();
-
-        public override int Read(byte[] buffer, int offset, int count) =>
-            _baseStream.Read(buffer, offset, count);
-
-        public override long Seek(long offset, SeekOrigin origin) =>
-            _baseStream.Seek(offset, origin);
-
-        public override void SetLength(long value) => _baseStream.SetLength(value);
-
-        public override void Write(byte[] buffer, int offset, int count) =>
-            _baseStream.Write(buffer, offset, count);
-
-        // Force async operations to use sync equivalents to avoid LZMA decoder bugs
-        public override Task<int> ReadAsync(
-            byte[] buffer,
-            int offset,
-            int count,
-            CancellationToken cancellationToken
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            return Task.FromResult(_baseStream.Read(buffer, offset, count));
-        }
-
-        public override Task WriteAsync(
-            byte[] buffer,
-            int offset,
-            int count,
-            CancellationToken cancellationToken
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            _baseStream.Write(buffer, offset, count);
-            return Task.CompletedTask;
-        }
-
-        public override Task FlushAsync(CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            _baseStream.Flush();
-            return Task.CompletedTask;
-        }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-        public override ValueTask<int> ReadAsync(
-            Memory<byte> buffer,
-            CancellationToken cancellationToken = default
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            return new ValueTask<int>(_baseStream.Read(buffer.Span));
-        }
-
-        public override ValueTask WriteAsync(
-            ReadOnlyMemory<byte> buffer,
-            CancellationToken cancellationToken = default
-        )
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            _baseStream.Write(buffer.Span);
-            return ValueTask.CompletedTask;
-        }
-#endif
-
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing)
-            {
-                _baseStream.Dispose();
-            }
-            base.Dispose(disposing);
-        }
     }
 
     private class PasswordProvider : IPasswordProvider

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -2,12 +2,14 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
+using SharpCompress.Polyfills;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Tar;
 using SharpCompress.Writers;
@@ -28,6 +30,22 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<TarArchive> OpenAsync(
+        string filePath,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return await OpenAsync(new FileInfo(filePath), readerOptions ?? new ReaderOptions(), cancellationToken);
+    }
+
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
@@ -45,6 +63,32 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         );
     }
 
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<TarArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        var archive = new TarArchive();
+        archive.SourceStream = new SourceStream(
+            fileInfo,
+            i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+            readerOptions ?? new ReaderOptions()
+        );
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<TarVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<TarArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     /// <summary>
     /// Constructor with all file parts passed in
     /// </summary>
@@ -66,6 +110,33 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         );
     }
 
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<TarArchive> OpenAsync(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        var archive = new TarArchive();
+        archive.SourceStream = new SourceStream(
+            files[0],
+            i => i < files.Length ? files[i] : null,
+            readerOptions ?? new ReaderOptions()
+        );
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<TarVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<TarArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     /// <summary>
     /// Constructor with all stream parts passed in
     /// </summary>
@@ -84,6 +155,33 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         );
     }
 
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<TarArchive> OpenAsync(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        var archive = new TarArchive();
+        archive.SourceStream = new SourceStream(
+            strms[0],
+            i => i < strms.Length ? strms[i] : null,
+            readerOptions ?? new ReaderOptions()
+        );
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<TarVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<TarArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     /// <summary>
     /// Takes a seekable Stream as a source
     /// </summary>
@@ -103,6 +201,34 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         );
     }
 
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<TarArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        var archive = new TarArchive();
+        archive.SourceStream = new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions());
+        archive.LazyVolumes = new Lazy<IReadOnlyCollection<TarVolume>>(() => archive.LoadVolumes(archive.SourceStream).ToList());
+        archive.LazyEntries = new Lazy<IReadOnlyCollection<TarArchiveEntry>>(
+            () => archive.LoadEntriesAsync(archive.Volumes, cancellationToken).GetAwaiter().GetResult().ToList()
+        );
+        return archive;
+    }
+
     public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
 
     public static bool IsTarFile(FileInfo fileInfo)
@@ -115,6 +241,24 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         return IsTarFile(stream);
     }
 
+    public static async Task<bool> IsTarFileAsync(
+        string filePath,
+        CancellationToken cancellationToken = default
+    ) => await IsTarFileAsync(new FileInfo(filePath), cancellationToken);
+
+    public static async Task<bool> IsTarFileAsync(
+        FileInfo fileInfo,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return await IsTarFileAsync(stream, cancellationToken);
+    }
+
     public static bool IsTarFile(Stream stream)
     {
         try
@@ -131,6 +275,26 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         return false;
     }
 
+    public static async Task<bool> IsTarFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        try
+        {
+            var tarHeader = new TarHeader(new ArchiveEncoding());
+            var readSucceeded = await tarHeader.ReadAsync(stream, cancellationToken)
+                .ConfigureAwait(false);
+            var isEmptyArchive =
+                tarHeader.Name?.Length == 0
+                && tarHeader.Size == 0
+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
+        }
+        catch { }
+        return false;
+    }
+
     protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
     {
         sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
@@ -145,7 +309,11 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         : base(ArchiveType.Tar, sourceStream) { }
 
     private TarArchive()
-        : base(ArchiveType.Tar) { }
+        : base(ArchiveType.Tar)
+    {
+        LazyVolumes = new Lazy<IReadOnlyCollection<TarVolume>>(() => LoadVolumes(SourceStream!).ToList());
+        LazyEntries = new Lazy<IReadOnlyCollection<TarArchiveEntry>>(() => LoadEntries(Volumes).ToList());
+    }
 
     protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
     {
@@ -180,7 +348,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
                         using (var entryStream = entry.OpenEntryStream())
                         {
                             using var memoryStream = new MemoryStream();
-                            entryStream.CopyTo(memoryStream, Constants.BufferSize);
+                            entryStream.CopyTo(memoryStream);
                             memoryStream.Position = 0;
                             var bytes = memoryStream.ToArray();
 
@@ -205,6 +373,67 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         }
     }
 
+    private async Task<IReadOnlyCollection<TarArchiveEntry>> LoadEntriesAsync(IEnumerable<TarVolume> volumes, CancellationToken cancellationToken)
+    {
+        var list = new List<TarArchiveEntry>();
+        var stream = volumes.Single().Stream;
+        TarHeader? previousHeader = null;
+        await foreach (
+            var header in TarHeaderFactory.ReadHeaderAsync(
+                StreamingMode.Seekable,
+                stream,
+                ReaderOptions.ArchiveEncoding,
+                cancellationToken
+            ).WithCancellation(cancellationToken)
+        )
+        {
+            if (header != null)
+            {
+                if (header.EntryType == EntryType.LongName)
+                {
+                    previousHeader = header;
+                }
+                else
+                {
+                    if (previousHeader != null)
+                    {
+                        var entry = new TarArchiveEntry(
+                            this,
+                            new TarFilePart(previousHeader, stream),
+                            CompressionType.None
+                        );
+
+                        var oldStreamPos = stream.Position;
+
+                        using (var entryStream = entry.OpenEntryStream())
+                        {
+                            using var memoryStream = new MemoryStream();
+                            await entryStream.CopyToAsync(memoryStream, cancellationToken).ConfigureAwait(false);
+                            memoryStream.Position = 0;
+                            var bytes = memoryStream.ToArray();
+
+                            header.Name = ReaderOptions.ArchiveEncoding.Decode(bytes).TrimNulls();
+                        }
+
+                        stream.Position = oldStreamPos;
+
+                        previousHeader = null;
+                    }
+                    list.Add(new TarArchiveEntry(
+                        this,
+                        new TarFilePart(header, stream),
+                        CompressionType.None
+                    ));
+                }
+            }
+            else
+            {
+                throw new IncompleteArchiveException("Failed to read TAR header");
+            }
+        }
+        return list.AsReadOnly();
+    }
+
     public static TarArchive Create() => new();
 
     protected override TarArchiveEntry CreateEntryInternal(

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -18,7 +18,7 @@ namespace SharpCompress.Archives.Zip;
 
 public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 {
-    private readonly SeekableZipHeaderFactory? headerFactory;
+    protected internal SeekableZipHeaderFactory? headerFactory;
 
     /// <summary>
     /// Gets or sets the compression level applied to files added to the archive,
@@ -124,27 +124,46 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         );
     }
 
-    public static bool IsZipFile(string filePath, string? password = null) =>
-        IsZipFile(new FileInfo(filePath), password);
+    public static bool IsZipFile(
+        string filePath,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => IsZipFile(new FileInfo(filePath), password, bufferSize);
 
-    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
+    public static bool IsZipFile(
+        FileInfo fileInfo,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         if (!fileInfo.Exists)
         {
             return false;
         }
         using Stream stream = fileInfo.OpenRead();
-        return IsZipFile(stream, password);
+        return IsZipFile(stream, password, bufferSize);
     }
 
-    public static bool IsZipFile(Stream stream, string? password = null)
+
+
+// ... other using statements
+
+namespace SharpCompress.Archives.Zip;
+
+//... existing class
+
+    public static bool IsZipFile(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
         try
         {
             if (stream is not SharpCompressStream)
             {
-                stream = new SharpCompressStream(stream, bufferSize: Constants.BufferSize);
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
             }
 
             var header = headerFactory
@@ -166,14 +185,53 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
     }
 
-    public static bool IsZipMulti(Stream stream, string? password = null)
+    public static async Task<bool> IsZipFileAsync(
+        Stream stream,
+        string? password = null,
+        CancellationToken cancellationToken = default,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
         try
         {
             if (stream is not SharpCompressStream)
             {
-                stream = new SharpCompressStream(stream, bufferSize: Constants.BufferSize);
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = await headerFactory
+                .ReadStreamHeaderAsync(stream, cancellationToken)
+                .FirstOrDefaultAsync(x => x.ZipHeaderType != ZipHeaderType.Split, cancellationToken)
+                .ConfigureAwait(false);
+            if (header is null)
+            {
+                return false;
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsZipMulti(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
             }
 
             var header = headerFactory
@@ -204,6 +262,50 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
     }
 
+    public static async Task<bool> IsZipMultiAsync(
+        Stream stream,
+        string? password = null,
+        CancellationToken cancellationToken = default,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = await headerFactory
+                .ReadStreamHeaderAsync(stream, cancellationToken)
+                .FirstOrDefaultAsync(x => x.ZipHeaderType != ZipHeaderType.Split, cancellationToken)
+                .ConfigureAwait(false);
+            if (header is null)
+            {
+                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
+                {
+                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
     {
         stream.LoadAllParts(); //request all streams
@@ -214,7 +316,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         if (streams.Count() > 1) //test part 2 - true = multipart not split
         {
             streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
-            var isZip = IsZipFile(streams[1], ReaderOptions.Password);
+            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
             streams[1].Position -= 4;
             if (isZip)
             {

src/SharpCompress/AssemblyInfo.cs

@@ -1,8 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 
-// CLSCompliant(false) is required because ZStandard integration uses unsafe code
-[assembly: CLSCompliant(false)]
+[assembly: CLSCompliant(true)]
 [assembly: InternalsVisibleTo(
     "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc"
 )]

src/SharpCompress/Common/Ace/AceCrc.cs

@@ -1,61 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common.Ace
-{
-    public class AceCrc
-    {
-        // CRC-32 lookup table (standard polynomial 0xEDB88320, reflected)
-        private static readonly uint[] Crc32Table = GenerateTable();
-
-        private static uint[] GenerateTable()
-        {
-            var table = new uint[256];
-
-            for (int i = 0; i < 256; i++)
-            {
-                uint crc = (uint)i;
-
-                for (int j = 0; j < 8; j++)
-                {
-                    if ((crc & 1) != 0)
-                        crc = (crc >> 1) ^ 0xEDB88320u;
-                    else
-                        crc >>= 1;
-                }
-
-                table[i] = crc;
-            }
-
-            return table;
-        }
-
-        /// <summary>
-        /// Calculate ACE CRC-32 checksum.
-        /// ACE CRC-32 uses standard CRC-32 polynomial (0xEDB88320, reflected)
-        /// with init=0xFFFFFFFF but NO final XOR.
-        /// </summary>
-        public static uint AceCrc32(ReadOnlySpan<byte> data)
-        {
-            uint crc = 0xFFFFFFFFu;
-
-            foreach (byte b in data)
-            {
-                crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF];
-            }
-
-            return crc; // No final XOR for ACE
-        }
-
-        /// <summary>
-        /// ACE CRC-16 is the lower 16 bits of the ACE CRC-32.
-        /// </summary>
-        public static ushort AceCrc16(ReadOnlySpan<byte> data)
-        {
-            return (ushort)(AceCrc32(data) & 0xFFFF);
-        }
-    }
-}

src/SharpCompress/Common/Ace/AceEntry.cs

@@ -1,68 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Ace.Headers;
-
-namespace SharpCompress.Common.Ace
-{
-    public class AceEntry : Entry
-    {
-        private readonly AceFilePart _filePart;
-
-        internal AceEntry(AceFilePart filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override long Crc
-        {
-            get
-            {
-                if (_filePart == null)
-                {
-                    return 0;
-                }
-                return _filePart.Header.Crc32;
-            }
-        }
-
-        public override string? Key => _filePart?.Header.Filename;
-
-        public override string? LinkTarget => null;
-
-        public override long CompressedSize => _filePart?.Header.PackedSize ?? 0;
-
-        public override CompressionType CompressionType
-        {
-            get
-            {
-                if (_filePart.Header.CompressionType == Headers.CompressionType.Stored)
-                {
-                    return CompressionType.None;
-                }
-                return CompressionType.AceLZ77;
-            }
-        }
-
-        public override long Size => _filePart?.Header.OriginalSize ?? 0;
-
-        public override DateTime? LastModifiedTime => _filePart.Header.DateTime;
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => _filePart.Header.IsFileEncrypted;
-
-        public override bool IsDirectory => _filePart.Header.IsDirectory;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
-    }
-}

src/SharpCompress/Common/Ace/AceFilePart.cs

@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Ace.Headers;
-using SharpCompress.IO;
-
-namespace SharpCompress.Common.Ace
-{
-    public class AceFilePart : FilePart
-    {
-        private readonly Stream _stream;
-        internal AceFileHeader Header { get; set; }
-
-        internal AceFilePart(AceFileHeader localAceHeader, Stream seekableStream)
-            : base(localAceHeader.ArchiveEncoding)
-        {
-            _stream = seekableStream;
-            Header = localAceHeader;
-        }
-
-        internal override string? FilePartName => Header.Filename;
-
-        internal override Stream GetCompressedStream()
-        {
-            if (_stream != null)
-            {
-                Stream compressedStream;
-                switch (Header.CompressionType)
-                {
-                    case Headers.CompressionType.Stored:
-                        compressedStream = new ReadOnlySubStream(
-                            _stream,
-                            Header.DataStartPosition,
-                            Header.PackedSize
-                        );
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            "CompressionMethod: " + Header.CompressionQuality
-                        );
-                }
-                return compressedStream;
-            }
-            return _stream.NotNull();
-        }
-
-        internal override Stream? GetRawStream() => _stream;
-    }
-}

src/SharpCompress/Common/Ace/AceVolume.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Arj;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Common.Ace
-{
-    public class AceVolume : Volume
-    {
-        public AceVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-            : base(stream, readerOptions, index) { }
-
-        public override bool IsFirstVolume
-        {
-            get { return true; }
-        }
-
-        /// <summary>
-        /// ArjArchive is part of a multi-part archive.
-        /// </summary>
-        public override bool IsMultiVolume
-        {
-            get { return false; }
-        }
-
-        internal IEnumerable<AceFilePart> GetVolumeFileParts()
-        {
-            return new List<AceFilePart>();
-        }
-    }
-}

src/SharpCompress/Common/Ace/Headers/AceFileHeader.cs

@@ -1,171 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.Collections.Generic;
-using System.IO;
-using System.Xml.Linq;
-using SharpCompress.Common.Arc;
-
-namespace SharpCompress.Common.Ace.Headers
-{
-    /// <summary>
-    /// ACE file entry header
-    /// </summary>
-    public sealed class AceFileHeader : AceHeader
-    {
-        public long DataStartPosition { get; private set; }
-        public long PackedSize { get; set; }
-        public long OriginalSize { get; set; }
-        public DateTime DateTime { get; set; }
-        public int Attributes { get; set; }
-        public uint Crc32 { get; set; }
-        public CompressionType CompressionType { get; set; }
-        public CompressionQuality CompressionQuality { get; set; }
-        public ushort Parameters { get; set; }
-        public string Filename { get; set; } = string.Empty;
-        public List<byte> Comment { get; set; } = new();
-
-        /// <summary>
-        /// File data offset in the archive
-        /// </summary>
-        public ulong DataOffset { get; set; }
-
-        public bool IsDirectory => (Attributes & 0x10) != 0;
-
-        public bool IsContinuedFromPrev =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_PREV) != 0;
-
-        public bool IsContinuedToNext =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_NEXT) != 0;
-
-        public int DictionarySize
-        {
-            get
-            {
-                int bits = Parameters & 0x0F;
-                return bits < 10 ? 1024 : 1 << bits;
-            }
-        }
-
-        public AceFileHeader(ArchiveEncoding archiveEncoding)
-            : base(archiveEncoding, AceHeaderType.FILE) { }
-
-        /// <summary>
-        /// Reads the next file entry header from the stream.
-        /// Returns null if no more entries or end of archive.
-        /// Supports both ACE 1.0 and ACE 2.0 formats.
-        /// </summary>
-        public override AceHeader? Read(Stream stream)
-        {
-            var headerData = ReadHeader(stream);
-            if (headerData.Length == 0)
-            {
-                return null;
-            }
-            int offset = 0;
-
-            // Header type (1 byte)
-            HeaderType = headerData[offset++];
-
-            // Skip recovery record headers (ACE 2.0 feature)
-            if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32)
-            {
-                // Skip to next header
-                return null;
-            }
-
-            if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE)
-            {
-                // Unknown header type - skip
-                return null;
-            }
-
-            // Header flags (2 bytes)
-            HeaderFlags = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Packed size (4 bytes)
-            PackedSize = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // Original size (4 bytes)
-            OriginalSize = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // File date/time in DOS format (4 bytes)
-            var dosDateTime = BitConverter.ToUInt32(headerData, offset);
-            DateTime = ConvertDosDateTime(dosDateTime);
-            offset += 4;
-
-            // File attributes (4 bytes)
-            Attributes = (int)BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // CRC32 (4 bytes)
-            Crc32 = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // Compression type (1 byte)
-            byte compressionType = headerData[offset++];
-            CompressionType = GetCompressionType(compressionType);
-
-            // Compression quality/parameter (1 byte)
-            byte compressionQuality = headerData[offset++];
-            CompressionQuality = GetCompressionQuality(compressionQuality);
-
-            // Parameters (2 bytes)
-            Parameters = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Reserved (2 bytes) - skip
-            offset += 2;
-
-            // Filename length (2 bytes)
-            var filenameLength = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Filename
-            if (offset + filenameLength <= headerData.Length)
-            {
-                Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength);
-                offset += filenameLength;
-            }
-
-            // Handle comment if present
-            if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
-            {
-                // Comment length (2 bytes)
-                if (offset + 2 <= headerData.Length)
-                {
-                    ushort commentLength = BitConverter.ToUInt16(headerData, offset);
-                    offset += 2 + commentLength; // Skip comment
-                }
-            }
-
-            // Store the data start position
-            DataStartPosition = stream.Position;
-
-            return this;
-        }
-
-        public CompressionType GetCompressionType(byte value) =>
-            value switch
-            {
-                0 => CompressionType.Stored,
-                1 => CompressionType.Lz77,
-                2 => CompressionType.Blocked,
-                _ => CompressionType.Unknown,
-            };
-
-        public CompressionQuality GetCompressionQuality(byte value) =>
-            value switch
-            {
-                0 => CompressionQuality.None,
-                1 => CompressionQuality.Fastest,
-                2 => CompressionQuality.Fast,
-                3 => CompressionQuality.Normal,
-                4 => CompressionQuality.Good,
-                5 => CompressionQuality.Best,
-                _ => CompressionQuality.Unknown,
-            };
-    }
-}

src/SharpCompress/Common/Ace/Headers/AceHeader.cs

@@ -1,153 +0,0 @@
-using System;
-using System.IO;
-using SharpCompress.Common.Arj.Headers;
-using SharpCompress.Crypto;
-
-namespace SharpCompress.Common.Ace.Headers
-{
-    /// <summary>
-    /// Header type constants
-    /// </summary>
-    public enum AceHeaderType
-    {
-        MAIN = 0,
-        FILE = 1,
-        RECOVERY32 = 2,
-        RECOVERY64A = 3,
-        RECOVERY64B = 4,
-    }
-
-    public abstract class AceHeader
-    {
-        // ACE signature: bytes at offset 7 should be "**ACE**"
-        private static readonly byte[] AceSignature =
-        [
-            (byte)'*',
-            (byte)'*',
-            (byte)'A',
-            (byte)'C',
-            (byte)'E',
-            (byte)'*',
-            (byte)'*',
-        ];
-
-        public AceHeader(ArchiveEncoding archiveEncoding, AceHeaderType type)
-        {
-            AceHeaderType = type;
-            ArchiveEncoding = archiveEncoding;
-        }
-
-        public ArchiveEncoding ArchiveEncoding { get; }
-        public AceHeaderType AceHeaderType { get; }
-
-        public ushort HeaderFlags { get; set; }
-        public ushort HeaderCrc { get; set; }
-        public ushort HeaderSize { get; set; }
-        public byte HeaderType { get; set; }
-
-        public bool IsFileEncrypted =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.FILE_ENCRYPTED) != 0;
-        public bool Is64Bit =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MEMORY_64BIT) != 0;
-
-        public bool IsSolid =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.SOLID_MAIN) != 0;
-
-        public bool IsMultiVolume =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MULTIVOLUME) != 0;
-
-        public abstract AceHeader? Read(Stream reader);
-
-        public byte[] ReadHeader(Stream stream)
-        {
-            // Read header CRC (2 bytes) and header size (2 bytes)
-            var headerBytes = new byte[4];
-            if (stream.Read(headerBytes, 0, 4) != 4)
-            {
-                return Array.Empty<byte>();
-            }
-
-            HeaderCrc = BitConverter.ToUInt16(headerBytes, 0); // CRC for validation
-            HeaderSize = BitConverter.ToUInt16(headerBytes, 2);
-            if (HeaderSize == 0)
-            {
-                return Array.Empty<byte>();
-            }
-
-            // Read the header data
-            var body = new byte[HeaderSize];
-            if (stream.Read(body, 0, HeaderSize) != HeaderSize)
-            {
-                return Array.Empty<byte>();
-            }
-
-            // Verify crc
-            var checksum = AceCrc.AceCrc16(body);
-            if (checksum != HeaderCrc)
-            {
-                throw new InvalidDataException("Header checksum is invalid");
-            }
-            return body;
-        }
-
-        public static bool IsArchive(Stream stream)
-        {
-            // ACE files have a specific signature
-            // First two bytes are typically 0x60 0xEA (signature bytes)
-            // At offset 7, there should be "**ACE**" (7 bytes)
-            var bytes = new byte[14];
-            if (stream.Read(bytes, 0, 14) != 14)
-            {
-                return false;
-            }
-
-            // Check for "**ACE**" at offset 7
-            return CheckMagicBytes(bytes, 7);
-        }
-
-        protected static bool CheckMagicBytes(byte[] headerBytes, int offset)
-        {
-            // Check for "**ACE**" at specified offset
-            for (int i = 0; i < AceSignature.Length; i++)
-            {
-                if (headerBytes[offset + i] != AceSignature[i])
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        protected DateTime ConvertDosDateTime(uint dosDateTime)
-        {
-            try
-            {
-                int second = (int)(dosDateTime & 0x1F) * 2;
-                int minute = (int)((dosDateTime >> 5) & 0x3F);
-                int hour = (int)((dosDateTime >> 11) & 0x1F);
-                int day = (int)((dosDateTime >> 16) & 0x1F);
-                int month = (int)((dosDateTime >> 21) & 0x0F);
-                int year = (int)((dosDateTime >> 25) & 0x7F) + 1980;
-
-                if (
-                    day < 1
-                    || day > 31
-                    || month < 1
-                    || month > 12
-                    || hour > 23
-                    || minute > 59
-                    || second > 59
-                )
-                {
-                    return DateTime.MinValue;
-                }
-
-                return new DateTime(year, month, day, hour, minute, second);
-            }
-            catch
-            {
-                return DateTime.MinValue;
-            }
-        }
-    }
-}

src/SharpCompress/Common/Ace/Headers/AceMainHeader.cs

@@ -1,97 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Common.Ace.Headers;
-using SharpCompress.Common.Zip.Headers;
-using SharpCompress.Crypto;
-
-namespace SharpCompress.Common.Ace.Headers
-{
-    /// <summary>
-    /// ACE main archive header
-    /// </summary>
-    public sealed class AceMainHeader : AceHeader
-    {
-        public byte ExtractVersion { get; set; }
-        public byte CreatorVersion { get; set; }
-        public HostOS HostOS { get; set; }
-        public byte VolumeNumber { get; set; }
-        public DateTime DateTime { get; set; }
-        public string Advert { get; set; } = string.Empty;
-        public List<byte> Comment { get; set; } = new();
-        public byte AceVersion { get; private set; }
-
-        public AceMainHeader(ArchiveEncoding archiveEncoding)
-            : base(archiveEncoding, AceHeaderType.MAIN) { }
-
-        /// <summary>
-        /// Reads the main archive header from the stream.
-        /// Returns header if this is a valid ACE archive.
-        /// Supports both ACE 1.0 and ACE 2.0 formats.
-        /// </summary>
-        public override AceHeader? Read(Stream stream)
-        {
-            var headerData = ReadHeader(stream);
-            if (headerData.Length == 0)
-            {
-                return null;
-            }
-            int offset = 0;
-
-            // Header type should be 0 for main header
-            if (headerData[offset++] != HeaderType)
-            {
-                return null;
-            }
-
-            // Header flags (2 bytes)
-            HeaderFlags = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Skip signature "**ACE**" (7 bytes)
-            if (!CheckMagicBytes(headerData, offset))
-            {
-                throw new InvalidDataException("Invalid ACE archive signature.");
-            }
-            offset += 7;
-
-            // ACE version (1 byte) - 10 for ACE 1.0, 20 for ACE 2.0
-            AceVersion = headerData[offset++];
-            ExtractVersion = headerData[offset++];
-
-            // Host OS (1 byte)
-            if (offset < headerData.Length)
-            {
-                var hostOsByte = headerData[offset++];
-                HostOS = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
-            }
-            // Volume number (1 byte)
-            VolumeNumber = headerData[offset++];
-
-            // Creation date/time (4 bytes)
-            var dosDateTime = BitConverter.ToUInt32(headerData, offset);
-            DateTime = ConvertDosDateTime(dosDateTime);
-            offset += 4;
-
-            // Reserved fields (8 bytes)
-            if (offset + 8 <= headerData.Length)
-            {
-                offset += 8;
-            }
-
-            // Skip additional fields based on flags
-            // Handle comment if present
-            if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
-            {
-                if (offset + 2 <= headerData.Length)
-                {
-                    ushort commentLength = BitConverter.ToUInt16(headerData, offset);
-                    offset += 2 + commentLength;
-                }
-            }
-
-            return this;
-        }
-    }
-}

src/SharpCompress/Common/Ace/Headers/CompressionQuality.cs

@@ -1,16 +0,0 @@
-namespace SharpCompress.Common.Ace.Headers
-{
-    /// <summary>
-    /// Compression quality
-    /// </summary>
-    public enum CompressionQuality
-    {
-        None,
-        Fastest,
-        Fast,
-        Normal,
-        Good,
-        Best,
-        Unknown,
-    }
-}

src/SharpCompress/Common/Ace/Headers/CompressionType.cs

@@ -1,13 +0,0 @@
-namespace SharpCompress.Common.Ace.Headers
-{
-    /// <summary>
-    /// Compression types
-    /// </summary>
-    public enum CompressionType
-    {
-        Stored,
-        Lz77,
-        Blocked,
-        Unknown,
-    }
-}

src/SharpCompress/Common/Ace/Headers/HeaderFlags.cs

@@ -1,33 +0,0 @@
-namespace SharpCompress.Common.Ace.Headers
-{
-    /// <summary>
-    /// Header flags (main + file, overlapping meanings)
-    /// </summary>
-    public static class HeaderFlags
-    {
-        // Shared / low bits
-        public const ushort ADDSIZE = 0x0001; // extra size field present
-        public const ushort COMMENT = 0x0002; // comment present
-        public const ushort MEMORY_64BIT = 0x0004;
-        public const ushort AV_STRING = 0x0008; // AV string present
-        public const ushort SOLID = 0x0010; // solid file
-        public const ushort LOCKED = 0x0020;
-        public const ushort PROTECTED = 0x0040;
-
-        // Main header specific
-        public const ushort V20FORMAT = 0x0100;
-        public const ushort SFX = 0x0200;
-        public const ushort LIMITSFXJR = 0x0400;
-        public const ushort MULTIVOLUME = 0x0800;
-        public const ushort ADVERT = 0x1000;
-        public const ushort RECOVERY = 0x2000;
-        public const ushort LOCKED_MAIN = 0x4000;
-        public const ushort SOLID_MAIN = 0x8000;
-
-        // File header specific (same bits, different meaning)
-        public const ushort NTSECURITY = 0x0400;
-        public const ushort CONTINUED_PREV = 0x1000;
-        public const ushort CONTINUED_NEXT = 0x2000;
-        public const ushort FILE_ENCRYPTED = 0x4000; // file encrypted (file header)
-    }
-}

src/SharpCompress/Common/Ace/Headers/HostOS.cs

@@ -1,22 +0,0 @@
-namespace SharpCompress.Common.Ace.Headers
-{
-    /// <summary>
-    /// Host OS type
-    /// </summary>
-    public enum HostOS
-    {
-        MsDos = 0,
-        Os2,
-        Windows,
-        Unix,
-        MacOs,
-        WinNt,
-        Primos,
-        AppleGs,
-        Atari,
-        Vax,
-        Amiga,
-        Next,
-        Unknown,
-    }
-}

src/SharpCompress/Common/ArchiveExtractionEventArgs.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class ArchiveExtractionEventArgs<T> : EventArgs
+{
+    internal ArchiveExtractionEventArgs(T entry) => Item = entry;
+
+    public T Item { get; }
+}

src/SharpCompress/Common/ArchiveType.cs

@@ -9,5 +9,4 @@ public enum ArchiveType
     GZip,
     Arc,
     Arj,
-    Ace,
 }

src/SharpCompress/Common/Arj/Headers/ArjHeader.cs

@@ -34,13 +34,14 @@ namespace SharpCompress.Common.Arj.Headers
         public byte[] ReadHeader(Stream stream)
         {
             // check for magic bytes
-            var magic = new byte[2];
+            Span<byte> magic = stackalloc byte[2];
             if (stream.Read(magic) != 2)
             {
                 return Array.Empty<byte>();
             }
 
-            if (!CheckMagicBytes(magic))
+            var magicValue = (ushort)(magic[0] | magic[1] << 8);
+            if (magicValue != ARJ_MAGIC)
             {
                 throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
             }
@@ -137,22 +138,5 @@ namespace SharpCompress.Common.Arj.Headers
                 ? (FileType)value
                 : Headers.FileType.Unknown;
         }
-
-        public static bool IsArchive(Stream stream)
-        {
-            var bytes = new byte[2];
-            if (stream.Read(bytes, 0, 2) != 2)
-            {
-                return false;
-            }
-
-            return CheckMagicBytes(bytes);
-        }
-
-        protected static bool CheckMagicBytes(byte[] headerBytes)
-        {
-            var magicValue = (ushort)(headerBytes[0] | headerBytes[1] << 8);
-            return magicValue == ARJ_MAGIC;
-        }
     }
 }

src/SharpCompress/Common/CompressedBytesReadEventArgs.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public sealed class CompressedBytesReadEventArgs : EventArgs
+{
+    public CompressedBytesReadEventArgs(
+        long compressedBytesRead,
+        long currentFilePartCompressedBytesRead
+    )
+    {
+        CompressedBytesRead = compressedBytesRead;
+        CurrentFilePartCompressedBytesRead = currentFilePartCompressedBytesRead;
+    }
+
+    /// <summary>
+    /// Compressed bytes read for the current entry
+    /// </summary>
+    public long CompressedBytesRead { get; }
+
+    /// <summary>
+    /// Current file part read for Multipart files (e.g. Rar)
+    /// </summary>
+    public long CurrentFilePartCompressedBytesRead { get; }
+}

src/SharpCompress/Common/CompressionType.cs

@@ -30,5 +30,4 @@ public enum CompressionType
     Distilled,
     ZStandard,
     ArjLZ77,
-    AceLZ77,
 }

src/SharpCompress/Common/Constants.cs

@@ -1,10 +0,0 @@
-namespace SharpCompress.Common;
-
-public static class Constants
-{
-    /// <summary>
-    /// The default buffer size for stream operations, matching .NET's Stream.CopyTo default of 81920 bytes.
-    /// This can be modified globally at runtime.
-    /// </summary>
-    public static int BufferSize { get; set; } = 81920;
-}

src/SharpCompress/Common/ExtractionMethods.cs

@@ -128,7 +128,7 @@ internal static class ExtractionMethods
         IEntry entry,
         string destinationDirectory,
         ExtractionOptions? options,
-        Func<string, ExtractionOptions?, CancellationToken, Task> writeAsync,
+        Func<string, ExtractionOptions?, Task> writeAsync,
         CancellationToken cancellationToken = default
     )
     {
@@ -189,7 +189,7 @@ internal static class ExtractionMethods
                     "Entry is trying to write a file outside of the destination directory."
                 );
             }
-            await writeAsync(destinationFileName, options, cancellationToken).ConfigureAwait(false);
+            await writeAsync(destinationFileName, options).ConfigureAwait(false);
         }
         else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
         {
@@ -201,7 +201,7 @@ internal static class ExtractionMethods
         IEntry entry,
         string destinationFileName,
         ExtractionOptions? options,
-        Func<string, FileMode, CancellationToken, Task> openAndWriteAsync,
+        Func<string, FileMode, Task> openAndWriteAsync,
         CancellationToken cancellationToken = default
     )
     {
@@ -225,8 +225,7 @@ internal static class ExtractionMethods
                 fm = FileMode.CreateNew;
             }
 
-            await openAndWriteAsync(destinationFileName, fm, cancellationToken)
-                .ConfigureAwait(false);
+            await openAndWriteAsync(destinationFileName, fm).ConfigureAwait(false);
             entry.PreserveExtractionOptions(destinationFileName, options);
         }
     }

src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public sealed class FilePartExtractionBeginEventArgs : EventArgs
+{
+    public FilePartExtractionBeginEventArgs(string name, long size, long compressedSize)
+    {
+        Name = name;
+        Size = size;
+        CompressedSize = compressedSize;
+    }
+
+    /// <summary>
+    /// File name for the part for the current entry
+    /// </summary>
+    public string Name { get; }
+
+    /// <summary>
+    /// Uncompressed size of the current entry in the part
+    /// </summary>
+    public long Size { get; }
+
+    /// <summary>
+    /// Compressed size of the current entry in the part
+    /// </summary>
+    public long CompressedSize { get; }
+}

src/SharpCompress/Common/IExtractionListener.cs

@@ -0,0 +1,7 @@
+namespace SharpCompress.Common;
+
+public interface IExtractionListener
+{
+    void FireFilePartExtractionBegin(string name, long size, long compressedSize);
+    void FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes);
+}

src/SharpCompress/Common/ProgressReport.cs

@@ -1,43 +0,0 @@
-namespace SharpCompress.Common;
-
-/// <summary>
-/// Represents progress information for compression or extraction operations.
-/// </summary>
-public sealed class ProgressReport
-{
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ProgressReport"/> class.
-    /// </summary>
-    /// <param name="entryPath">The path of the entry being processed.</param>
-    /// <param name="bytesTransferred">Number of bytes transferred so far.</param>
-    /// <param name="totalBytes">Total bytes to be transferred, or null if unknown.</param>
-    public ProgressReport(string entryPath, long bytesTransferred, long? totalBytes)
-    {
-        EntryPath = entryPath;
-        BytesTransferred = bytesTransferred;
-        TotalBytes = totalBytes;
-    }
-
-    /// <summary>
-    /// Gets the path of the entry being processed.
-    /// </summary>
-    public string EntryPath { get; }
-
-    /// <summary>
-    /// Gets the number of bytes transferred so far.
-    /// </summary>
-    public long BytesTransferred { get; }
-
-    /// <summary>
-    /// Gets the total number of bytes to be transferred, or null if unknown.
-    /// </summary>
-    public long? TotalBytes { get; }
-
-    /// <summary>
-    /// Gets the progress percentage (0-100), or null if total bytes is unknown.
-    /// </summary>
-    public double? PercentComplete =>
-        TotalBytes.HasValue && TotalBytes.Value > 0
-            ? (double)BytesTransferred / TotalBytes.Value * 100
-            : null;
-}

src/SharpCompress/Common/Rar/Headers/MarkHeader.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Rar.Headers;
 
@@ -25,6 +27,20 @@ internal class MarkHeader : IRarHeader
         throw new EndOfStreamException();
     }
 
+    private static async Task<byte> GetByteAsync(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        byte[] buffer = new byte[1];
+        var read = await stream.ReadAsync(buffer, 0, 1, cancellationToken).ConfigureAwait(false);
+        if (read == 1)
+        {
+            return buffer[0];
+        }
+        throw new EndOfStreamException();
+    }
+
     public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader)
     {
         var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
@@ -129,4 +145,115 @@ internal class MarkHeader : IRarHeader
 
         throw new InvalidFormatException("Rar signature not found");
     }
+
+    public static async Task<MarkHeader> ReadAsync(
+        Stream stream,
+        bool leaveStreamOpen,
+        bool lookForHeader,
+        CancellationToken cancellationToken
+    )
+    {
+        var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
+        try
+        {
+            var start = -1;
+            var b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+            start++;
+            while (start <= maxScanIndex)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                // Rar old signature: 52 45 7E 5E
+                // Rar4 signature:    52 61 72 21 1A 07 00
+                // Rar5 signature:    52 61 72 21 1A 07 01 00
+                if (b == 0x52)
+                {
+                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                    start++;
+                    if (b == 0x61)
+                    {
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x72)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x21)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x1a)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x07)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b == 1)
+                        {
+                            b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                            start++;
+                            if (b != 0)
+                            {
+                                continue;
+                            }
+
+                            return new MarkHeader(true); // Rar5
+                        }
+                        else if (b == 0)
+                        {
+                            return new MarkHeader(false); // Rar4
+                        }
+                    }
+                    else if (b == 0x45)
+                    {
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x7e)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x5e)
+                        {
+                            continue;
+                        }
+
+                        throw new InvalidFormatException(
+                            "Rar format version pre-4 is unsupported."
+                        );
+                    }
+                }
+                else
+                {
+                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                    start++;
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            if (!leaveStreamOpen)
+            {
+                stream.Dispose();
+            }
+            throw new InvalidFormatException("Error trying to read rar signature.", e);
+        }
+
+        throw new InvalidFormatException("Rar signature not found");
+    }
 }

src/SharpCompress/Common/ReaderExtractionEventArgs.cs

@@ -0,0 +1,17 @@
+using System;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Common;
+
+public sealed class ReaderExtractionEventArgs<T> : EventArgs
+{
+    internal ReaderExtractionEventArgs(T entry, ReaderProgress? readerProgress = null)
+    {
+        Item = entry;
+        ReaderProgress = readerProgress;
+    }
+
+    public T Item { get; }
+
+    public ReaderProgress? ReaderProgress { get; }
+}

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -55,7 +55,7 @@ internal class SevenZipFilePart : FilePart
         {
             folderStream.Skip(skipSize);
         }
-        return new ReadOnlySubStream(folderStream, Header.Size, leaveOpen: false);
+        return new ReadOnlySubStream(folderStream, Header.Size);
     }
 
     public CompressionType CompressionType

src/SharpCompress/Common/Tar/Headers/TarHeader.cs

@@ -1,8 +1,9 @@
 using System;
 using System.Buffers.Binary;
-using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Tar.Headers;
 
@@ -10,16 +11,8 @@ internal sealed class TarHeader
 {
     internal static readonly DateTime EPOCH = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
-    public TarHeader(
-        ArchiveEncoding archiveEncoding,
-        TarHeaderWriteFormat writeFormat = TarHeaderWriteFormat.GNU_TAR_LONG_LINK
-    )
-    {
-        ArchiveEncoding = archiveEncoding;
-        WriteFormat = writeFormat;
-    }
+    public TarHeader(ArchiveEncoding archiveEncoding) => ArchiveEncoding = archiveEncoding;
 
-    internal TarHeaderWriteFormat WriteFormat { get; set; }
     internal string? Name { get; set; }
     internal string? LinkName { get; set; }
 
@@ -39,114 +32,6 @@ internal sealed class TarHeader
     private const int MAX_LONG_NAME_SIZE = 32768;
 
     internal void Write(Stream output)
-    {
-        switch (WriteFormat)
-        {
-            case TarHeaderWriteFormat.GNU_TAR_LONG_LINK:
-                WriteGnuTarLongLink(output);
-                break;
-            case TarHeaderWriteFormat.USTAR:
-                WriteUstar(output);
-                break;
-            default:
-                throw new Exception("This should be impossible...");
-        }
-    }
-
-    internal void WriteUstar(Stream output)
-    {
-        var buffer = new byte[BLOCK_SIZE];
-
-        WriteOctalBytes(511, buffer, 100, 8); // file mode
-        WriteOctalBytes(0, buffer, 108, 8); // owner ID
-        WriteOctalBytes(0, buffer, 116, 8); // group ID
-
-        //ArchiveEncoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
-        var nameByteCount = ArchiveEncoding
-            .GetEncoding()
-            .GetByteCount(Name.NotNull("Name is null"));
-
-        if (nameByteCount > 100)
-        {
-            // if name is longer, try to split it into name and namePrefix
-
-            string fullName = Name.NotNull("Name is null");
-
-            // find all directory separators
-            List<int> dirSeps = new List<int>();
-            for (int i = 0; i < fullName.Length; i++)
-            {
-                if (fullName[i] == Path.DirectorySeparatorChar)
-                {
-                    dirSeps.Add(i);
-                }
-            }
-
-            // find the right place to split the name
-            int splitIndex = -1;
-            for (int i = 0; i < dirSeps.Count; i++)
-            {
-                int count = ArchiveEncoding
-                    .GetEncoding()
-                    .GetByteCount(fullName.Substring(0, dirSeps[i]));
-                if (count < 155)
-                {
-                    splitIndex = dirSeps[i];
-                }
-                else
-                {
-                    break;
-                }
-            }
-
-            if (splitIndex == -1)
-            {
-                throw new Exception(
-                    $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Directory separator not found! Try using GNU Tar format instead!"
-                );
-            }
-
-            string namePrefix = fullName.Substring(0, splitIndex);
-            string name = fullName.Substring(splitIndex + 1);
-
-            if (this.ArchiveEncoding.GetEncoding().GetByteCount(namePrefix) >= 155)
-                throw new Exception(
-                    $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!"
-                );
-
-            if (this.ArchiveEncoding.GetEncoding().GetByteCount(name) >= 100)
-                throw new Exception(
-                    $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!"
-                );
-
-            // write name prefix
-            WriteStringBytes(ArchiveEncoding.Encode(namePrefix), buffer, 345, 100);
-            // write partial name
-            WriteStringBytes(ArchiveEncoding.Encode(name), buffer, 100);
-        }
-        else
-        {
-            WriteStringBytes(ArchiveEncoding.Encode(Name.NotNull("Name is null")), buffer, 100);
-        }
-
-        WriteOctalBytes(Size, buffer, 124, 12);
-        var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
-        WriteOctalBytes(time, buffer, 136, 12);
-        buffer[156] = (byte)EntryType;
-
-        // write ustar magic field
-        WriteStringBytes(Encoding.ASCII.GetBytes("ustar"), buffer, 257, 6);
-        // write ustar version "00"
-        buffer[263] = 0x30;
-        buffer[264] = 0x30;
-
-        var crc = RecalculateChecksum(buffer);
-        WriteOctalBytes(crc, buffer, 148, 8);
-
-        output.Write(buffer, 0, buffer.Length);
-    }
-
-    internal void WriteGnuTarLongLink(Stream output)
     {
         var buffer = new byte[BLOCK_SIZE];
 
@@ -202,7 +87,7 @@ internal sealed class TarHeader
                 0,
                 100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1)
             );
-            WriteGnuTarLongLink(output);
+            Write(output);
         }
     }
 
@@ -304,6 +189,92 @@ internal sealed class TarHeader
         return true;
     }
 
+    internal async Task<bool> ReadAsync(Stream stream, CancellationToken cancellationToken)
+    {
+        string? longName = null;
+        string? longLinkName = null;
+        var hasLongValue = true;
+        byte[] buffer;
+        EntryType entryType;
+
+        do
+        {
+            buffer = await ReadBlockAsync(stream, cancellationToken).ConfigureAwait(false);
+
+            if (buffer.Length == 0)
+            {
+                return false;
+            }
+
+            entryType = ReadEntryType(buffer);
+
+            // LongName and LongLink headers can follow each other and need
+            // to apply to the header that follows them.
+            if (entryType == EntryType.LongName)
+            {
+                longName = await ReadLongNameAsync(stream, buffer, cancellationToken)
+                    .ConfigureAwait(false);
+                continue;
+            }
+            else if (entryType == EntryType.LongLink)
+            {
+                longLinkName = await ReadLongNameAsync(stream, buffer, cancellationToken)
+                    .ConfigureAwait(false);
+                continue;
+            }
+
+            hasLongValue = false;
+        } while (hasLongValue);
+
+        // Check header checksum
+        if (!checkChecksum(buffer))
+        {
+            return false;
+        }
+
+        Name = longName ?? ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
+        EntryType = entryType;
+        Size = ReadSize(buffer);
+
+        // for symlinks, additionally read the linkname
+        if (entryType == EntryType.SymLink || entryType == EntryType.HardLink)
+        {
+            LinkName = longLinkName ?? ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
+        }
+
+        Mode = ReadAsciiInt64Base8(buffer, 100, 7);
+
+        if (entryType == EntryType.Directory)
+        {
+            Mode |= 0b1_000_000_000;
+        }
+
+        UserId = ReadAsciiInt64Base8oldGnu(buffer, 108, 7);
+        GroupId = ReadAsciiInt64Base8oldGnu(buffer, 116, 7);
+
+        var unixTimeStamp = ReadAsciiInt64Base8(buffer, 136, 11);
+
+        LastModifiedTime = EPOCH.AddSeconds(unixTimeStamp).ToLocalTime();
+        Magic = ArchiveEncoding.Decode(buffer, 257, 6).TrimNulls();
+
+        if (!string.IsNullOrEmpty(Magic) && "ustar".Equals(Magic))
+        {
+            var namePrefix = ArchiveEncoding.Decode(buffer, 345, 157).TrimNulls();
+
+            if (!string.IsNullOrEmpty(namePrefix))
+            {
+                Name = namePrefix + "/" + Name;
+            }
+        }
+
+        if (entryType != EntryType.LongName && Name.Length == 0)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
     private string ReadLongName(BinaryReader reader, byte[] buffer)
     {
         var size = ReadSize(buffer);
@@ -328,6 +299,39 @@ internal sealed class TarHeader
         return ArchiveEncoding.Decode(nameBytes, 0, nameBytes.Length).TrimNulls();
     }
 
+    private async Task<string> ReadLongNameAsync(
+        Stream stream,
+        byte[] buffer,
+        CancellationToken cancellationToken
+    )
+    {
+        var size = ReadSize(buffer);
+
+        // Validate size to prevent memory exhaustion from malformed headers
+        if (size < 0 || size > MAX_LONG_NAME_SIZE)
+        {
+            throw new InvalidFormatException(
+                $"Long name size {size} is invalid or exceeds maximum allowed size of {MAX_LONG_NAME_SIZE} bytes"
+            );
+        }
+
+        var nameLength = (int)size;
+        var nameBytes = new byte[nameLength];
+        await ReadFullyAsync(stream, nameBytes, 0, nameLength, cancellationToken)
+            .ConfigureAwait(false);
+
+        var remainingBytesToRead = BLOCK_SIZE - (nameLength % BLOCK_SIZE);
+
+        // Read the rest of the block and discard the data
+        if (remainingBytesToRead > 0 && remainingBytesToRead < BLOCK_SIZE)
+        {
+            var discardBuffer = new byte[remainingBytesToRead];
+            await ReadFullyAsync(stream, discardBuffer, 0, remainingBytesToRead, cancellationToken)
+                .ConfigureAwait(false);
+        }
+        return ArchiveEncoding.Decode(nameBytes, 0, nameBytes.Length).TrimNulls();
+    }
+
     private static EntryType ReadEntryType(byte[] buffer) => (EntryType)buffer[156];
 
     private long ReadSize(byte[] buffer)
@@ -351,6 +355,60 @@ internal sealed class TarHeader
         return buffer;
     }
 
+    private static async Task<byte[]> ReadBlockAsync(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = new byte[BLOCK_SIZE];
+        var bytesRead = 0;
+        while (bytesRead < BLOCK_SIZE)
+        {
+            var read = await stream.ReadAsync(
+                buffer,
+                bytesRead,
+                BLOCK_SIZE - bytesRead,
+                cancellationToken
+            );
+            if (read == 0)
+            {
+                // end of stream. If we read nothing, return empty array.
+                // if we read some, but not a full block, it's an error.
+                if (bytesRead == 0)
+                {
+                    return Array.Empty<byte>();
+                }
+                throw new InvalidFormatException("Buffer is invalid size");
+            }
+            bytesRead += read;
+        }
+
+        return buffer;
+    }
+
+    private static async Task ReadFullyAsync(
+        Stream stream,
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        var totalRead = 0;
+        while (totalRead < count)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var read = await stream
+                .ReadAsync(buffer, offset + totalRead, count - totalRead, cancellationToken)
+                .ConfigureAwait(false);
+            if (read == 0)
+            {
+                throw new EndOfStreamException("End of stream reached, but more bytes were expected.");
+            }
+            totalRead += read;
+        }
+    }
+
     private static void WriteStringBytes(ReadOnlySpan<byte> name, Span<byte> buffer, int length)
     {
         name.CopyTo(buffer);
@@ -358,18 +416,6 @@ internal sealed class TarHeader
         buffer.Slice(i, length - i).Clear();
     }
 
-    private static void WriteStringBytes(
-        ReadOnlySpan<byte> name,
-        Span<byte> buffer,
-        int offset,
-        int length
-    )
-    {
-        name.CopyTo(buffer.Slice(offset));
-        var i = Math.Min(length, name.Length);
-        buffer.Slice(offset + i, length - i).Clear();
-    }
-
     private static void WriteStringBytes(string name, byte[] buffer, int offset, int length)
     {
         int i;

src/SharpCompress/Common/Tar/Headers/TarHeaderWriteFormat.cs

@@ -1,7 +0,0 @@
-namespace SharpCompress.Common.Tar.Headers;
-
-public enum TarHeaderWriteFormat
-{
-    GNU_TAR_LONG_LINK,
-    USTAR,
-}

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

@@ -1,5 +1,8 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
 
@@ -54,6 +57,54 @@ internal static class TarHeaderFactory
         }
     }
 
+    internal static async IAsyncEnumerable<TarHeader?> ReadHeaderAsync(
+        StreamingMode mode,
+        Stream stream,
+        ArchiveEncoding archiveEncoding,
+        [EnumeratorCancellation] CancellationToken cancellationToken
+    )
+    {
+        while (true)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            TarHeader? header = null;
+            try
+            {
+                header = new TarHeader(archiveEncoding);
+
+                if (!await header.ReadAsync(stream, cancellationToken).ConfigureAwait(false))
+                {
+                    yield break;
+                }
+                switch (mode)
+                {
+                    case StreamingMode.Seekable:
+                        {
+                            header.DataStartPosition = stream.Position;
+
+                            //skip to nearest 512
+                            stream.Position += PadTo512(header.Size);
+                        }
+                        break;
+                    case StreamingMode.Streaming:
+                        {
+                            header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
+                        }
+                        break;
+                    default:
+                    {
+                        throw new InvalidFormatException("Invalid StreamingMode");
+                    }
+                }
+            }
+            catch
+            {
+                header = null;
+            }
+            yield return header;
+        }
+    }
+
     private static long PadTo512(long size)
     {
         var zeros = (int)(size % 512);

src/SharpCompress/Common/Zip/Headers/DirectoryEndHeader.cs

@@ -1,4 +1,7 @@
+using System.Buffers.Binary;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -19,6 +22,22 @@ internal class DirectoryEndHeader : ZipHeader
         Comment = reader.ReadBytes(CommentLength);
     }
 
+    internal async Task ReadAsync(Stream stream, CancellationToken cancellationToken)
+    {
+        VolumeNumber = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        FirstVolumeWithDirectory = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        TotalNumberOfEntriesInDisk = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        TotalNumberOfEntries = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        DirectorySize = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        DirectoryStartOffsetRelativeToDisk = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        CommentLength = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        Comment = await ZipHeaderFactory.ReadBytesAsync(stream, CommentLength, cancellationToken).ConfigureAwait(false);
+    }
+
     public ushort VolumeNumber { get; private set; }
 
     public ushort FirstVolumeWithDirectory { get; private set; }

src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs

@@ -1,5 +1,8 @@
+using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -90,7 +93,114 @@ internal class DirectoryEntryHeader : ZipFileEntry
 
         if (unixTimeExtra is not null)
         {
-            // Tuple order is last modified time, last access time, and creation time.
+            var unixTimeTuple = ((UnixTimeExtraField)unixTimeExtra).UnicodeTimes;
+
+            if (unixTimeTuple.Item1.HasValue)
+            {
+                var dosTime = Utility.DateTimeToDosTime(unixTimeTuple.Item1.Value);
+
+                LastModifiedDate = (ushort)(dosTime >> 16);
+                LastModifiedTime = (ushort)(dosTime & 0x0FFFF);
+            }
+            else if (unixTimeTuple.Item2.HasValue)
+            {
+                var dosTime = Utility.DateTimeToDosTime(unixTimeTuple.Item2.Value);
+
+                LastModifiedDate = (ushort)(dosTime >> 16);
+                LastModifiedTime = (ushort)(dosTime & 0x0FFFF);
+            }
+            else if (unixTimeTuple.Item3.HasValue)
+            {
+                var dosTime = Utility.DateTimeToDosTime(unixTimeTuple.Item3.Value);
+
+                LastModifiedDate = (ushort)(dosTime >> 16);
+                LastModifiedTime = (ushort)(dosTime & 0x0FFFF);
+            }
+        }
+    }
+
+    internal async Task ReadAsync(Stream stream, CancellationToken cancellationToken)
+    {
+        Version = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        VersionNeededToExtract = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        Flags = (HeaderFlags)await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        CompressionMethod = (ZipCompressionMethod)
+            await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        OriginalLastModifiedTime =
+            LastModifiedTime = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        OriginalLastModifiedDate =
+            LastModifiedDate = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        Crc = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        CompressedSize = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        UncompressedSize = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        var nameLength = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        var extraLength = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        var commentLength = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        DiskNumberStart = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        InternalFileAttributes = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        ExternalFileAttributes = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        RelativeOffsetOfEntryHeader = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+
+        var name = await ZipHeaderFactory.ReadBytesAsync(stream, nameLength, cancellationToken).ConfigureAwait(false);
+        var extra = await ZipHeaderFactory.ReadBytesAsync(stream, extraLength, cancellationToken).ConfigureAwait(false);
+        var comment = await ZipHeaderFactory.ReadBytesAsync(stream, commentLength, cancellationToken)
+            .ConfigureAwait(false);
+
+        if (Flags.HasFlag(HeaderFlags.Efs))
+        {
+            Name = ArchiveEncoding.DecodeUTF8(name);
+            Comment = ArchiveEncoding.DecodeUTF8(comment);
+        }
+        else
+        {
+            Name = ArchiveEncoding.Decode(name);
+            Comment = ArchiveEncoding.Decode(comment);
+        }
+
+        LoadExtra(extra);
+
+        var unicodePathExtra = Extra.FirstOrDefault(u =>
+            u.Type == ExtraDataType.UnicodePathExtraField
+        );
+        if (unicodePathExtra != null && ArchiveEncoding.Forced == null)
+        {
+            Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
+        }
+
+        var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
+        if (zip64ExtraData != null)
+        {
+            zip64ExtraData.Process(
+                UncompressedSize,
+                CompressedSize,
+                RelativeOffsetOfEntryHeader,
+                DiskNumberStart
+            );
+
+            if (CompressedSize == uint.MaxValue)
+            {
+                CompressedSize = zip64ExtraData.CompressedSize;
+            }
+
+            if (UncompressedSize == uint.MaxValue)
+            {
+                UncompressedSize = zip64ExtraData.UncompressedSize;
+            }
+
+            if (RelativeOffsetOfEntryHeader == uint.MaxValue)
+            {
+                RelativeOffsetOfEntryHeader = zip64ExtraData.RelativeOffsetOfEntryHeader;
+            }
+        }
+
+        var unixTimeExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnixTimeExtraField);
+
+        if (unixTimeExtra is not null)
+        {
             var unixTimeTuple = ((UnixTimeExtraField)unixTimeExtra).UnicodeTimes;
 
             if (unixTimeTuple.Item1.HasValue)

src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs

@@ -1,5 +1,8 @@
+using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -96,5 +99,87 @@ internal class LocalEntryHeader : ZipFileEntry
         }
     }
 
+    internal async Task ReadAsync(Stream stream, CancellationToken cancellationToken)
+    {
+        Version = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        Flags = (HeaderFlags)await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        CompressionMethod = (ZipCompressionMethod)
+            await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        OriginalLastModifiedTime =
+            LastModifiedTime = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        OriginalLastModifiedDate =
+            LastModifiedDate = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        Crc = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        CompressedSize = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        UncompressedSize = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        var nameLength = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        var extraLength = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        var name = await ZipHeaderFactory.ReadBytesAsync(stream, nameLength, cancellationToken).ConfigureAwait(false);
+        var extra = await ZipHeaderFactory.ReadBytesAsync(stream, extraLength, cancellationToken).ConfigureAwait(false);
+
+        if (Flags.HasFlag(HeaderFlags.Efs))
+        {
+            Name = ArchiveEncoding.DecodeUTF8(name);
+        }
+        else
+        {
+            Name = ArchiveEncoding.Decode(name);
+        }
+
+        LoadExtra(extra);
+
+        var unicodePathExtra = Extra.FirstOrDefault(u =>
+            u.Type == ExtraDataType.UnicodePathExtraField
+        );
+        if (unicodePathExtra != null && ArchiveEncoding.Forced == null)
+        {
+            Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
+        }
+
+        var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
+        if (zip64ExtraData != null)
+        {
+            zip64ExtraData.Process(UncompressedSize, CompressedSize, 0, 0);
+
+            if (CompressedSize == uint.MaxValue)
+            {
+                CompressedSize = zip64ExtraData.CompressedSize;
+            }
+            if (UncompressedSize == uint.MaxValue)
+            {
+                UncompressedSize = zip64ExtraData.UncompressedSize;
+            }
+        }
+
+        var unixTimeExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnixTimeExtraField);
+
+        if (unixTimeExtra is not null)
+        {
+            var unixTimeTuple = ((UnixTimeExtraField)unixTimeExtra).UnicodeTimes;
+
+            if (unixTimeTuple.Item1.HasValue)
+            {
+                var dosTime = Utility.DateTimeToDosTime(unixTimeTuple.Item1.Value);
+
+                LastModifiedDate = (ushort)(dosTime >> 16);
+                LastModifiedTime = (ushort)(dosTime & 0x0FFFF);
+            }
+            else if (unixTimeTuple.Item2.HasValue)
+            {
+                var dosTime = Utility.DateTimeToDosTime(unixTimeTuple.Item2.Value);
+
+                LastModifiedDate = (ushort)(dosTime >> 16);
+                LastModifiedTime = (ushort)(dosTime & 0x0FFFF);
+            }
+            else if (unixTimeTuple.Item3.HasValue)
+            {
+                var dosTime = Utility.DateTimeToDosTime(unixTimeTuple.Item3.Value);
+
+                LastModifiedDate = (ushort)(dosTime >> 16);
+                LastModifiedTime = (ushort)(dosTime & 0x0FFFF);
+            }
+        }
+    }
+
     internal ushort Version { get; private set; }
 }

src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs

@@ -1,4 +1,7 @@
+using System.Buffers.Binary;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -26,6 +29,35 @@ internal class Zip64DirectoryEndHeader : ZipHeader
         );
     }
 
+    internal async Task ReadAsync(Stream stream, CancellationToken cancellationToken)
+    {
+        SizeOfDirectoryEndRecord = (long)
+            await ZipHeaderFactory.ReadUInt64Async(stream, cancellationToken).ConfigureAwait(false);
+        VersionMadeBy = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken).ConfigureAwait(false);
+        VersionNeededToExtract = await ZipHeaderFactory.ReadUInt16Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        VolumeNumber = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+        FirstVolumeWithDirectory = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        TotalNumberOfEntriesInDisk = (long)
+            await ZipHeaderFactory.ReadUInt64Async(stream, cancellationToken).ConfigureAwait(false);
+        TotalNumberOfEntries = (long)
+            await ZipHeaderFactory.ReadUInt64Async(stream, cancellationToken).ConfigureAwait(false);
+        DirectorySize = (long)
+            await ZipHeaderFactory.ReadUInt64Async(stream, cancellationToken).ConfigureAwait(false);
+        DirectoryStartOffsetRelativeToDisk = (long)
+            await ZipHeaderFactory.ReadUInt64Async(stream, cancellationToken).ConfigureAwait(false);
+        DataSector = await ZipHeaderFactory.ReadBytesAsync(
+                stream,
+                (int)(
+                    SizeOfDirectoryEndRecord
+                    - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
+                ),
+                cancellationToken
+            )
+            .ConfigureAwait(false);
+    }
+
     private const int SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS = 44;
 
     public long SizeOfDirectoryEndRecord { get; private set; }

src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndLocatorHeader.cs

@@ -1,4 +1,7 @@
+using System.Buffers.Binary;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -14,6 +17,16 @@ internal class Zip64DirectoryEndLocatorHeader : ZipHeader
         TotalNumberOfVolumes = reader.ReadUInt32();
     }
 
+    internal async Task ReadAsync(Stream stream, CancellationToken cancellationToken)
+    {
+        FirstVolumeWithDirectory = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+        RelativeOffsetOfTheEndOfDirectoryRecord = (long)
+            await ZipHeaderFactory.ReadUInt64Async(stream, cancellationToken).ConfigureAwait(false);
+        TotalNumberOfVolumes = await ZipHeaderFactory.ReadUInt32Async(stream, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     public uint FirstVolumeWithDirectory { get; private set; }
 
     public long RelativeOffsetOfTheEndOfDirectoryRecord { get; private set; }

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -1,6 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -85,6 +88,90 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
         }
     }
 
+    internal async IAsyncEnumerable<ZipHeader> ReadSeekableHeaderAsync(
+        Stream stream,
+        [EnumeratorCancellation] CancellationToken cancellationToken
+    )
+    {
+        // Still need BinaryReader for synchronous SeekBackToHeader, until SeekBackToHeaderAsync is implemented
+        var reader = new BinaryReader(stream);
+
+        SeekBackToHeader(stream, reader); // Synchronous due to stream.Seek and BinaryReader
+
+        var eocd_location = stream.Position;
+        var entry = new DirectoryEndHeader();
+        await entry.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+
+        if (entry.IsZip64)
+        {
+            _zip64 = true;
+
+            stream.Seek(eocd_location - ZIP64_EOCD_LENGTH - 4, SeekOrigin.Begin); // Synchronous seek
+            var zip64_locator = await ReadUInt32Async(stream, cancellationToken)
+                .ConfigureAwait(false);
+            if (zip64_locator != ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR)
+            {
+                throw new ArchiveException("Failed to locate the Zip64 Directory Locator");
+            }
+
+            var zip64Locator = new Zip64DirectoryEndLocatorHeader();
+            await zip64Locator.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+
+            stream.Seek(
+                zip64Locator.RelativeOffsetOfTheEndOfDirectoryRecord,
+                SeekOrigin.Begin
+            ); // Synchronous seek
+            var zip64Signature = await ReadUInt32Async(stream, cancellationToken)
+                .ConfigureAwait(false);
+            if (zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
+            {
+                throw new ArchiveException("Failed to locate the Zip64 Header");
+            }
+
+            var zip64Entry = new Zip64DirectoryEndHeader();
+            await zip64Entry.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+            stream.Seek(
+                zip64Entry.DirectoryStartOffsetRelativeToDisk,
+                SeekOrigin.Begin
+            ); // Synchronous seek
+        }
+        else
+        {
+            stream.Seek(entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin); // Synchronous seek
+        }
+
+        var position = stream.Position;
+        while (true)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            stream.Position = position; // Synchronous seek
+            var signature = await ReadUInt32Async(stream, cancellationToken)
+                .ConfigureAwait(false);
+            var nextHeader = await ReadHeaderAsync(
+                signature,
+                stream,
+                _zip64,
+                cancellationToken
+            ).ConfigureAwait(false);
+            position = stream.Position;
+
+            if (nextHeader is null)
+            {
+                yield break;
+            }
+
+            if (nextHeader is DirectoryEntryHeader entryHeader)
+            {
+                entryHeader.HasData = entryHeader.CompressedSize != 0;
+                yield return entryHeader;
+            }
+            else if (nextHeader is DirectoryEndHeader endHeader)
+            {
+                yield return endHeader;
+            }
+        }
+    }
+
     private static bool IsMatch(byte[] haystack, int position, byte[] needle)
     {
         for (var i = 0; i < needle.Length; i++)

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -1,7 +1,10 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -200,4 +203,230 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
             yield return header;
         }
     }
+
+    internal async IAsyncEnumerable<ZipHeader> ReadStreamHeaderAsync(
+        Stream stream,
+        [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken
+    )
+    {
+        if (stream is not SharpCompressStream)
+        {
+            if (stream is SourceStream src)
+            {
+                stream = new SharpCompressStream(
+                    stream,
+                    src.ReaderOptions.LeaveStreamOpen,
+                    bufferSize: src.ReaderOptions.BufferSize
+                );
+            }
+            else
+            {
+                throw new ArgumentException("Stream must be a SharpCompressStream", nameof(stream));
+            }
+        }
+        var rewindableStream = (SharpCompressStream)stream;
+
+        while (true)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            uint headerBytes = 0;
+            if (
+                _lastEntryHeader != null
+                && FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)
+            )
+            {
+                if (_lastEntryHeader.Part is null)
+                {
+                    continue;
+                }
+
+                var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
+
+                var crc = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+                if (crc == POST_DATA_DESCRIPTOR)
+                {
+                    crc = await ReadUInt32Async(rewindableStream, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                _lastEntryHeader.Crc = crc;
+
+                ulong compSize = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+                ulong uncompSize = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+                headerBytes = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+
+                bool isSentinel = compSize == 0xFFFFFFFF || uncompSize == 0xFFFFFFFF;
+                bool isHeader = headerBytes == 0x04034b50 || headerBytes == 0x02014b50;
+
+                if (!isHeader && !isSentinel)
+                {
+                    compSize = (uncompSize << 32) | compSize;
+                    uncompSize =
+                        ((ulong)headerBytes << 32)
+                        | await ReadUInt32Async(rewindableStream, cancellationToken)
+                            .ConfigureAwait(false);
+                    headerBytes = await ReadUInt32Async(rewindableStream, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                else if (isSentinel)
+                {
+                    compSize = await ReadUInt64Async(rewindableStream, cancellationToken)
+                        .ConfigureAwait(false);
+                    uncompSize = await ReadUInt64Async(rewindableStream, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+
+                _lastEntryHeader.CompressedSize = (long)compSize;
+                _lastEntryHeader.UncompressedSize = (long)uncompSize;
+
+                if (pos.HasValue)
+                {
+                    _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
+                }
+            }
+            else if (_lastEntryHeader != null && _lastEntryHeader.IsZip64)
+            {
+                if (_lastEntryHeader.Part is null)
+                    continue;
+
+                var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
+
+                headerBytes = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+
+                await ReadBytesAsync(rewindableStream, 12, cancellationToken).ConfigureAwait(false); //skip a bunch of fields we don't care about
+
+                var crc = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+
+                if (crc == POST_DATA_DESCRIPTOR)
+                {
+                    crc = await ReadUInt32Async(rewindableStream, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                _lastEntryHeader.Crc = crc;
+
+                var compressed_size = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+                var uncompressed_size = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+
+                var test_header = !(headerBytes == 0x04034b50 || headerBytes == 0x02014b50);
+
+                var test_64bit = ((long)uncompressed_size << 32) | compressed_size;
+                if (test_64bit == _lastEntryHeader.CompressedSize && test_header)
+                {
+                    _lastEntryHeader.UncompressedSize =
+                        ((long)await ReadUInt32Async(rewindableStream, cancellationToken)
+                            .ConfigureAwait(false) << 32) | headerBytes;
+                    headerBytes = await ReadUInt32Async(rewindableStream, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                else
+                {
+                    _lastEntryHeader.UncompressedSize = uncompressed_size;
+                }
+
+                if (pos.HasValue)
+                {
+                    _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
+
+                    rewindableStream.Position = pos.Value + 4;
+                }
+            }
+            else
+            {
+                headerBytes = await ReadUInt32Async(rewindableStream, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+
+            _lastEntryHeader = null;
+            var header = await ReadHeaderAsync(
+                headerBytes,
+                rewindableStream,
+                cancellationToken: cancellationToken
+            );
+            if (header is null)
+            {
+                yield break;
+            }
+
+            if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
+            {
+                var local_header = ((LocalEntryHeader)header);
+                var dir_header = _entries?.FirstOrDefault(entry =>
+                    entry.Key == local_header.Name
+                    && local_header.CompressedSize == 0
+                    && local_header.UncompressedSize == 0
+                    && local_header.Crc == 0
+                    && local_header.IsDirectory == false
+                );
+
+                if (dir_header != null)
+                {
+                    local_header.UncompressedSize = dir_header.Size;
+                    local_header.CompressedSize = dir_header.CompressedSize;
+                    local_header.Crc = (uint)dir_header.Crc;
+                }
+
+                if (local_header.CompressedSize > 0)
+                {
+                    header.HasData = true;
+                }
+                else if (local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor))
+                {
+                    var nextHeaderBytes = await ReadUInt32Async(
+                        rewindableStream,
+                        cancellationToken
+                    );
+                    ((IStreamStack)rewindableStream).Rewind(sizeof(uint));
+
+                    header.HasData = !IsHeader(nextHeaderBytes);
+                }
+                else
+                {
+                    header.HasData = false;
+                }
+            }
+            yield return header;
+        }
+    }
+
+    private static async Task<byte[]> ReadBytesAsync(
+        Stream stream,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = new byte[count];
+        var read = await stream.ReadAsync(buffer, 0, count, cancellationToken);
+        if (read < count)
+        {
+            throw new EndOfStreamException();
+        }
+        return buffer;
+    }
+
+    private static async Task<uint> ReadUInt32Async(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = await ReadBytesAsync(stream, 4, cancellationToken);
+        return BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+    }
+
+    private static async Task<ushort> ReadUInt16Async(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = await ReadBytesAsync(stream, 2, cancellationToken);
+        return BinaryPrimitives.ReadUInt16LittleEndian(buffer);
+    }
+
 }

src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs

@@ -20,7 +20,7 @@ internal class WinzipAesEncryptionData
     {
         _keySize = keySize;
 
-#if NETFRAMEWORK || NETSTANDARD2_0
+#if NETFRAMEWORK
         var rfc2898 = new Rfc2898DeriveBytes(password, salt, RFC2898_ITERATIONS);
         KeyBytes = rfc2898.GetBytes(KeySizeInBytes);
         IvBytes = rfc2898.GetBytes(KeySizeInBytes);

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -13,8 +13,8 @@ using SharpCompress.Compressors.PPMd;
 using SharpCompress.Compressors.Reduce;
 using SharpCompress.Compressors.Shrink;
 using SharpCompress.Compressors.Xz;
-using SharpCompress.Compressors.ZStandard;
 using SharpCompress.IO;
+using ZstdSharp;
 
 namespace SharpCompress.Common.Zip;
 

src/SharpCompress/Common/Zip/ZipHeaderFactory.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -106,6 +109,129 @@ internal class ZipHeaderFactory
         }
     }
 
+    protected async Task<ZipHeader?> ReadHeaderAsync(
+        uint headerBytes,
+        Stream stream,
+        bool zip64 = false,
+        CancellationToken cancellationToken = default
+    )
+    {
+        switch (headerBytes)
+        {
+            case ENTRY_HEADER_BYTES:
+            {
+                var entryHeader = new LocalEntryHeader(_archiveEncoding);
+                await entryHeader.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+                await LoadHeaderAsync(entryHeader, stream, cancellationToken).ConfigureAwait(false);
+
+                _lastEntryHeader = entryHeader;
+                return entryHeader;
+            }
+            case DIRECTORY_START_HEADER_BYTES:
+            {
+                var entry = new DirectoryEntryHeader(_archiveEncoding);
+                await entry.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+                return entry;
+            }
+            case POST_DATA_DESCRIPTOR:
+            {
+                if (
+                    _lastEntryHeader != null
+                    && FlagUtility.HasFlag(
+                        _lastEntryHeader.NotNull().Flags,
+                        HeaderFlags.UsePostDataDescriptor
+                    )
+                )
+                {
+                    _lastEntryHeader.Crc = await ReadUInt32Async(stream, cancellationToken)
+                        .ConfigureAwait(false);
+                    _lastEntryHeader.CompressedSize = zip64
+                        ? (long)await ReadUInt64Async(stream, cancellationToken)
+                            .ConfigureAwait(false)
+                        : await ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+                    _lastEntryHeader.UncompressedSize = zip64
+                        ? (long)await ReadUInt64Async(stream, cancellationToken)
+                            .ConfigureAwait(false)
+                        : await ReadUInt32Async(stream, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    await ReadBytesAsync(stream, zip64 ? 20 : 12, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                return null;
+            }
+            case DIGITAL_SIGNATURE:
+                return null;
+            case DIRECTORY_END_HEADER_BYTES:
+            {
+                var entry = new DirectoryEndHeader();
+                await entry.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+                return entry;
+            }
+            case SPLIT_ARCHIVE_HEADER_BYTES:
+            {
+                return new SplitHeader();
+            }
+            case ZIP64_END_OF_CENTRAL_DIRECTORY:
+            {
+                var entry = new Zip64DirectoryEndHeader();
+                await entry.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+                return entry;
+            }
+            case ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR:
+            {
+                var entry = new Zip64DirectoryEndLocatorHeader();
+                await entry.ReadAsync(stream, cancellationToken).ConfigureAwait(false);
+                return entry;
+            }
+            default:
+                return null;
+        }
+    }
+
+    internal static async Task<byte[]> ReadBytesAsync(
+        Stream stream,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = new byte[count];
+        var read = await stream.ReadAsync(buffer, 0, count, cancellationToken);
+        if (read < count)
+        {
+            throw new EndOfStreamException();
+        }
+        return buffer;
+    }
+
+    internal static async Task<uint> ReadUInt32Async(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = await ReadBytesAsync(stream, 4, cancellationToken);
+        return BinaryPrimitives.ReadUInt32LittleEndian(buffer);
+    }
+
+    internal static async Task<ushort> ReadUInt16Async(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = await ReadBytesAsync(stream, 2, cancellationToken);
+        return BinaryPrimitives.ReadUInt16LittleEndian(buffer);
+    }
+
+    internal static async Task<ulong> ReadUInt64Async(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = await ReadBytesAsync(stream, 8, cancellationToken);
+        return BinaryPrimitives.ReadUInt64LittleEndian(buffer);
+    }
+
     internal static bool IsHeader(uint headerBytes)
     {
         switch (headerBytes)
@@ -176,12 +302,6 @@ internal class ZipHeaderFactory
             return;
         }
 
-        //if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
-        //{
-        //    entryHeader.PackedStream = new ReadOnlySubStream(stream);
-        //}
-        //else
-        //{
         switch (_mode)
         {
             case StreamingMode.Seekable:
@@ -202,7 +322,87 @@ internal class ZipHeaderFactory
                 throw new InvalidFormatException("Invalid StreamingMode");
             }
         }
+    }
 
-        //}
+    private async Task LoadHeaderAsync(
+        ZipFileEntry entryHeader,
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.Encrypted))
+        {
+            if (
+                !entryHeader.IsDirectory
+                && entryHeader.CompressedSize == 0
+                && FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.UsePostDataDescriptor)
+            )
+            {
+                throw new NotSupportedException(
+                    "SharpCompress cannot currently read non-seekable Zip Streams with encrypted data that has been written in a non-seekable manner."
+                );
+            }
+
+            if (_password is null)
+            {
+                throw new CryptographicException("No password supplied for encrypted zip.");
+            }
+
+            entryHeader.Password = _password;
+
+            if (entryHeader.CompressionMethod == ZipCompressionMethod.WinzipAes)
+            {
+                var data = entryHeader.Extra.SingleOrDefault(x =>
+                    x.Type == ExtraDataType.WinZipAes
+                );
+                if (data != null)
+                {
+                    var keySize = (WinzipAesKeySize)data.DataBytes[4];
+
+                    var salt = new byte[WinzipAesEncryptionData.KeyLengthInBytes(keySize) / 2];
+                    var passwordVerifyValue = new byte[2];
+                    await stream
+                        .ReadAsync(salt, 0, salt.Length, cancellationToken)
+                        .ConfigureAwait(false);
+                    await stream
+                        .ReadAsync(passwordVerifyValue, 0, 2, cancellationToken)
+                        .ConfigureAwait(false);
+                    entryHeader.WinzipAesEncryptionData = new WinzipAesEncryptionData(
+                        keySize,
+                        salt,
+                        passwordVerifyValue,
+                        _password
+                    );
+
+                    entryHeader.CompressedSize -= (uint)(salt.Length + 2);
+                }
+            }
+        }
+
+        if (entryHeader.IsDirectory)
+        {
+            return;
+        }
+
+        switch (_mode)
+        {
+            case StreamingMode.Seekable:
+            {
+                entryHeader.DataStartPosition = stream.Position;
+                stream.Position += entryHeader.CompressedSize;
+                break;
+            }
+
+            case StreamingMode.Streaming:
+            {
+                entryHeader.PackedStream = stream;
+                break;
+            }
+
+            default:
+            {
+                throw new InvalidFormatException("Invalid StreamingMode");
+            }
+        }
     }
 }

src/SharpCompress/Compressors/BZip2/BZip2Stream.cs

@@ -30,7 +30,6 @@ public sealed class BZip2Stream : Stream, IStreamStack
 
     private readonly Stream stream;
     private bool isDisposed;
-    private readonly bool leaveOpen;
 
     /// <summary>
     /// Create a BZip2Stream
@@ -38,30 +37,19 @@ public sealed class BZip2Stream : Stream, IStreamStack
     /// <param name="stream">The stream to read from</param>
     /// <param name="compressionMode">Compression Mode</param>
     /// <param name="decompressConcatenated">Decompress Concatenated</param>
-    /// <param name="leaveOpen">Leave the stream open after disposing</param>
-    public BZip2Stream(
-        Stream stream,
-        CompressionMode compressionMode,
-        bool decompressConcatenated,
-        bool leaveOpen = false
-    )
+    public BZip2Stream(Stream stream, CompressionMode compressionMode, bool decompressConcatenated)
     {
 #if DEBUG_STREAMS
         this.DebugConstruct(typeof(BZip2Stream));
 #endif
-        this.leaveOpen = leaveOpen;
         Mode = compressionMode;
         if (Mode == CompressionMode.Compress)
         {
-            this.stream = new CBZip2OutputStream(stream, 9, leaveOpen);
+            this.stream = new CBZip2OutputStream(stream);
         }
         else
         {
-            this.stream = new CBZip2InputStream(
-                stream,
-                decompressConcatenated,
-                leaveOpen: leaveOpen
-            );
+            this.stream = new CBZip2InputStream(stream, decompressConcatenated);
         }
     }
 

src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs

@@ -168,7 +168,6 @@ internal class CBZip2InputStream : Stream, IStreamStack
     private int computedBlockCRC,
         computedCombinedCRC;
     private readonly bool decompressConcatenated;
-    private readonly bool leaveOpen;
 
     private int i2,
         count,
@@ -182,10 +181,9 @@ internal class CBZip2InputStream : Stream, IStreamStack
     private char z;
     private bool isDisposed;
 
-    public CBZip2InputStream(Stream zStream, bool decompressConcatenated, bool leaveOpen = false)
+    public CBZip2InputStream(Stream zStream, bool decompressConcatenated)
     {
         this.decompressConcatenated = decompressConcatenated;
-        this.leaveOpen = leaveOpen;
         ll8 = null;
         tt = null;
         BsSetStream(zStream);
@@ -209,10 +207,7 @@ internal class CBZip2InputStream : Stream, IStreamStack
         this.DebugDispose(typeof(CBZip2InputStream));
 #endif
         base.Dispose(disposing);
-        if (!leaveOpen)
-        {
-            bsStream?.Dispose();
-        }
+        bsStream?.Dispose();
     }
 
     internal static int[][] InitIntArray(int n1, int n2)
@@ -403,10 +398,7 @@ internal class CBZip2InputStream : Stream, IStreamStack
 
     private void BsFinishedWithStream()
     {
-        if (!leaveOpen)
-        {
-            bsStream?.Dispose();
-        }
+        bsStream?.Dispose();
         bsStream = null;
     }
 

src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs

@@ -341,14 +341,12 @@ internal sealed class CBZip2OutputStream : Stream, IStreamStack
 
     private int currentChar = -1;
     private int runLength;
-    private readonly bool leaveOpen;
 
-    public CBZip2OutputStream(Stream inStream, bool leaveOpen = false)
-        : this(inStream, 9, leaveOpen) { }
+    public CBZip2OutputStream(Stream inStream)
+        : this(inStream, 9) { }
 
-    public CBZip2OutputStream(Stream inStream, int inBlockSize, bool leaveOpen = false)
+    public CBZip2OutputStream(Stream inStream, int inBlockSize)
     {
-        this.leaveOpen = leaveOpen;
         block = null;
         quadrant = null;
         zptr = null;
@@ -483,10 +481,7 @@ internal sealed class CBZip2OutputStream : Stream, IStreamStack
             this.DebugDispose(typeof(CBZip2OutputStream));
 #endif
             Dispose();
-            if (!leaveOpen)
-            {
-                bsStream?.Dispose();
-            }
+            bsStream?.Dispose();
             bsStream = null;
         }
     }

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -586,13 +586,7 @@ internal class ZlibBaseStream : Stream, IStreamStack
 
     public override void Flush()
     {
-        // Only flush the underlying stream when in write mode
-        // Flushing input streams during read operations is not meaningful
-        // and can cause issues with forward-only/non-seekable streams
-        if (_streamMode == StreamMode.Writer)
-        {
-            _stream.Flush();
-        }
+        _stream.Flush();
         //rewind the buffer
         ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
         z.AvailableBytesIn = 0;
@@ -600,13 +594,7 @@ internal class ZlibBaseStream : Stream, IStreamStack
 
     public override async Task FlushAsync(CancellationToken cancellationToken)
     {
-        // Only flush the underlying stream when in write mode
-        // Flushing input streams during read operations is not meaningful
-        // and can cause issues with forward-only/non-seekable streams
-        if (_streamMode == StreamMode.Writer)
-        {
-            await _stream.FlushAsync(cancellationToken).ConfigureAwait(false);
-        }
+        await _stream.FlushAsync(cancellationToken).ConfigureAwait(false);
         //rewind the buffer
         ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
         z.AvailableBytesIn = 0;

src/SharpCompress/Compressors/LZMA/LZ/LzOutWindow.cs

@@ -153,7 +153,7 @@ internal class OutWindow : IDisposable
         _pendingLen = rem;
     }
 
-    public async ValueTask CopyPendingAsync(CancellationToken cancellationToken = default)
+    public async Task CopyPendingAsync(CancellationToken cancellationToken = default)
     {
         if (_pendingLen < 1)
         {
@@ -206,7 +206,7 @@ internal class OutWindow : IDisposable
         _pendingDist = distance;
     }
 
-    public async ValueTask CopyBlockAsync(
+    public async Task CopyBlockAsync(
         int distance,
         int len,
         CancellationToken cancellationToken = default
@@ -253,7 +253,7 @@ internal class OutWindow : IDisposable
         }
     }
 
-    public async ValueTask PutByteAsync(byte b, CancellationToken cancellationToken = default)
+    public async Task PutByteAsync(byte b, CancellationToken cancellationToken = default)
     {
         _buffer[_pos++] = b;
         _total++;
@@ -369,28 +369,6 @@ internal class OutWindow : IDisposable
         return size;
     }
 
-    public int Read(Memory<byte> buffer, int offset, int count)
-    {
-        if (_streamPos >= _pos)
-        {
-            return 0;
-        }
-
-        var size = _pos - _streamPos;
-        if (size > count)
-        {
-            size = count;
-        }
-        _buffer.AsMemory(_streamPos, size).CopyTo(buffer.Slice(offset, size));
-        _streamPos += size;
-        if (_streamPos >= _windowSize)
-        {
-            _pos = 0;
-            _streamPos = 0;
-        }
-        return size;
-    }
-
     public int ReadByte()
     {
         if (_streamPos >= _pos)

src/SharpCompress/Compressors/LZMA/LZipStream.cs

@@ -45,14 +45,10 @@ public sealed class LZipStream : Stream, IStreamStack
     private bool _finished;
 
     private long _writeCount;
-    private readonly Stream? _originalStream;
-    private readonly bool _leaveOpen;
 
-    public LZipStream(Stream stream, CompressionMode mode, bool leaveOpen = false)
+    public LZipStream(Stream stream, CompressionMode mode)
     {
         Mode = mode;
-        _originalStream = stream;
-        _leaveOpen = leaveOpen;
 
         if (mode == CompressionMode.Decompress)
         {
@@ -62,7 +58,7 @@ public sealed class LZipStream : Stream, IStreamStack
                 throw new InvalidFormatException("Not an LZip stream");
             }
             var properties = GetProperties(dSize);
-            _stream = new LzmaStream(properties, stream, leaveOpen: leaveOpen);
+            _stream = new LzmaStream(properties, stream);
         }
         else
         {
@@ -129,10 +125,6 @@ public sealed class LZipStream : Stream, IStreamStack
         {
             Finish();
             _stream.Dispose();
-            if (Mode == CompressionMode.Compress && !_leaveOpen)
-            {
-                _originalStream?.Dispose();
-            }
         }
     }
 

src/SharpCompress/Compressors/LZMA/LzmaDecoder.cs

@@ -3,7 +3,6 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.LZ;
 using SharpCompress.Compressors.LZMA.RangeCoder;
 
@@ -476,7 +475,7 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
         return false;
     }
 
-    internal async ValueTask<bool> CodeAsync(
+    internal async System.Threading.Tasks.Task<bool> CodeAsync(
         int dictionarySize,
         OutWindow outWindow,
         RangeCoder.Decoder rangeDecoder,

src/SharpCompress/Compressors/LZMA/LzmaStream.cs

@@ -35,7 +35,6 @@ public class LzmaStream : Stream, IStreamStack
     private readonly Stream _inputStream;
     private readonly long _inputSize;
     private readonly long _outputSize;
-    private readonly bool _leaveOpen;
 
     private readonly int _dictionarySize;
     private readonly OutWindow _outWindow = new();
@@ -57,28 +56,14 @@ public class LzmaStream : Stream, IStreamStack
     private readonly Encoder _encoder;
     private bool _isDisposed;
 
-    public LzmaStream(byte[] properties, Stream inputStream, bool leaveOpen = false)
-        : this(properties, inputStream, -1, -1, null, properties.Length < 5, leaveOpen) { }
+    public LzmaStream(byte[] properties, Stream inputStream)
+        : this(properties, inputStream, -1, -1, null, properties.Length < 5) { }
 
-    public LzmaStream(byte[] properties, Stream inputStream, long inputSize, bool leaveOpen = false)
-        : this(properties, inputStream, inputSize, -1, null, properties.Length < 5, leaveOpen) { }
+    public LzmaStream(byte[] properties, Stream inputStream, long inputSize)
+        : this(properties, inputStream, inputSize, -1, null, properties.Length < 5) { }
 
-    public LzmaStream(
-        byte[] properties,
-        Stream inputStream,
-        long inputSize,
-        long outputSize,
-        bool leaveOpen = false
-    )
-        : this(
-            properties,
-            inputStream,
-            inputSize,
-            outputSize,
-            null,
-            properties.Length < 5,
-            leaveOpen
-        ) { }
+    public LzmaStream(byte[] properties, Stream inputStream, long inputSize, long outputSize)
+        : this(properties, inputStream, inputSize, outputSize, null, properties.Length < 5) { }
 
     public LzmaStream(
         byte[] properties,
@@ -86,15 +71,13 @@ public class LzmaStream : Stream, IStreamStack
         long inputSize,
         long outputSize,
         Stream presetDictionary,
-        bool isLzma2,
-        bool leaveOpen = false
+        bool isLzma2
     )
     {
         _inputStream = inputStream;
         _inputSize = inputSize;
         _outputSize = outputSize;
         _isLzma2 = isLzma2;
-        _leaveOpen = leaveOpen;
 
 #if DEBUG_STREAMS
         this.DebugConstruct(typeof(LzmaStream));
@@ -196,10 +179,7 @@ public class LzmaStream : Stream, IStreamStack
             {
                 _position = _encoder.Code(null, true);
             }
-            if (!_leaveOpen)
-            {
-                _inputStream?.Dispose();
-            }
+            _inputStream?.Dispose();
             _outWindow.Dispose();
         }
         base.Dispose(disposing);
@@ -445,12 +425,10 @@ public class LzmaStream : Stream, IStreamStack
         }
     }
 
-    private async ValueTask DecodeChunkHeaderAsync(CancellationToken cancellationToken = default)
+    private async Task DecodeChunkHeaderAsync(CancellationToken cancellationToken = default)
     {
         var controlBuffer = new byte[1];
-        await _inputStream
-            .ReadExactlyAsync(controlBuffer, 0, 1, cancellationToken)
-            .ConfigureAwait(false);
+        await _inputStream.ReadAsync(controlBuffer, 0, 1, cancellationToken).ConfigureAwait(false);
         var control = controlBuffer[0];
         _inputPosition++;
 
@@ -477,15 +455,11 @@ public class LzmaStream : Stream, IStreamStack
 
             _availableBytes = (control & 0x1F) << 16;
             var buffer = new byte[2];
-            await _inputStream
-                .ReadExactlyAsync(buffer, 0, 2, cancellationToken)
-                .ConfigureAwait(false);
+            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
             _availableBytes += (buffer[0] << 8) + buffer[1] + 1;
             _inputPosition += 2;
 
-            await _inputStream
-                .ReadExactlyAsync(buffer, 0, 2, cancellationToken)
-                .ConfigureAwait(false);
+            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
             _rangeDecoderLimit = (buffer[0] << 8) + buffer[1] + 1;
             _inputPosition += 2;
 
@@ -493,7 +467,7 @@ public class LzmaStream : Stream, IStreamStack
             {
                 _needProps = false;
                 await _inputStream
-                    .ReadExactlyAsync(controlBuffer, 0, 1, cancellationToken)
+                    .ReadAsync(controlBuffer, 0, 1, cancellationToken)
                     .ConfigureAwait(false);
                 Properties[0] = controlBuffer[0];
                 _inputPosition++;
@@ -521,9 +495,7 @@ public class LzmaStream : Stream, IStreamStack
         {
             _uncompressedChunk = true;
             var buffer = new byte[2];
-            await _inputStream
-                .ReadExactlyAsync(buffer, 0, 2, cancellationToken)
-                .ConfigureAwait(false);
+            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
             _availableBytes = (buffer[0] << 8) + buffer[1] + 1;
             _inputPosition += 2;
         }
@@ -652,119 +624,6 @@ public class LzmaStream : Stream, IStreamStack
         return total;
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_endReached)
-        {
-            return 0;
-        }
-
-        var total = 0;
-        var offset = 0;
-        var count = buffer.Length;
-        while (total < count)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            if (_availableBytes == 0)
-            {
-                if (_isLzma2)
-                {
-                    await DecodeChunkHeaderAsync(cancellationToken).ConfigureAwait(false);
-                }
-                else
-                {
-                    _endReached = true;
-                }
-                if (_endReached)
-                {
-                    break;
-                }
-            }
-
-            var toProcess = count - total;
-            if (toProcess > _availableBytes)
-            {
-                toProcess = (int)_availableBytes;
-            }
-
-            _outWindow.SetLimit(toProcess);
-            if (_uncompressedChunk)
-            {
-                _inputPosition += await _outWindow
-                    .CopyStreamAsync(_inputStream, toProcess, cancellationToken)
-                    .ConfigureAwait(false);
-            }
-            else if (
-                await _decoder
-                    .CodeAsync(_dictionarySize, _outWindow, _rangeDecoder, cancellationToken)
-                    .ConfigureAwait(false)
-                && _outputSize < 0
-            )
-            {
-                _availableBytes = _outWindow.AvailableBytes;
-            }
-
-            var read = _outWindow.Read(buffer, offset, toProcess);
-            total += read;
-            offset += read;
-            _position += read;
-            _availableBytes -= read;
-
-            if (_availableBytes == 0 && !_uncompressedChunk)
-            {
-                if (
-                    !_rangeDecoder.IsFinished
-                    || (_rangeDecoderLimit >= 0 && _rangeDecoder._total != _rangeDecoderLimit)
-                )
-                {
-                    _outWindow.SetLimit(toProcess + 1);
-                    if (
-                        !await _decoder
-                            .CodeAsync(
-                                _dictionarySize,
-                                _outWindow,
-                                _rangeDecoder,
-                                cancellationToken
-                            )
-                            .ConfigureAwait(false)
-                    )
-                    {
-                        _rangeDecoder.ReleaseStream();
-                        throw new DataErrorException();
-                    }
-                }
-
-                _rangeDecoder.ReleaseStream();
-
-                _inputPosition += _rangeDecoder._total;
-                if (_outWindow.HasPending)
-                {
-                    throw new DataErrorException();
-                }
-            }
-        }
-
-        if (_endReached)
-        {
-            if (_inputSize >= 0 && _inputPosition != _inputSize)
-            {
-                throw new DataErrorException();
-            }
-            if (_outputSize >= 0 && _position != _outputSize)
-            {
-                throw new DataErrorException();
-            }
-        }
-
-        return total;
-    }
-#endif
-
     public override Task WriteAsync(
         byte[] buffer,
         int offset,

src/SharpCompress/Compressors/LZMA/Registry.cs

@@ -7,7 +7,7 @@ using SharpCompress.Compressors.Deflate;
 using SharpCompress.Compressors.Filters;
 using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.Compressors.PPMd;
-using SharpCompress.Compressors.ZStandard;
+using ZstdSharp;
 
 namespace SharpCompress.Compressors.LZMA;
 

src/SharpCompress/Compressors/Rar/MultiVolumeReadOnlyStream.cs

@@ -37,8 +37,18 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
     private IEnumerator<RarFilePart> filePartEnumerator;
     private Stream currentStream;
 
-    internal MultiVolumeReadOnlyStream(IEnumerable<RarFilePart> parts)
+    private readonly IExtractionListener streamListener;
+
+    private long currentPartTotalReadBytes;
+    private long currentEntryTotalReadBytes;
+
+    internal MultiVolumeReadOnlyStream(
+        IEnumerable<RarFilePart> parts,
+        IExtractionListener streamListener
+    )
     {
+        this.streamListener = streamListener;
+
         filePartEnumerator = parts.GetEnumerator();
         filePartEnumerator.MoveNext();
         InitializeNextFilePart();
@@ -71,7 +81,15 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
         currentPosition = 0;
         currentStream = filePartEnumerator.Current.GetCompressedStream();
 
+        currentPartTotalReadBytes = 0;
+
         CurrentCrc = filePartEnumerator.Current.FileHeader.FileCrc;
+
+        streamListener.FireFilePartExtractionBegin(
+            filePartEnumerator.Current.FilePartName,
+            filePartEnumerator.Current.FileHeader.CompressedSize,
+            filePartEnumerator.Current.FileHeader.UncompressedSize
+        );
     }
 
     public override int Read(byte[] buffer, int offset, int count)
@@ -123,6 +141,12 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
                 break;
             }
         }
+        currentPartTotalReadBytes += totalRead;
+        currentEntryTotalReadBytes += totalRead;
+        streamListener.FireCompressedBytesRead(
+            currentPartTotalReadBytes,
+            currentEntryTotalReadBytes
+        );
         return totalRead;
     }
 
@@ -182,6 +206,12 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
                 break;
             }
         }
+        currentPartTotalReadBytes += totalRead;
+        currentEntryTotalReadBytes += totalRead;
+        streamListener.FireCompressedBytesRead(
+            currentPartTotalReadBytes,
+            currentEntryTotalReadBytes
+        );
         return totalRead;
     }
 
@@ -240,6 +270,12 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
                 break;
             }
         }
+        currentPartTotalReadBytes += totalRead;
+        currentEntryTotalReadBytes += totalRead;
+        streamListener.FireCompressedBytesRead(
+            currentPartTotalReadBytes,
+            currentEntryTotalReadBytes
+        );
         return totalRead;
     }
 #endif

src/SharpCompress/Compressors/Rar/RarStream.cs

@@ -134,7 +134,7 @@ internal class RarStream : Stream, IStreamStack
             fetch = false;
         }
         _position += outTotal;
-        if (count > 0 && outTotal == 0 && _position < Length)
+        if (count > 0 && outTotal == 0 && _position != Length)
         {
             // sanity check, eg if we try to decompress a redir entry
             throw new InvalidOperationException(
@@ -179,7 +179,7 @@ internal class RarStream : Stream, IStreamStack
             fetch = false;
         }
         _position += outTotal;
-        if (count > 0 && outTotal == 0 && _position < Length)
+        if (count > 0 && outTotal == 0 && _position != Length)
         {
             // sanity check, eg if we try to decompress a redir entry
             throw new InvalidOperationException(

src/SharpCompress/Compressors/ZStandard/BitOperations.cs

@@ -1,311 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-#if !NETCOREAPP3_0_OR_GREATER
-
-using System.Runtime.CompilerServices;
-using static SharpCompress.Compressors.ZStandard.UnsafeHelper;
-
-// Some routines inspired by the Stanford Bit Twiddling Hacks by Sean Eron Anderson:
-// http://graphics.stanford.edu/~seander/bithacks.html
-
-namespace System.Numerics
-{
-    /// <summary>
-    /// Utility methods for intrinsic bit-twiddling operations.
-    /// The methods use hardware intrinsics when available on the underlying platform,
-    /// otherwise they use optimized software fallbacks.
-    /// </summary>
-    public static unsafe class BitOperations
-    {
-        // hack: should be public because of inline
-        public static readonly byte* TrailingZeroCountDeBruijn = GetArrayPointer(
-            new byte[]
-            {
-                00,
-                01,
-                28,
-                02,
-                29,
-                14,
-                24,
-                03,
-                30,
-                22,
-                20,
-                15,
-                25,
-                17,
-                04,
-                08,
-                31,
-                27,
-                13,
-                23,
-                21,
-                19,
-                16,
-                07,
-                26,
-                12,
-                18,
-                06,
-                11,
-                05,
-                10,
-                09,
-            }
-        );
-
-        // hack: should be public because of inline
-        public static readonly byte* Log2DeBruijn = GetArrayPointer(
-            new byte[]
-            {
-                00,
-                09,
-                01,
-                10,
-                13,
-                21,
-                02,
-                29,
-                11,
-                14,
-                16,
-                18,
-                22,
-                25,
-                03,
-                30,
-                08,
-                12,
-                20,
-                28,
-                15,
-                17,
-                24,
-                07,
-                19,
-                27,
-                23,
-                06,
-                26,
-                05,
-                04,
-                31,
-            }
-        );
-
-        /// <summary>
-        /// Returns the integer (floor) log of the specified value, base 2.
-        /// Note that by convention, input value 0 returns 0 since log(0) is undefined.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Log2(uint value)
-        {
-            // The 0->0 contract is fulfilled by setting the LSB to 1.
-            // Log(1) is 0, and setting the LSB for values > 1 does not change the log2 result.
-            value |= 1;
-
-            // value    lzcnt   actual  expected
-            // ..0001   31      31-31    0
-            // ..0010   30      31-30    1
-            // 0010..    2      31-2    29
-            // 0100..    1      31-1    30
-            // 1000..    0      31-0    31
-
-            // Fallback contract is 0->0
-            // No AggressiveInlining due to large method size
-            // Has conventional contract 0->0 (Log(0) is undefined)
-
-            // Fill trailing zeros with ones, eg 00010010 becomes 00011111
-            value |= value >> 01;
-            value |= value >> 02;
-            value |= value >> 04;
-            value |= value >> 08;
-            value |= value >> 16;
-
-            // uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
-            return Log2DeBruijn[
-                // Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_1100_0100_1010_1100_1101_1101u
-                (int)((value * 0x07C4ACDDu) >> 27)
-            ];
-        }
-
-        /// <summary>
-        /// Returns the integer (floor) log of the specified value, base 2.
-        /// Note that by convention, input value 0 returns 0 since log(0) is undefined.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Log2(ulong value)
-        {
-            value |= 1;
-
-            uint hi = (uint)(value >> 32);
-
-            if (hi == 0)
-            {
-                return Log2((uint)value);
-            }
-
-            return 32 + Log2(hi);
-        }
-
-        /// <summary>
-        /// Count the number of trailing zero bits in an integer value.
-        /// Similar in behavior to the x86 instruction TZCNT.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int TrailingZeroCount(int value) => TrailingZeroCount((uint)value);
-
-        /// <summary>
-        /// Count the number of trailing zero bits in an integer value.
-        /// Similar in behavior to the x86 instruction TZCNT.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int TrailingZeroCount(uint value)
-        {
-            // Unguarded fallback contract is 0->0, BSF contract is 0->undefined
-            if (value == 0)
-            {
-                return 32;
-            }
-
-            // uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
-            return TrailingZeroCountDeBruijn[
-                // Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_0111_1100_1011_0101_0011_0001u
-                (int)(((value & (uint)-(int)value) * 0x077CB531u) >> 27)
-            ]; // Multi-cast mitigates redundant conv.u8
-        }
-
-        /// <summary>
-        /// Count the number of trailing zero bits in a mask.
-        /// Similar in behavior to the x86 instruction TZCNT.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int TrailingZeroCount(long value) => TrailingZeroCount((ulong)value);
-
-        /// <summary>
-        /// Count the number of trailing zero bits in a mask.
-        /// Similar in behavior to the x86 instruction TZCNT.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int TrailingZeroCount(ulong value)
-        {
-            uint lo = (uint)value;
-
-            if (lo == 0)
-            {
-                return 32 + TrailingZeroCount((uint)(value >> 32));
-            }
-
-            return TrailingZeroCount(lo);
-        }
-
-        /// <summary>
-        /// Rotates the specified value left by the specified number of bits.
-        /// Similar in behavior to the x86 instruction ROL.
-        /// </summary>
-        /// <param name="value">The value to rotate.</param>
-        /// <param name="offset">The number of bits to rotate by.
-        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
-        /// <returns>The rotated value.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint RotateLeft(uint value, int offset) =>
-            (value << offset) | (value >> (32 - offset));
-
-        /// <summary>
-        /// Rotates the specified value left by the specified number of bits.
-        /// Similar in behavior to the x86 instruction ROL.
-        /// </summary>
-        /// <param name="value">The value to rotate.</param>
-        /// <param name="offset">The number of bits to rotate by.
-        /// Any value outside the range [0..63] is treated as congruent mod 64.</param>
-        /// <returns>The rotated value.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong RotateLeft(ulong value, int offset) =>
-            (value << offset) | (value >> (64 - offset));
-
-        /// <summary>
-        /// Rotates the specified value right by the specified number of bits.
-        /// Similar in behavior to the x86 instruction ROR.
-        /// </summary>
-        /// <param name="value">The value to rotate.</param>
-        /// <param name="offset">The number of bits to rotate by.
-        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
-        /// <returns>The rotated value.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint RotateRight(uint value, int offset) =>
-            (value >> offset) | (value << (32 - offset));
-
-        /// <summary>
-        /// Rotates the specified value right by the specified number of bits.
-        /// Similar in behavior to the x86 instruction ROR.
-        /// </summary>
-        /// <param name="value">The value to rotate.</param>
-        /// <param name="offset">The number of bits to rotate by.
-        /// Any value outside the range [0..63] is treated as congruent mod 64.</param>
-        /// <returns>The rotated value.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong RotateRight(ulong value, int offset) =>
-            (value >> offset) | (value << (64 - offset));
-
-        /// <summary>
-        /// Count the number of leading zero bits in a mask.
-        /// Similar in behavior to the x86 instruction LZCNT.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int LeadingZeroCount(uint value)
-        {
-            // Unguarded fallback contract is 0->31, BSR contract is 0->undefined
-            if (value == 0)
-            {
-                return 32;
-            }
-
-            // No AggressiveInlining due to large method size
-            // Has conventional contract 0->0 (Log(0) is undefined)
-
-            // Fill trailing zeros with ones, eg 00010010 becomes 00011111
-            value |= value >> 01;
-            value |= value >> 02;
-            value |= value >> 04;
-            value |= value >> 08;
-            value |= value >> 16;
-
-            // uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
-            return 31
-                ^ Log2DeBruijn[
-                    // uint|long -> IntPtr cast on 32-bit platforms does expensive overflow checks not needed here
-                    (int)((value * 0x07C4ACDDu) >> 27)
-                ];
-        }
-
-        /// <summary>
-        /// Count the number of leading zero bits in a mask.
-        /// Similar in behavior to the x86 instruction LZCNT.
-        /// </summary>
-        /// <param name="value">The value.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int LeadingZeroCount(ulong value)
-        {
-            uint hi = (uint)(value >> 32);
-
-            if (hi == 0)
-            {
-                return 32 + LeadingZeroCount((uint)value);
-            }
-
-            return LeadingZeroCount(hi);
-        }
-    }
-}
-
-#endif

src/SharpCompress/Compressors/ZStandard/CompressionStream.cs

@@ -1,301 +0,0 @@
-using System;
-using System.Buffers;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Compressors.ZStandard.Unsafe;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-public class CompressionStream : Stream
-{
-    private readonly Stream innerStream;
-    private readonly byte[] outputBuffer;
-    private readonly bool preserveCompressor;
-    private readonly bool leaveOpen;
-    private Compressor? compressor;
-    private ZSTD_outBuffer_s output;
-
-    public CompressionStream(
-        Stream stream,
-        int level = Compressor.DefaultCompressionLevel,
-        int bufferSize = 0,
-        bool leaveOpen = true
-    )
-        : this(stream, new Compressor(level), bufferSize, false, leaveOpen) { }
-
-    public CompressionStream(
-        Stream stream,
-        Compressor compressor,
-        int bufferSize = 0,
-        bool preserveCompressor = true,
-        bool leaveOpen = true
-    )
-    {
-        if (stream == null)
-            throw new ArgumentNullException(nameof(stream));
-
-        if (!stream.CanWrite)
-            throw new ArgumentException("Stream is not writable", nameof(stream));
-
-        if (bufferSize < 0)
-            throw new ArgumentOutOfRangeException(nameof(bufferSize));
-
-        innerStream = stream;
-        this.compressor = compressor;
-        this.preserveCompressor = preserveCompressor;
-        this.leaveOpen = leaveOpen;
-
-        var outputBufferSize =
-            bufferSize > 0
-                ? bufferSize
-                : (int)Unsafe.Methods.ZSTD_CStreamOutSize().EnsureZstdSuccess();
-        outputBuffer = ArrayPool<byte>.Shared.Rent(outputBufferSize);
-        output = new ZSTD_outBuffer_s { pos = 0, size = (nuint)outputBufferSize };
-    }
-
-    public void SetParameter(ZSTD_cParameter parameter, int value)
-    {
-        EnsureNotDisposed();
-        compressor.NotNull().SetParameter(parameter, value);
-    }
-
-    public int GetParameter(ZSTD_cParameter parameter)
-    {
-        EnsureNotDisposed();
-        return compressor.NotNull().GetParameter(parameter);
-    }
-
-    public void LoadDictionary(byte[] dict)
-    {
-        EnsureNotDisposed();
-        compressor.NotNull().LoadDictionary(dict);
-    }
-
-    ~CompressionStream() => Dispose(false);
-
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
-    public override async ValueTask DisposeAsync()
-#else
-    public async Task DisposeAsync()
-#endif
-    {
-        if (compressor == null)
-            return;
-
-        try
-        {
-            await FlushInternalAsync(ZSTD_EndDirective.ZSTD_e_end).ConfigureAwait(false);
-        }
-        finally
-        {
-            ReleaseUnmanagedResources();
-            GC.SuppressFinalize(this);
-        }
-    }
-
-    protected override void Dispose(bool disposing)
-    {
-        if (compressor == null)
-            return;
-
-        try
-        {
-            if (disposing)
-                FlushInternal(ZSTD_EndDirective.ZSTD_e_end);
-        }
-        finally
-        {
-            ReleaseUnmanagedResources();
-        }
-    }
-
-    private void ReleaseUnmanagedResources()
-    {
-        if (!preserveCompressor)
-        {
-            compressor.NotNull().Dispose();
-        }
-        compressor = null;
-
-        if (outputBuffer != null)
-        {
-            ArrayPool<byte>.Shared.Return(outputBuffer);
-        }
-
-        if (!leaveOpen)
-        {
-            innerStream.Dispose();
-        }
-    }
-
-    public override void Flush() => FlushInternal(ZSTD_EndDirective.ZSTD_e_flush);
-
-    public override async Task FlushAsync(CancellationToken cancellationToken) =>
-        await FlushInternalAsync(ZSTD_EndDirective.ZSTD_e_flush, cancellationToken)
-            .ConfigureAwait(false);
-
-    private void FlushInternal(ZSTD_EndDirective directive) => WriteInternal(null, directive);
-
-    private async Task FlushInternalAsync(
-        ZSTD_EndDirective directive,
-        CancellationToken cancellationToken = default
-    ) => await WriteInternalAsync(null, directive, cancellationToken).ConfigureAwait(false);
-
-    public override void Write(byte[] buffer, int offset, int count) =>
-        Write(new ReadOnlySpan<byte>(buffer, offset, count));
-
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
-    public override void Write(ReadOnlySpan<byte> buffer) =>
-        WriteInternal(buffer, ZSTD_EndDirective.ZSTD_e_continue);
-#else
-    public void Write(ReadOnlySpan<byte> buffer) =>
-        WriteInternal(buffer, ZSTD_EndDirective.ZSTD_e_continue);
-#endif
-
-    private void WriteInternal(ReadOnlySpan<byte> buffer, ZSTD_EndDirective directive)
-    {
-        EnsureNotDisposed();
-
-        var input = new ZSTD_inBuffer_s
-        {
-            pos = 0,
-            size = buffer != null ? (nuint)buffer.Length : 0,
-        };
-        nuint remaining;
-        do
-        {
-            output.pos = 0;
-            remaining = CompressStream(ref input, buffer, directive);
-
-            var written = (int)output.pos;
-            if (written > 0)
-                innerStream.Write(outputBuffer, 0, written);
-        } while (
-            directive == ZSTD_EndDirective.ZSTD_e_continue ? input.pos < input.size : remaining > 0
-        );
-    }
-
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
-    private async ValueTask WriteInternalAsync(
-        ReadOnlyMemory<byte>? buffer,
-        ZSTD_EndDirective directive,
-        CancellationToken cancellationToken = default
-    )
-#else
-    private async Task WriteInternalAsync(
-        ReadOnlyMemory<byte>? buffer,
-        ZSTD_EndDirective directive,
-        CancellationToken cancellationToken = default
-    )
-#endif
-
-    {
-        EnsureNotDisposed();
-
-        var input = new ZSTD_inBuffer_s
-        {
-            pos = 0,
-            size = buffer.HasValue ? (nuint)buffer.Value.Length : 0,
-        };
-        nuint remaining;
-        do
-        {
-            output.pos = 0;
-            remaining = CompressStream(
-                ref input,
-                buffer.HasValue ? buffer.Value.Span : null,
-                directive
-            );
-
-            var written = (int)output.pos;
-            if (written > 0)
-                await innerStream
-                    .WriteAsync(outputBuffer, 0, written, cancellationToken)
-                    .ConfigureAwait(false);
-        } while (
-            directive == ZSTD_EndDirective.ZSTD_e_continue ? input.pos < input.size : remaining > 0
-        );
-    }
-
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
-
-    public override Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    ) => WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
-
-    public override async ValueTask WriteAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken = default
-    ) =>
-        await WriteInternalAsync(buffer, ZSTD_EndDirective.ZSTD_e_continue, cancellationToken)
-            .ConfigureAwait(false);
-#else
-
-    public override Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    ) => WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken);
-
-    public async Task WriteAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken = default
-    ) =>
-        await WriteInternalAsync(buffer, ZSTD_EndDirective.ZSTD_e_continue, cancellationToken)
-            .ConfigureAwait(false);
-#endif
-
-    internal unsafe nuint CompressStream(
-        ref ZSTD_inBuffer_s input,
-        ReadOnlySpan<byte> inputBuffer,
-        ZSTD_EndDirective directive
-    )
-    {
-        fixed (byte* inputBufferPtr = inputBuffer)
-        fixed (byte* outputBufferPtr = outputBuffer)
-        {
-            input.src = inputBufferPtr;
-            output.dst = outputBufferPtr;
-            return compressor
-                .NotNull()
-                .CompressStream(ref input, ref output, directive)
-                .EnsureZstdSuccess();
-        }
-    }
-
-    public override bool CanRead => false;
-    public override bool CanSeek => false;
-    public override bool CanWrite => true;
-
-    public override long Length => throw new NotSupportedException();
-
-    public override long Position
-    {
-        get => throw new NotSupportedException();
-        set => throw new NotSupportedException();
-    }
-
-    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
-
-    public override void SetLength(long value) => throw new NotSupportedException();
-
-    public override int Read(byte[] buffer, int offset, int count) =>
-        throw new NotSupportedException();
-
-    private void EnsureNotDisposed()
-    {
-        if (compressor == null)
-            throw new ObjectDisposedException(nameof(CompressionStream));
-    }
-
-    public void SetPledgedSrcSize(ulong pledgedSrcSize)
-    {
-        EnsureNotDisposed();
-        compressor.NotNull().SetPledgedSrcSize(pledgedSrcSize);
-    }
-}

src/SharpCompress/Compressors/ZStandard/Compressor.cs

@@ -1,204 +0,0 @@
-using System;
-using SharpCompress.Compressors.ZStandard.Unsafe;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-public unsafe class Compressor : IDisposable
-{
-    /// <summary>
-    /// Minimum negative compression level allowed
-    /// </summary>
-    public static int MinCompressionLevel => Unsafe.Methods.ZSTD_minCLevel();
-
-    /// <summary>
-    /// Maximum compression level available
-    /// </summary>
-    public static int MaxCompressionLevel => Unsafe.Methods.ZSTD_maxCLevel();
-
-    /// <summary>
-    /// Default compression level
-    /// </summary>
-    /// <see cref="Unsafe.Methods.ZSTD_defaultCLevel"/>
-    public const int DefaultCompressionLevel = 3;
-
-    private int level = DefaultCompressionLevel;
-
-    private readonly SafeCctxHandle handle;
-
-    public int Level
-    {
-        get => level;
-        set
-        {
-            if (level != value)
-            {
-                level = value;
-                SetParameter(ZSTD_cParameter.ZSTD_c_compressionLevel, value);
-            }
-        }
-    }
-
-    public void SetParameter(ZSTD_cParameter parameter, int value)
-    {
-        using var cctx = handle.Acquire();
-        Unsafe.Methods.ZSTD_CCtx_setParameter(cctx, parameter, value).EnsureZstdSuccess();
-    }
-
-    public int GetParameter(ZSTD_cParameter parameter)
-    {
-        using var cctx = handle.Acquire();
-        int value;
-        Unsafe.Methods.ZSTD_CCtx_getParameter(cctx, parameter, &value).EnsureZstdSuccess();
-        return value;
-    }
-
-    public void LoadDictionary(byte[] dict)
-    {
-        var dictReadOnlySpan = new ReadOnlySpan<byte>(dict);
-        LoadDictionary(dictReadOnlySpan);
-    }
-
-    public void LoadDictionary(ReadOnlySpan<byte> dict)
-    {
-        using var cctx = handle.Acquire();
-        fixed (byte* dictPtr = dict)
-            Unsafe
-                .Methods.ZSTD_CCtx_loadDictionary(cctx, dictPtr, (nuint)dict.Length)
-                .EnsureZstdSuccess();
-    }
-
-    public Compressor(int level = DefaultCompressionLevel)
-    {
-        handle = SafeCctxHandle.Create();
-        Level = level;
-    }
-
-    public static int GetCompressBound(int length) =>
-        (int)Unsafe.Methods.ZSTD_compressBound((nuint)length);
-
-    public static ulong GetCompressBoundLong(ulong length) =>
-        Unsafe.Methods.ZSTD_compressBound((nuint)length);
-
-    public Span<byte> Wrap(ReadOnlySpan<byte> src)
-    {
-        var dest = new byte[GetCompressBound(src.Length)];
-        var length = Wrap(src, dest);
-        return new Span<byte>(dest, 0, length);
-    }
-
-    public int Wrap(byte[] src, byte[] dest, int offset) =>
-        Wrap(src, new Span<byte>(dest, offset, dest.Length - offset));
-
-    public int Wrap(ReadOnlySpan<byte> src, Span<byte> dest)
-    {
-        fixed (byte* srcPtr = src)
-        fixed (byte* destPtr = dest)
-        {
-            using var cctx = handle.Acquire();
-            return (int)
-                Unsafe
-                    .Methods.ZSTD_compress2(
-                        cctx,
-                        destPtr,
-                        (nuint)dest.Length,
-                        srcPtr,
-                        (nuint)src.Length
-                    )
-                    .EnsureZstdSuccess();
-        }
-    }
-
-    public int Wrap(ArraySegment<byte> src, ArraySegment<byte> dest) =>
-        Wrap((ReadOnlySpan<byte>)src, dest);
-
-    public int Wrap(
-        byte[] src,
-        int srcOffset,
-        int srcLength,
-        byte[] dst,
-        int dstOffset,
-        int dstLength
-    ) =>
-        Wrap(
-            new ReadOnlySpan<byte>(src, srcOffset, srcLength),
-            new Span<byte>(dst, dstOffset, dstLength)
-        );
-
-    public bool TryWrap(byte[] src, byte[] dest, int offset, out int written) =>
-        TryWrap(src, new Span<byte>(dest, offset, dest.Length - offset), out written);
-
-    public bool TryWrap(ReadOnlySpan<byte> src, Span<byte> dest, out int written)
-    {
-        fixed (byte* srcPtr = src)
-        fixed (byte* destPtr = dest)
-        {
-            nuint returnValue;
-            using (var cctx = handle.Acquire())
-            {
-                returnValue = Unsafe.Methods.ZSTD_compress2(
-                    cctx,
-                    destPtr,
-                    (nuint)dest.Length,
-                    srcPtr,
-                    (nuint)src.Length
-                );
-            }
-
-            if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall))
-            {
-                written = default;
-                return false;
-            }
-
-            returnValue.EnsureZstdSuccess();
-            written = (int)returnValue;
-            return true;
-        }
-    }
-
-    public bool TryWrap(ArraySegment<byte> src, ArraySegment<byte> dest, out int written) =>
-        TryWrap((ReadOnlySpan<byte>)src, dest, out written);
-
-    public bool TryWrap(
-        byte[] src,
-        int srcOffset,
-        int srcLength,
-        byte[] dst,
-        int dstOffset,
-        int dstLength,
-        out int written
-    ) =>
-        TryWrap(
-            new ReadOnlySpan<byte>(src, srcOffset, srcLength),
-            new Span<byte>(dst, dstOffset, dstLength),
-            out written
-        );
-
-    public void Dispose()
-    {
-        handle.Dispose();
-        GC.SuppressFinalize(this);
-    }
-
-    internal nuint CompressStream(
-        ref ZSTD_inBuffer_s input,
-        ref ZSTD_outBuffer_s output,
-        ZSTD_EndDirective directive
-    )
-    {
-        fixed (ZSTD_inBuffer_s* inputPtr = &input)
-        fixed (ZSTD_outBuffer_s* outputPtr = &output)
-        {
-            using var cctx = handle.Acquire();
-            return Unsafe
-                .Methods.ZSTD_compressStream2(cctx, outputPtr, inputPtr, directive)
-                .EnsureZstdSuccess();
-        }
-    }
-
-    public void SetPledgedSrcSize(ulong pledgedSrcSize)
-    {
-        using var cctx = handle.Acquire();
-        Unsafe.Methods.ZSTD_CCtx_setPledgedSrcSize(cctx, pledgedSrcSize).EnsureZstdSuccess();
-    }
-}

src/SharpCompress/Compressors/ZStandard/Constants.cs

@@ -1,8 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard;
-
-internal class Constants
-{
-    //NOTE: https://docs.microsoft.com/en-us/dotnet/framework/configure-apps/file-schema/runtime/gcallowverylargeobjects-element#remarks
-    //NOTE: https://github.com/dotnet/runtime/blob/v5.0.0-rtm.20519.4/src/libraries/System.Private.CoreLib/src/System/Array.cs#L27
-    public const ulong MaxByteArrayLength = 0x7FFFFFC7;
-}

src/SharpCompress/Compressors/ZStandard/DecompressionStream.cs

@@ -1,293 +0,0 @@
-using System;
-using System.Buffers;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Compressors.ZStandard.Unsafe;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-public class DecompressionStream : Stream
-{
-    private readonly Stream innerStream;
-    private readonly byte[] inputBuffer;
-    private readonly int inputBufferSize;
-    private readonly bool preserveDecompressor;
-    private readonly bool leaveOpen;
-    private readonly bool checkEndOfStream;
-    private Decompressor? decompressor;
-    private ZSTD_inBuffer_s input;
-    private nuint lastDecompressResult = 0;
-    private bool contextDrained = true;
-
-    public DecompressionStream(
-        Stream stream,
-        int bufferSize = 0,
-        bool checkEndOfStream = true,
-        bool leaveOpen = true
-    )
-        : this(stream, new Decompressor(), bufferSize, checkEndOfStream, false, leaveOpen) { }
-
-    public DecompressionStream(
-        Stream stream,
-        Decompressor decompressor,
-        int bufferSize = 0,
-        bool checkEndOfStream = true,
-        bool preserveDecompressor = true,
-        bool leaveOpen = true
-    )
-    {
-        if (stream == null)
-            throw new ArgumentNullException(nameof(stream));
-
-        if (!stream.CanRead)
-            throw new ArgumentException("Stream is not readable", nameof(stream));
-
-        if (bufferSize < 0)
-            throw new ArgumentOutOfRangeException(nameof(bufferSize));
-
-        innerStream = stream;
-        this.decompressor = decompressor;
-        this.preserveDecompressor = preserveDecompressor;
-        this.leaveOpen = leaveOpen;
-        this.checkEndOfStream = checkEndOfStream;
-
-        inputBufferSize =
-            bufferSize > 0
-                ? bufferSize
-                : (int)Unsafe.Methods.ZSTD_DStreamInSize().EnsureZstdSuccess();
-        inputBuffer = ArrayPool<byte>.Shared.Rent(inputBufferSize);
-        input = new ZSTD_inBuffer_s { pos = (nuint)inputBufferSize, size = (nuint)inputBufferSize };
-    }
-
-    public void SetParameter(ZSTD_dParameter parameter, int value)
-    {
-        EnsureNotDisposed();
-        decompressor.NotNull().SetParameter(parameter, value);
-    }
-
-    public int GetParameter(ZSTD_dParameter parameter)
-    {
-        EnsureNotDisposed();
-        return decompressor.NotNull().GetParameter(parameter);
-    }
-
-    public void LoadDictionary(byte[] dict)
-    {
-        EnsureNotDisposed();
-        decompressor.NotNull().LoadDictionary(dict);
-    }
-
-    ~DecompressionStream() => Dispose(false);
-
-    protected override void Dispose(bool disposing)
-    {
-        if (decompressor == null)
-            return;
-
-        if (!preserveDecompressor)
-        {
-            decompressor.Dispose();
-        }
-        decompressor = null;
-
-        if (inputBuffer != null)
-        {
-            ArrayPool<byte>.Shared.Return(inputBuffer);
-        }
-
-        if (!leaveOpen)
-        {
-            innerStream.Dispose();
-        }
-    }
-
-    public override int Read(byte[] buffer, int offset, int count) =>
-        Read(new Span<byte>(buffer, offset, count));
-
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
-    public override int Read(Span<byte> buffer)
-#else
-    public int Read(Span<byte> buffer)
-#endif
-    {
-        EnsureNotDisposed();
-
-        // Guard against infinite loop (output.pos would never become non-zero)
-        if (buffer.Length == 0)
-        {
-            return 0;
-        }
-
-        var output = new ZSTD_outBuffer_s { pos = 0, size = (nuint)buffer.Length };
-        while (true)
-        {
-            // If there is still input available, or there might be data buffered in the decompressor context, flush that out
-            while (input.pos < input.size || !contextDrained)
-            {
-                nuint oldInputPos = input.pos;
-                nuint result = DecompressStream(ref output, buffer);
-                if (output.pos > 0 || oldInputPos != input.pos)
-                {
-                    // Keep result from last decompress call that made some progress, so we known if we're at end of frame
-                    lastDecompressResult = result;
-                }
-                // If decompression filled the output buffer, there might still be data buffered in the decompressor context
-                contextDrained = output.pos < output.size;
-                // If we have data to return, return it immediately, so we won't stall on Read
-                if (output.pos > 0)
-                {
-                    return (int)output.pos;
-                }
-            }
-
-            // Otherwise, read some more input
-            int bytesRead;
-            if ((bytesRead = innerStream.Read(inputBuffer, 0, inputBufferSize)) == 0)
-            {
-                if (checkEndOfStream && lastDecompressResult != 0)
-                {
-                    throw new EndOfStreamException("Premature end of stream");
-                }
-
-                return 0;
-            }
-
-            input.size = (nuint)bytesRead;
-            input.pos = 0;
-        }
-    }
-
-#if !NETSTANDARD2_0 && !NETFRAMEWORK
-    public override Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    ) => ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
-
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-#else
-
-    public override Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    ) => ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken);
-
-    public async Task<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-#endif
-    {
-        EnsureNotDisposed();
-
-        // Guard against infinite loop (output.pos would never become non-zero)
-        if (buffer.Length == 0)
-        {
-            return 0;
-        }
-
-        var output = new ZSTD_outBuffer_s { pos = 0, size = (nuint)buffer.Length };
-        while (true)
-        {
-            // If there is still input available, or there might be data buffered in the decompressor context, flush that out
-            while (input.pos < input.size || !contextDrained)
-            {
-                nuint oldInputPos = input.pos;
-                nuint result = DecompressStream(ref output, buffer.Span);
-                if (output.pos > 0 || oldInputPos != input.pos)
-                {
-                    // Keep result from last decompress call that made some progress, so we known if we're at end of frame
-                    lastDecompressResult = result;
-                }
-                // If decompression filled the output buffer, there might still be data buffered in the decompressor context
-                contextDrained = output.pos < output.size;
-                // If we have data to return, return it immediately, so we won't stall on Read
-                if (output.pos > 0)
-                {
-                    return (int)output.pos;
-                }
-            }
-
-            // Otherwise, read some more input
-            int bytesRead;
-            if (
-                (
-                    bytesRead = await innerStream
-                        .ReadAsync(inputBuffer, 0, inputBufferSize, cancellationToken)
-                        .ConfigureAwait(false)
-                ) == 0
-            )
-            {
-                if (checkEndOfStream && lastDecompressResult != 0)
-                {
-                    throw new EndOfStreamException("Premature end of stream");
-                }
-
-                return 0;
-            }
-
-            input.size = (nuint)bytesRead;
-            input.pos = 0;
-        }
-    }
-
-    private unsafe nuint DecompressStream(ref ZSTD_outBuffer_s output, Span<byte> outputBuffer)
-    {
-        fixed (byte* inputBufferPtr = inputBuffer)
-        fixed (byte* outputBufferPtr = outputBuffer)
-        {
-            input.src = inputBufferPtr;
-            output.dst = outputBufferPtr;
-            return decompressor.NotNull().DecompressStream(ref input, ref output);
-        }
-    }
-
-    public override bool CanRead => true;
-    public override bool CanSeek => false;
-    public override bool CanWrite => false;
-
-    public override long Length => throw new NotSupportedException();
-
-    public override long Position
-    {
-        get => throw new NotSupportedException();
-        set => throw new NotSupportedException();
-    }
-
-    public override void Flush() => throw new NotSupportedException();
-
-    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
-
-    public override void SetLength(long value) => throw new NotSupportedException();
-
-    public override void Write(byte[] buffer, int offset, int count) =>
-        throw new NotSupportedException();
-
-    private void EnsureNotDisposed()
-    {
-        if (decompressor == null)
-            throw new ObjectDisposedException(nameof(DecompressionStream));
-    }
-
-#if NETSTANDARD2_0 || NETFRAMEWORK
-    public virtual Task DisposeAsync()
-    {
-        try
-        {
-            Dispose();
-            return Task.CompletedTask;
-        }
-        catch (Exception exc)
-        {
-            return Task.FromException(exc);
-        }
-    }
-#endif
-}

src/SharpCompress/Compressors/ZStandard/Decompressor.cs

@@ -1,176 +0,0 @@
-using System;
-using SharpCompress.Compressors.ZStandard.Unsafe;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-public unsafe class Decompressor : IDisposable
-{
-    private readonly SafeDctxHandle handle;
-
-    public Decompressor()
-    {
-        handle = SafeDctxHandle.Create();
-    }
-
-    public void SetParameter(ZSTD_dParameter parameter, int value)
-    {
-        using var dctx = handle.Acquire();
-        Unsafe.Methods.ZSTD_DCtx_setParameter(dctx, parameter, value).EnsureZstdSuccess();
-    }
-
-    public int GetParameter(ZSTD_dParameter parameter)
-    {
-        using var dctx = handle.Acquire();
-        int value;
-        Unsafe.Methods.ZSTD_DCtx_getParameter(dctx, parameter, &value).EnsureZstdSuccess();
-        return value;
-    }
-
-    public void LoadDictionary(byte[] dict)
-    {
-        var dictReadOnlySpan = new ReadOnlySpan<byte>(dict);
-        this.LoadDictionary(dictReadOnlySpan);
-    }
-
-    public void LoadDictionary(ReadOnlySpan<byte> dict)
-    {
-        using var dctx = handle.Acquire();
-        fixed (byte* dictPtr = dict)
-            Unsafe
-                .Methods.ZSTD_DCtx_loadDictionary(dctx, dictPtr, (nuint)dict.Length)
-                .EnsureZstdSuccess();
-    }
-
-    public static ulong GetDecompressedSize(ReadOnlySpan<byte> src)
-    {
-        fixed (byte* srcPtr = src)
-            return Unsafe
-                .Methods.ZSTD_decompressBound(srcPtr, (nuint)src.Length)
-                .EnsureContentSizeOk();
-    }
-
-    public static ulong GetDecompressedSize(ArraySegment<byte> src) =>
-        GetDecompressedSize((ReadOnlySpan<byte>)src);
-
-    public static ulong GetDecompressedSize(byte[] src, int srcOffset, int srcLength) =>
-        GetDecompressedSize(new ReadOnlySpan<byte>(src, srcOffset, srcLength));
-
-    public Span<byte> Unwrap(ReadOnlySpan<byte> src, int maxDecompressedSize = int.MaxValue)
-    {
-        var expectedDstSize = GetDecompressedSize(src);
-        if (expectedDstSize > (ulong)maxDecompressedSize)
-            throw new ZstdException(
-                ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall,
-                $"Decompressed content size {expectedDstSize} is greater than {nameof(maxDecompressedSize)} {maxDecompressedSize}"
-            );
-        if (expectedDstSize > Constants.MaxByteArrayLength)
-            throw new ZstdException(
-                ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall,
-                $"Decompressed content size {expectedDstSize} is greater than max possible byte array size {Constants.MaxByteArrayLength}"
-            );
-
-        var dest = new byte[expectedDstSize];
-        var length = Unwrap(src, dest);
-        return new Span<byte>(dest, 0, length);
-    }
-
-    public int Unwrap(byte[] src, byte[] dest, int offset) =>
-        Unwrap(src, new Span<byte>(dest, offset, dest.Length - offset));
-
-    public int Unwrap(ReadOnlySpan<byte> src, Span<byte> dest)
-    {
-        fixed (byte* srcPtr = src)
-        fixed (byte* destPtr = dest)
-        {
-            using var dctx = handle.Acquire();
-            return (int)
-                Unsafe
-                    .Methods.ZSTD_decompressDCtx(
-                        dctx,
-                        destPtr,
-                        (nuint)dest.Length,
-                        srcPtr,
-                        (nuint)src.Length
-                    )
-                    .EnsureZstdSuccess();
-        }
-    }
-
-    public int Unwrap(
-        byte[] src,
-        int srcOffset,
-        int srcLength,
-        byte[] dst,
-        int dstOffset,
-        int dstLength
-    ) =>
-        Unwrap(
-            new ReadOnlySpan<byte>(src, srcOffset, srcLength),
-            new Span<byte>(dst, dstOffset, dstLength)
-        );
-
-    public bool TryUnwrap(byte[] src, byte[] dest, int offset, out int written) =>
-        TryUnwrap(src, new Span<byte>(dest, offset, dest.Length - offset), out written);
-
-    public bool TryUnwrap(ReadOnlySpan<byte> src, Span<byte> dest, out int written)
-    {
-        fixed (byte* srcPtr = src)
-        fixed (byte* destPtr = dest)
-        {
-            nuint returnValue;
-            using (var dctx = handle.Acquire())
-            {
-                returnValue = Unsafe.Methods.ZSTD_decompressDCtx(
-                    dctx,
-                    destPtr,
-                    (nuint)dest.Length,
-                    srcPtr,
-                    (nuint)src.Length
-                );
-            }
-
-            if (returnValue == unchecked(0 - (nuint)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall))
-            {
-                written = default;
-                return false;
-            }
-
-            returnValue.EnsureZstdSuccess();
-            written = (int)returnValue;
-            return true;
-        }
-    }
-
-    public bool TryUnwrap(
-        byte[] src,
-        int srcOffset,
-        int srcLength,
-        byte[] dst,
-        int dstOffset,
-        int dstLength,
-        out int written
-    ) =>
-        TryUnwrap(
-            new ReadOnlySpan<byte>(src, srcOffset, srcLength),
-            new Span<byte>(dst, dstOffset, dstLength),
-            out written
-        );
-
-    public void Dispose()
-    {
-        handle.Dispose();
-        GC.SuppressFinalize(this);
-    }
-
-    internal nuint DecompressStream(ref ZSTD_inBuffer_s input, ref ZSTD_outBuffer_s output)
-    {
-        fixed (ZSTD_inBuffer_s* inputPtr = &input)
-        fixed (ZSTD_outBuffer_s* outputPtr = &output)
-        {
-            using var dctx = handle.Acquire();
-            return Unsafe
-                .Methods.ZSTD_decompressStream(dctx, outputPtr, inputPtr)
-                .EnsureZstdSuccess();
-        }
-    }
-}

src/SharpCompress/Compressors/ZStandard/JobThreadPool.cs

@@ -1,141 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Threading;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-internal unsafe class JobThreadPool : IDisposable
-{
-    private int numThreads;
-    private readonly List<JobThread> threads;
-    private readonly BlockingCollection<Job> queue;
-
-    private struct Job
-    {
-        public void* function;
-        public void* opaque;
-    }
-
-    private class JobThread
-    {
-        private Thread Thread { get; }
-        public CancellationTokenSource CancellationTokenSource { get; }
-
-        public JobThread(Thread thread)
-        {
-            CancellationTokenSource = new CancellationTokenSource();
-            Thread = thread;
-        }
-
-        public void Start()
-        {
-            Thread.Start(this);
-        }
-
-        public void Cancel()
-        {
-            CancellationTokenSource.Cancel();
-        }
-
-        public void Join()
-        {
-            Thread.Join();
-        }
-    }
-
-    private void Worker(object? obj)
-    {
-        if (obj is not JobThread poolThread)
-            return;
-
-        var cancellationToken = poolThread.CancellationTokenSource.Token;
-        while (!queue.IsCompleted && !cancellationToken.IsCancellationRequested)
-        {
-            try
-            {
-                if (queue.TryTake(out var job, -1, cancellationToken))
-                    ((delegate* managed<void*, void>)job.function)(job.opaque);
-            }
-            catch (InvalidOperationException) { }
-            catch (OperationCanceledException) { }
-        }
-    }
-
-    public JobThreadPool(int num, int queueSize)
-    {
-        numThreads = num;
-        queue = new BlockingCollection<Job>(queueSize + 1);
-        threads = new List<JobThread>(num);
-        for (var i = 0; i < numThreads; i++)
-            CreateThread();
-    }
-
-    private void CreateThread()
-    {
-        var poolThread = new JobThread(new Thread(Worker));
-        threads.Add(poolThread);
-        poolThread.Start();
-    }
-
-    public void Resize(int num)
-    {
-        lock (threads)
-        {
-            if (num < numThreads)
-            {
-                for (var i = numThreads - 1; i >= num; i--)
-                {
-                    threads[i].Cancel();
-                    threads.RemoveAt(i);
-                }
-            }
-            else
-            {
-                for (var i = numThreads; i < num; i++)
-                    CreateThread();
-            }
-        }
-
-        numThreads = num;
-    }
-
-    public void Add(void* function, void* opaque)
-    {
-        queue.Add(new Job { function = function, opaque = opaque });
-    }
-
-    public bool TryAdd(void* function, void* opaque)
-    {
-        return queue.TryAdd(new Job { function = function, opaque = opaque });
-    }
-
-    public void Join(bool cancel = true)
-    {
-        queue.CompleteAdding();
-        List<JobThread> jobThreads;
-        lock (threads)
-            jobThreads = new List<JobThread>(threads);
-
-        if (cancel)
-        {
-            foreach (var thread in jobThreads)
-                thread.Cancel();
-        }
-
-        foreach (var thread in jobThreads)
-            thread.Join();
-    }
-
-    public void Dispose()
-    {
-        queue.Dispose();
-    }
-
-    public int Size()
-    {
-        // todo not implemented
-        // https://github.com/dotnet/runtime/issues/24200
-        return 0;
-    }
-}

src/SharpCompress/Compressors/ZStandard/SafeHandles.cs

@@ -1,163 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-using SharpCompress.Compressors.ZStandard.Unsafe;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-/// <summary>
-/// Provides the base class for ZstdSharp <see cref="SafeHandle"/> implementations.
-/// </summary>
-/// <remarks>
-/// Even though ZstdSharp is a managed library, its internals are using unmanaged
-/// memory and we are using safe handles in the library's high-level API to ensure
-/// proper disposal of unmanaged resources and increase safety.
-/// </remarks>
-/// <seealso cref="SafeCctxHandle"/>
-/// <seealso cref="SafeDctxHandle"/>
-internal abstract unsafe class SafeZstdHandle : SafeHandle
-{
-    /// <summary>
-    /// Parameterless constructor is hidden. Use the static <c>Create</c> factory
-    /// method to create a new safe handle instance.
-    /// </summary>
-    protected SafeZstdHandle()
-        : base(IntPtr.Zero, true) { }
-
-    public sealed override bool IsInvalid => handle == IntPtr.Zero;
-}
-
-/// <summary>
-/// Safely wraps an unmanaged Zstd compression context.
-/// </summary>
-internal sealed unsafe class SafeCctxHandle : SafeZstdHandle
-{
-    /// <inheritdoc/>
-    private SafeCctxHandle() { }
-
-    /// <summary>
-    /// Creates a new instance of <see cref="SafeCctxHandle"/>.
-    /// </summary>
-    /// <returns></returns>
-    /// <exception cref="ZstdException">Creation failed.</exception>
-    public static SafeCctxHandle Create()
-    {
-        var safeHandle = new SafeCctxHandle();
-        bool success = false;
-        try
-        {
-            var cctx = Unsafe.Methods.ZSTD_createCCtx();
-            if (cctx == null)
-                throw new ZstdException(ZSTD_ErrorCode.ZSTD_error_GENERIC, "Failed to create cctx");
-            safeHandle.SetHandle((IntPtr)cctx);
-            success = true;
-        }
-        finally
-        {
-            if (!success)
-            {
-                safeHandle.SetHandleAsInvalid();
-            }
-        }
-        return safeHandle;
-    }
-
-    /// <summary>
-    /// Acquires a reference to the safe handle.
-    /// </summary>
-    /// <returns>
-    /// A <see cref="SafeHandleHolder{T}"/> instance that can be implicitly converted to a pointer
-    /// to <see cref="ZSTD_CCtx_s"/>.
-    /// </returns>
-    public SafeHandleHolder<ZSTD_CCtx_s> Acquire() => new(this);
-
-    protected override bool ReleaseHandle()
-    {
-        return Unsafe.Methods.ZSTD_freeCCtx((ZSTD_CCtx_s*)handle) == 0;
-    }
-}
-
-/// <summary>
-/// Safely wraps an unmanaged Zstd compression context.
-/// </summary>
-internal sealed unsafe class SafeDctxHandle : SafeZstdHandle
-{
-    /// <inheritdoc/>
-    private SafeDctxHandle() { }
-
-    /// <summary>
-    /// Creates a new instance of <see cref="SafeDctxHandle"/>.
-    /// </summary>
-    /// <returns></returns>
-    /// <exception cref="ZstdException">Creation failed.</exception>
-    public static SafeDctxHandle Create()
-    {
-        var safeHandle = new SafeDctxHandle();
-        bool success = false;
-        try
-        {
-            var dctx = Unsafe.Methods.ZSTD_createDCtx();
-            if (dctx == null)
-                throw new ZstdException(ZSTD_ErrorCode.ZSTD_error_GENERIC, "Failed to create dctx");
-            safeHandle.SetHandle((IntPtr)dctx);
-            success = true;
-        }
-        finally
-        {
-            if (!success)
-            {
-                safeHandle.SetHandleAsInvalid();
-            }
-        }
-        return safeHandle;
-    }
-
-    /// <summary>
-    /// Acquires a reference to the safe handle.
-    /// </summary>
-    /// <returns>
-    /// A <see cref="SafeHandleHolder{T}"/> instance that can be implicitly converted to a pointer
-    /// to <see cref="ZSTD_DCtx_s"/>.
-    /// </returns>
-    public SafeHandleHolder<ZSTD_DCtx_s> Acquire() => new(this);
-
-    protected override bool ReleaseHandle()
-    {
-        return Unsafe.Methods.ZSTD_freeDCtx((ZSTD_DCtx_s*)handle) == 0;
-    }
-}
-
-/// <summary>
-/// Provides a convenient interface to safely acquire pointers of a specific type
-/// from a <see cref="SafeHandle"/>, by utilizing <see langword="using"/> blocks.
-/// </summary>
-/// <typeparam name="T">The type of pointers to return.</typeparam>
-/// <remarks>
-/// Safe handle holders can be <see cref="Dispose"/>d to decrement the safe handle's
-/// reference count, and can be implicitly converted to pointers to <see cref="T"/>.
-/// </remarks>
-internal unsafe ref struct SafeHandleHolder<T>
-    where T : unmanaged
-{
-    private readonly SafeHandle _handle;
-
-    private bool _refAdded;
-
-    public SafeHandleHolder(SafeHandle safeHandle)
-    {
-        _handle = safeHandle;
-        _refAdded = false;
-        safeHandle.DangerousAddRef(ref _refAdded);
-    }
-
-    public static implicit operator T*(SafeHandleHolder<T> holder) =>
-        (T*)holder._handle.DangerousGetHandle();
-
-    public void Dispose()
-    {
-        if (_refAdded)
-        {
-            _handle.DangerousRelease();
-            _refAdded = false;
-        }
-    }
-}

src/SharpCompress/Compressors/ZStandard/SynchronizationWrapper.cs

@@ -1,22 +0,0 @@
-using System.Threading;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-internal static unsafe class SynchronizationWrapper
-{
-    private static object UnwrapObject(void** obj) => UnmanagedObject.Unwrap<object>(*obj);
-
-    public static void Init(void** obj) => *obj = UnmanagedObject.Wrap(new object());
-
-    public static void Free(void** obj) => UnmanagedObject.Free(*obj);
-
-    public static void Enter(void** obj) => Monitor.Enter(UnwrapObject(obj));
-
-    public static void Exit(void** obj) => Monitor.Exit(UnwrapObject(obj));
-
-    public static void Pulse(void** obj) => Monitor.Pulse(UnwrapObject(obj));
-
-    public static void PulseAll(void** obj) => Monitor.PulseAll(UnwrapObject(obj));
-
-    public static void Wait(void** mutex) => Monitor.Wait(UnwrapObject(mutex));
-}

src/SharpCompress/Compressors/ZStandard/ThrowHelper.cs

@@ -1,48 +0,0 @@
-using SharpCompress.Compressors.ZStandard.Unsafe;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-public static unsafe class ThrowHelper
-{
-    private const ulong ZSTD_CONTENTSIZE_UNKNOWN = unchecked(0UL - 1);
-    private const ulong ZSTD_CONTENTSIZE_ERROR = unchecked(0UL - 2);
-
-    public static nuint EnsureZstdSuccess(this nuint returnValue)
-    {
-        if (Unsafe.Methods.ZSTD_isError(returnValue))
-            ThrowException(returnValue, Unsafe.Methods.ZSTD_getErrorName(returnValue));
-
-        return returnValue;
-    }
-
-    public static nuint EnsureZdictSuccess(this nuint returnValue)
-    {
-        if (Unsafe.Methods.ZDICT_isError(returnValue))
-            ThrowException(returnValue, Unsafe.Methods.ZDICT_getErrorName(returnValue));
-
-        return returnValue;
-    }
-
-    public static ulong EnsureContentSizeOk(this ulong returnValue)
-    {
-        if (returnValue == ZSTD_CONTENTSIZE_UNKNOWN)
-            throw new ZstdException(
-                ZSTD_ErrorCode.ZSTD_error_GENERIC,
-                "Decompressed content size is not specified"
-            );
-
-        if (returnValue == ZSTD_CONTENTSIZE_ERROR)
-            throw new ZstdException(
-                ZSTD_ErrorCode.ZSTD_error_GENERIC,
-                "Decompressed content size cannot be determined (e.g. invalid magic number, srcSize too small)"
-            );
-
-        return returnValue;
-    }
-
-    private static void ThrowException(nuint returnValue, string message)
-    {
-        var code = 0 - returnValue;
-        throw new ZstdException((ZSTD_ErrorCode)code, message);
-    }
-}

src/SharpCompress/Compressors/ZStandard/UnmanagedObject.cs

@@ -1,18 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace SharpCompress.Compressors.ZStandard;
-
-/*
- * Wrap object to void* to make it unmanaged
- */
-internal static unsafe class UnmanagedObject
-{
-    public static void* Wrap(object obj) => (void*)GCHandle.ToIntPtr(GCHandle.Alloc(obj));
-
-    private static GCHandle UnwrapGcHandle(void* value) => GCHandle.FromIntPtr((IntPtr)value);
-
-    public static T Unwrap<T>(void* value) => (T)UnwrapGcHandle(value).Target!;
-
-    public static void Free(void* value) => UnwrapGcHandle(value).Free();
-}

src/SharpCompress/Compressors/ZStandard/Unsafe/Allocations.cs

@@ -1,52 +0,0 @@
-using System.Runtime.CompilerServices;
-using static SharpCompress.Compressors.ZStandard.UnsafeHelper;
-
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public static unsafe partial class Methods
-{
-    /* custom memory allocation functions */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void* ZSTD_customMalloc(nuint size, ZSTD_customMem customMem)
-    {
-        if (customMem.customAlloc != null)
-            return ((delegate* managed<void*, nuint, void*>)customMem.customAlloc)(
-                customMem.opaque,
-                size
-            );
-        return malloc(size);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void* ZSTD_customCalloc(nuint size, ZSTD_customMem customMem)
-    {
-        if (customMem.customAlloc != null)
-        {
-            /* calloc implemented as malloc+memset;
-             * not as efficient as calloc, but next best guess for custom malloc */
-            void* ptr = ((delegate* managed<void*, nuint, void*>)customMem.customAlloc)(
-                customMem.opaque,
-                size
-            );
-            memset(ptr, 0, (uint)size);
-            return ptr;
-        }
-
-        return calloc(1, size);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void ZSTD_customFree(void* ptr, ZSTD_customMem customMem)
-    {
-        if (ptr != null)
-        {
-            if (customMem.customFree != null)
-                ((delegate* managed<void*, void*, void>)customMem.customFree)(
-                    customMem.opaque,
-                    ptr
-                );
-            else
-                free(ptr);
-        }
-    }
-}

src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_CStream_t.cs

@@ -1,14 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/* bitStream can mix input from multiple sources.
- * A critical property of these streams is that they encode and decode in **reverse** direction.
- * So the first bit sequence you add will be the last to be read, like a LIFO stack.
- */
-public unsafe struct BIT_CStream_t
-{
-    public nuint bitContainer;
-    public uint bitPos;
-    public sbyte* startPtr;
-    public sbyte* ptr;
-    public sbyte* endPtr;
-}

src/SharpCompress/Compressors/ZStandard/Unsafe/BIT_DStream_status.cs

@@ -1,16 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public enum BIT_DStream_status
-{
-    /* fully refilled */
-    BIT_DStream_unfinished = 0,
-
-    /* still some bits left in bitstream */
-    BIT_DStream_endOfBuffer = 1,
-
-    /* bitstream entirely consumed, bit-exact */
-    BIT_DStream_completed = 2,
-
-    /* user requested more bits than present in bitstream */
-    BIT_DStream_overflow = 3,
-}