fmt

.config/dotnet-tools.json

@@ -3,11 +3,11 @@
   "isRoot": true,
   "tools": {
     "csharpier": {
-      "version": "1.2.4",
+      "version": "1.2.1",
       "commands": [
         "csharpier"
       ],
       "rollForward": false
     }
   }
-}
+}

.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/dotnetcore.yml

@@ -17,9 +17,9 @@ jobs:
     - uses: actions/checkout@v6
     - uses: actions/setup-dotnet@v5
       with:
-        dotnet-version: 10.0.x
+        dotnet-version: 8.0.x
     - run: dotnet run --project build/build.csproj
-    - uses: actions/upload-artifact@v6
+    - uses: actions/upload-artifact@v5
       with:
         name: ${{ matrix.os }}-sharpcompress.nupkg
         path: artifacts/*

.gitignore

@@ -15,6 +15,7 @@ tests/TestArchives/*/Scratch
 tests/TestArchives/*/Scratch2
 .vs
 tools
+.vscode
 .idea/
 
 .DS_Store

.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,20 @@
 <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="Microsoft.Bcl.AsyncInterfaces" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.14" />
+    <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
     <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
-    <PackageVersion Include="SimpleExec" Version="12.1.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="8.0.0" />
     <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="10.0.0" />
+    <PackageVersion Include="ZstdSharp.Port" Version="0.8.6" />
+    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="8.0.21" />
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
     <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
   </ItemGroup>

FORMATS.md

@@ -22,28 +22,11 @@
 | 7Zip (4)               | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate      | Decompress          | SevenZipArchive | N/A        | N/A           |
 
 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.
+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.
 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
-
-- 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.

README.md

@@ -1,6 +1,6 @@
 # SharpCompress
 
-SharpCompress is a compression library in pure C# for .NET Framework 4.8, .NET 8.0 and .NET 10.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0 and NET 8.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
 
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 

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,41 +116,6 @@ using (var archive = RarArchive.Open("Test.rar"))
 }
 ```
 
-### Extract solid Rar or 7Zip archives with manual progress reporting
-
-`ExtractAllEntries` only works for solid archives (Rar) or 7Zip archives. For optimal performance with these archive types, use this method:
-
-```C#
-using (var archive = RarArchive.Open("archive.rar")) // Must be solid Rar or 7Zip
-{
-    if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
-    {
-        // Calculate total size for progress reporting
-        double totalSize = archive.Entries.Where(e => !e.IsDirectory).Sum(e => e.Size);
-        long completed = 0;
-
-        using (var reader = archive.ExtractAllEntries())
-        {
-            while (reader.MoveToNextEntry())
-            {
-                if (!reader.Entry.IsDirectory)
-                {
-                    reader.WriteEntryToDirectory(@"D:\output", new ExtractionOptions()
-                    {
-                        ExtractFullPath = true,
-                        Overwrite = true
-                    });
-
-                    completed += reader.Entry.Size;
-                    double progress = completed / totalSize;
-                    Console.WriteLine($"Progress: {progress:P}");
-                }
-            }
-        }
-    }
-}
-```
-
 ### Use ReaderFactory to autodetect archive type and Open the entry stream
 
 ```C#
@@ -330,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

@@ -11,7 +11,6 @@ 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";
 
 Target(
@@ -43,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,
@@ -70,7 +61,7 @@ Target(
 Target(
     Test,
     [Build],
-    ["net10.0", "net48"],
+    ["net8.0", "net48"],
     framework =>
     {
         IEnumerable<string> GetFiles(string d)

build/build.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net10.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Bullseye" />

build/packages.lock.json

@@ -1,12 +1,12 @@
 {
   "version": 2,
   "dependencies": {
-    "net10.0": {
+    "net8.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",
@@ -16,9 +16,9 @@
       },
       "SimpleExec": {
         "type": "Direct",
-        "requested": "[12.1.0, )",
-        "resolved": "12.1.0",
-        "contentHash": "PcCSAlMcKr5yTd571MgEMoGmoSr+omwziq2crB47lKP740lrmjuBocAUXHj+Q6LR6aUDFyhszot2wbtFJTClkA=="
+        "requested": "[12.0.0, )",
+        "resolved": "12.0.0",
+        "contentHash": "ptxlWtxC8vM6Y6e3h9ZTxBBkOWnWrm/Sa1HT+2i1xcXY3Hx2hmKDZP5RShPf8Xr9D+ivlrXNy57ktzyH8kyt+Q=="
       }
     }
   }

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "10.0.100",
+    "version": "8.0.100",
     "rollForward": "latestFeature"
   }
 }

src/SharpCompress/Archives/AbstractArchive.cs

@@ -8,7 +8,7 @@ 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
 {
@@ -17,6 +17,11 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
     private bool _disposed;
     private readonly SourceStream? _sourceStream;
 
+    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; }
 
     internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
@@ -38,6 +43,12 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
 
     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)
@@ -88,12 +99,38 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
         }
     }
 
-    private void EnsureEntriesLoaded()
+    void IArchiveExtractionListener.EnsureEntriesLoaded()
     {
         _lazyEntries.EnsureFullyLoaded();
         _lazyVolumes.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 +146,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 +161,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,8 +168,13 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive
     {
         get
         {
-            EnsureEntriesLoaded();
+            ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
             return Entries.All(x => x.IsComplete);
         }
     }
+
+    public virtual bool IsMultiVolume =>
+        _sourceStream?.Files.Count > 1 || _sourceStream?.Streams.Count > 1;
+
+    public virtual bool SupportsMultiThreading => false;
 }

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -2,8 +2,6 @@ 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;
@@ -26,27 +24,6 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
-    /// <summary>
-    /// Opens an Archive for random access asynchronously
-    /// </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 = FindFactory<IArchiveFactory>(stream);
-        return await factory
-            .OpenAsync(stream, readerOptions, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     public static IWritableArchive Create(ArchiveType type)
     {
         var factory = Factory
@@ -72,22 +49,6 @@ public static class ArchiveFactory
         return Open(new FileInfo(filePath), options);
     }
 
-    /// <summary>
-    /// Opens an Archive from a filepath asynchronously.
-    /// </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>
@@ -100,24 +61,6 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
     }
 
-    /// <summary>
-    /// Opens an Archive from a FileInfo object asynchronously.
-    /// </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 = FindFactory<IArchiveFactory>(fileInfo);
-        return await factory.OpenAsync(fileInfo, options, cancellationToken).ConfigureAwait(false);
-    }
-
     /// <summary>
     /// Constructor with IEnumerable FileInfo objects, multi and split support.
     /// </summary>
@@ -144,40 +87,6 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
     }
 
-    /// <summary>
-    /// Opens a multi-part archive from files asynchronously.
-    /// </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).ConfigureAwait(false);
-        }
-
-        fileInfo.NotNull(nameof(fileInfo));
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        var factory = FindFactory<IMultiArchiveFactory>(fileInfo);
-        return await factory
-            .OpenAsync(filesArray, options, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     /// <summary>
     /// Constructor with IEnumerable FileInfo objects, multi and split support.
     /// </summary>
@@ -204,41 +113,6 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
     }
 
-    /// <summary>
-    /// Opens a multi-part archive from streams asynchronously.
-    /// </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
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        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).ConfigureAwait(false);
-        }
-
-        firstStream.NotNull(nameof(firstStream));
-        options ??= new ReaderOptions();
-
-        var factory = FindFactory<IMultiArchiveFactory>(firstStream);
-        return await factory
-            .OpenAsync(streamsArray, options, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     /// <summary>
     /// Extract to specific directory, retaining filename
     /// </summary>

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 
@@ -22,30 +20,11 @@ class AutoArchiveFactory : IArchiveFactory
         int bufferSize = ReaderOptions.DefaultBufferSize
     ) => throw new NotSupportedException();
 
-    public Task<bool> IsArchiveAsync(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
-        CancellationToken cancellationToken = default
-    ) => throw new NotSupportedException();
-
     public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
 
     public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
         ArchiveFactory.Open(stream, readerOptions);
 
-    public Task<IArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    ) => ArchiveFactory.OpenAsync(stream, readerOptions, cancellationToken);
-
     public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
         ArchiveFactory.Open(fileInfo, readerOptions);
-
-    public Task<IArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    ) => ArchiveFactory.OpenAsync(fileInfo, readerOptions, cancellationToken);
 }

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -102,70 +102,6 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         );
     }
 
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
-    }
-
     public static GZipArchive Create() => new();
 
     /// <summary>
@@ -231,28 +167,6 @@ 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) { }
 

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; }
 
@@ -39,4 +45,14 @@ public interface IArchive : IDisposable
     /// The total size of the files as uncompressed in the archive.
     /// </summary>
     long TotalUncompressSize { get; }
+
+    /// <summary>
+    /// Is the archive part of a multi-volume set.
+    /// </summary>
+    bool IsMultiVolume { get; }
+
+    /// <summary>
+    /// Does the archive support multi-threaded extraction.
+    /// </summary>
+    bool SupportsMultiThreading { get; }
 }

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -1,4 +1,3 @@
-using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -9,153 +8,127 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveEntryExtensions
 {
-    private const int BufferSize = 81920;
-
-    /// <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, 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, 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,
+            entry.WriteToFileAsync,
+            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, ct) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                await entry.WriteToAsync(fs, ct).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,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -28,34 +26,10 @@ public interface IArchiveFactory : IFactory
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(Stream stream, ReaderOptions? readerOptions = null);
 
-    /// <summary>
-    /// Opens an Archive for random access asynchronously.
-    /// </summary>
-    /// <param name="stream">An open, readable and seekable stream.</param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">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>
-    /// Opens an Archive from a FileInfo object asynchronously.
-    /// </summary>
-    /// <param name="fileInfo">the file to open.</param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    Task<IArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
 }

src/SharpCompress/Archives/IMultiArchiveFactory.cs

@@ -1,7 +1,5 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -29,34 +27,10 @@ public interface IMultiArchiveFactory : IFactory
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
 
-    /// <summary>
-    /// Opens a multi-part archive from streams asynchronously.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">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>
-    /// Opens a multi-part archive from files asynchronously.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    Task<IArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
 }

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -1,39 +0,0 @@
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.IO;
-using System.Linq;
-using SharpCompress.Common.Rar;
-using SharpCompress.Common.Rar.Headers;
-using SharpCompress.IO;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives.Rar;
-
-/// <summary>
-/// A rar part based on a FileInfo object
-/// </summary>
-internal class FileInfoRarArchiveVolume : RarVolume
-{
-    internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index)
-        : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options), index)
-    {
-        FileInfo = fileInfo;
-        FileParts = GetVolumeFileParts().ToArray().ToReadOnly();
-    }
-
-    private static ReaderOptions FixOptions(ReaderOptions options)
-    {
-        //make sure we're closing streams with fileinfo
-        options.LeaveStreamOpen = false;
-        return options;
-    }
-
-    internal ReadOnlyCollection<RarFilePart> FileParts { get; }
-
-    internal FileInfo FileInfo { get; }
-
-    internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
-        new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
-
-    internal override IEnumerable<RarFilePart> ReadFileParts() => FileParts;
-}

src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs

@@ -1,21 +0,0 @@
-using System.IO;
-using SharpCompress.Common.Rar.Headers;
-
-namespace SharpCompress.Archives.Rar;
-
-internal sealed class FileInfoRarFilePart : SeekableFilePart
-{
-    internal FileInfoRarFilePart(
-        FileInfoRarArchiveVolume volume,
-        string? password,
-        MarkHeader mh,
-        FileHeader fh,
-        FileInfo fi
-    )
-        : base(mh, fh, volume.Index, volume.Stream, password) => FileInfo = fi;
-
-    internal FileInfo FileInfo { get; }
-
-    internal override string FilePartName =>
-        "Rar File: " + FileInfo.FullName + " File Entry: " + FileHeader.FileName;
-}

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -2,8 +2,6 @@ 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;
@@ -49,9 +47,9 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     {
         sourceStream.LoadAllParts(); //request all streams
         var streams = sourceStream.Streams.ToArray();
-        var i = 0;
         if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
         {
+            var i = 0;
             sourceStream.IsVolumes = true;
             streams[1].Position = 0;
             sourceStream.Position = 0;
@@ -59,12 +57,18 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
             return sourceStream.Streams.Select(a => new StreamRarArchiveVolume(
                 a,
                 ReaderOptions,
-                i++
+                i++,
+                IsMultiVolume
             ));
         }
 
         //split mode or single file
-        return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
+        return new StreamRarArchiveVolume(
+            sourceStream,
+            ReaderOptions,
+            0,
+            IsMultiVolume
+        ).AsEnumerable();
     }
 
     protected override IReader CreateReaderForSolidExtraction()
@@ -85,8 +89,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     }
 
     public override bool IsSolid => Volumes.First().IsSolidArchive;
-
-    public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted;
+    public override bool SupportsMultiThreading => !IsMultiVolume && !IsSolid;
 
     public virtual int MinVersion => Volumes.First().MinVersion;
     public virtual int MaxVersion => Volumes.First().MaxVersion;
@@ -183,70 +186,6 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
         );
     }
 
-    /// <summary>
-    /// Opens a RarArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a RarArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a RarArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a RarArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
-    }
-
     public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
 
     public static bool IsRarFile(FileInfo fileInfo)

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)
             );
         }
 
@@ -134,4 +134,6 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             );
         }
     }
+
+    public override bool SupportsMultiThreading => Parts.Single().SupportsMultiThreading;
 }

src/SharpCompress/Archives/Rar/SeekableRarFilePart.cs

@@ -1,25 +1,29 @@
 using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
+using SharpCompress.IO;
 
 namespace SharpCompress.Archives.Rar;
 
-internal class SeekableFilePart : RarFilePart
+internal class SeekableRarFilePart : RarFilePart
 {
     private readonly Stream _stream;
     private readonly string? _password;
+    private readonly bool _isMultiVolume;
 
-    internal SeekableFilePart(
+    internal SeekableRarFilePart(
         MarkHeader mh,
         FileHeader fh,
         int index,
         Stream stream,
-        string? password
+        string? password,
+        bool isMultiVolume
     )
         : base(mh, fh, index)
     {
         _stream = stream;
         _password = password;
+        _isMultiVolume = isMultiVolume;
     }
 
     internal override Stream GetCompressedStream()
@@ -42,4 +46,7 @@ internal class SeekableFilePart : RarFilePart
     }
 
     internal override string FilePartName => "Unknown Stream - File Entry: " + FileHeader.FileName;
+
+    public override bool SupportsMultiThreading =>
+        !_isMultiVolume && _stream is SourceStream ss && ss.IsFileMode && ss.Files.Count == 1;
 }

src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs

@@ -9,11 +9,28 @@ namespace SharpCompress.Archives.Rar;
 
 internal class StreamRarArchiveVolume : RarVolume
 {
-    internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index)
-        : base(StreamingMode.Seekable, stream, options, index) { }
+    private readonly bool _isMultiVolume;
+
+    internal StreamRarArchiveVolume(
+        Stream stream,
+        ReaderOptions options,
+        int index,
+        bool isMultiVolume
+    )
+        : base(StreamingMode.Seekable, stream, options, index)
+    {
+        _isMultiVolume = isMultiVolume;
+    }
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
 
     internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
-        new SeekableFilePart(markHeader, fileHeader, Index, Stream, ReaderOptions.Password);
+        new SeekableRarFilePart(
+            markHeader,
+            fileHeader,
+            Index,
+            Stream,
+            ReaderOptions.Password,
+            _isMultiVolume
+        );
 }

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -2,8 +2,6 @@ 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.SevenZip;
 using SharpCompress.Compressors.LZMA.Utilites;
@@ -105,70 +103,6 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         );
     }
 
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
-    }
-
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
@@ -271,15 +205,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;
 
     private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
     {
         private readonly SevenZipArchive _archive;
-        private SevenZipEntry? _currentEntry;
+        private CFolder? _currentFolder;
+        private Stream? _currentStream;
+        private CFileItem? _currentItem;
 
         internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
             : base(readerOptions, ArchiveType.SevenZip) => this._archive = archive;
@@ -292,135 +226,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 non-directory entries, yield them without creating shared streams
-            // Each call to GetEntryStream() will create a fresh decompression stream
-            // to avoid state corruption issues with async operations
-            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()
-        {
-            // Create a fresh decompression stream for each file (no state sharing).
-            // However, the LZMA decoder has bugs in its async implementation that cause
-            // state corruption even on fresh streams. The SyncOnlyStream wrapper
-            // works around these bugs by forcing async operations to use sync equivalents.
-            //
-            // TODO: Fix the LZMA decoder async bugs (in LzmaStream, Decoder, OutWindow)
-            // so this wrapper is no longer necessary.
-            var entry = _currentEntry.NotNull("currentEntry is not null");
-            if (entry.IsDirectory)
-            {
-                return CreateEntryStream(Stream.Null);
-            }
-            return CreateEntryStream(new SyncOnlyStream(entry.FilePart.GetCompressedStream()));
-        }
-    }
-
-    /// <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);
-        }
+        protected override EntryStream GetEntryStream() =>
+            CreateEntryStream(
+                new ReadOnlySubStream(
+                    _currentStream.NotNull("currentStream is not null"),
+                    _currentItem?.Size ?? 0
+                )
+            );
     }
 
     private class PasswordProvider : IPasswordProvider

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -103,70 +103,6 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         );
     }
 
-    /// <summary>
-    /// Opens a TarArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a TarArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a TarArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a TarArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
-    }
-
     public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
 
     public static bool IsTarFile(FileInfo fileInfo)

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -124,70 +124,6 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         );
     }
 
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static async Task<IArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
-    }
-
     public static bool IsZipFile(
         string filePath,
         string? password = null,
@@ -263,93 +199,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
                 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, useSync: true).FirstOrDefault();
-                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static async Task<bool> IsZipFileAsync(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            if (stream is not SharpCompressStream)
-            {
-                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
-            }
-
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
-            {
-                return false;
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static async Task<bool> IsZipMultiAsync(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            if (stream is not SharpCompressStream)
-            {
-                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
-            }
-
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            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());
-                    ZipHeader? x = null;
-                    await foreach (
-                        var h in z.ReadSeekableHeader(stream).WithCancellation(cancellationToken)
-                    )
-                    {
-                        x = h;
-                        break;
-                    }
+                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
                     return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
                 }
                 else
@@ -404,9 +254,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
     {
         var vols = volumes.ToArray();
-        foreach (
-            var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream, useSync: true)
-        )
+        foreach (var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream))
         {
             if (h != null)
             {
@@ -435,7 +283,12 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 
                             yield return new ZipArchiveEntry(
                                 this,
-                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
+                                new SeekableZipFilePart(
+                                    headerFactory.NotNull(),
+                                    deh,
+                                    s,
+                                    IsMultiVolume
+                                )
                             );
                         }
                         break;
@@ -537,4 +390,6 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         ((IStreamStack)stream).StackSeek(0);
         return ZipReader.Open(stream, ReaderOptions, Entries);
     }
+
+    public override bool SupportsMultiThreading => !IsMultiVolume;
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -23,5 +23,7 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
 
     public bool IsComplete => true;
 
+    public override bool SupportsMultiThreading => Parts.Single().SupportsMultiThreading;
+
     #endregion
 }

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/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/AsyncBinaryReader.cs

@@ -1,117 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common
-{
-    public sealed class AsyncBinaryReader : IDisposable
-    {
-        private readonly Stream _stream;
-        private readonly Stream _originalStream;
-        private readonly bool _leaveOpen;
-        private readonly byte[] _buffer = new byte[8];
-        private bool _disposed;
-
-        public AsyncBinaryReader(Stream stream, bool leaveOpen = false, int bufferSize = 4096)
-        {
-            _originalStream = stream ?? throw new ArgumentNullException(nameof(stream));
-            _leaveOpen = leaveOpen;
-
-            // Use the stream directly without wrapping in BufferedStream
-            // BufferedStream uses synchronous Read internally which doesn't work with async-only streams
-            // SharpCompress uses SharpCompressStream for buffering which supports true async reads
-            _stream = stream;
-        }
-
-        public Stream BaseStream => _stream;
-
-        public async ValueTask<byte> ReadByteAsync(CancellationToken ct = default)
-        {
-            await ReadExactAsync(_buffer, 0, 1, ct).ConfigureAwait(false);
-            return _buffer[0];
-        }
-
-        public async ValueTask<ushort> ReadUInt16Async(CancellationToken ct = default)
-        {
-            await ReadExactAsync(_buffer, 0, 2, ct).ConfigureAwait(false);
-            return BinaryPrimitives.ReadUInt16LittleEndian(_buffer);
-        }
-
-        public async ValueTask<uint> ReadUInt32Async(CancellationToken ct = default)
-        {
-            await ReadExactAsync(_buffer, 0, 4, ct).ConfigureAwait(false);
-            return BinaryPrimitives.ReadUInt32LittleEndian(_buffer);
-        }
-
-        public async ValueTask<ulong> ReadUInt64Async(CancellationToken ct = default)
-        {
-            await ReadExactAsync(_buffer, 0, 8, ct).ConfigureAwait(false);
-            return BinaryPrimitives.ReadUInt64LittleEndian(_buffer);
-        }
-
-        public async ValueTask<byte[]> ReadBytesAsync(int count, CancellationToken ct = default)
-        {
-            var result = new byte[count];
-            await ReadExactAsync(result, 0, count, ct).ConfigureAwait(false);
-            return result;
-        }
-
-        private async ValueTask ReadExactAsync(
-            byte[] destination,
-            int offset,
-            int length,
-            CancellationToken ct
-        )
-        {
-            var read = 0;
-            while (read < length)
-            {
-                var n = await _stream
-                    .ReadAsync(destination, offset + read, length - read, ct)
-                    .ConfigureAwait(false);
-                if (n == 0)
-                {
-                    throw new EndOfStreamException();
-                }
-
-                read += n;
-            }
-        }
-
-        public void Dispose()
-        {
-            if (_disposed)
-            {
-                return;
-            }
-
-            _disposed = true;
-
-            // Dispose the original stream if we own it
-            if (!_leaveOpen)
-            {
-                _originalStream.Dispose();
-            }
-        }
-
-#if NET6_0_OR_GREATER
-        public async ValueTask DisposeAsync()
-        {
-            if (_disposed)
-            {
-                return;
-            }
-
-            _disposed = true;
-
-            // Dispose the original stream if we own it
-            if (!_leaveOpen)
-            {
-                await _originalStream.DisposeAsync().ConfigureAwait(false);
-            }
-        }
-#endif
-    }
-}

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/Entry.cs

@@ -87,4 +87,5 @@ public abstract class Entry : IEntry
     /// Entry file attribute.
     /// </summary>
     public virtual int? Attrib => throw new NotImplementedException();
+    public virtual bool SupportsMultiThreading => false;
 }

src/SharpCompress/Common/FilePart.cs

@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common;
 
@@ -17,7 +15,5 @@ public abstract class FilePart
     internal abstract Stream? GetRawStream();
     internal bool Skipped { get; set; }
 
-    internal virtual Task<Stream?> GetCompressedStreamAsync(
-        CancellationToken cancellationToken = default
-    ) => Task.FromResult(GetCompressedStream());
+    public virtual bool SupportsMultiThreading => false;
 }

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/IEntry.cs

@@ -21,4 +21,5 @@ public interface IEntry
     DateTime? LastModifiedTime { get; }
     long Size { get; }
     int? Attrib { get; }
+    bool SupportsMultiThreading { 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/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/Tar/Headers/TarHeader.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Buffers.Binary;
-using System.Collections.Generic;
 using System.IO;
 using System.Text;
 
@@ -10,16 +9,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 +30,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 +85,7 @@ internal sealed class TarHeader
                 0,
                 100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1)
             );
-            WriteGnuTarLongLink(output);
+            Write(output);
         }
     }
 
@@ -358,18 +241,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/Zip/Headers/DirectoryEndHeader.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -20,18 +19,6 @@ internal class DirectoryEndHeader : ZipHeader
         Comment = reader.ReadBytes(CommentLength);
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        VolumeNumber = await reader.ReadUInt16Async();
-        FirstVolumeWithDirectory = await reader.ReadUInt16Async();
-        TotalNumberOfEntriesInDisk = await reader.ReadUInt16Async();
-        TotalNumberOfEntries = await reader.ReadUInt16Async();
-        DirectorySize = await reader.ReadUInt32Async();
-        DirectoryStartOffsetRelativeToDisk = await reader.ReadUInt32Async();
-        CommentLength = await reader.ReadUInt16Async();
-        Comment = await reader.ReadBytesAsync(CommentLength);
-    }
-
     public ushort VolumeNumber { get; private set; }
 
     public ushort FirstVolumeWithDirectory { get; private set; }

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

@@ -1,6 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -32,37 +31,7 @@ internal class DirectoryEntryHeader : ZipFileEntry
         var extra = reader.ReadBytes(extraLength);
         var comment = reader.ReadBytes(commentLength);
 
-        ProcessReadData(name, extra, comment);
-    }
-
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        Version = await reader.ReadUInt16Async();
-        VersionNeededToExtract = await reader.ReadUInt16Async();
-        Flags = (HeaderFlags)await reader.ReadUInt16Async();
-        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
-        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
-        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
-        Crc = await reader.ReadUInt32Async();
-        CompressedSize = await reader.ReadUInt32Async();
-        UncompressedSize = await reader.ReadUInt32Async();
-        var nameLength = await reader.ReadUInt16Async();
-        var extraLength = await reader.ReadUInt16Async();
-        var commentLength = await reader.ReadUInt16Async();
-        DiskNumberStart = await reader.ReadUInt16Async();
-        InternalFileAttributes = await reader.ReadUInt16Async();
-        ExternalFileAttributes = await reader.ReadUInt32Async();
-        RelativeOffsetOfEntryHeader = await reader.ReadUInt32Async();
-
-        var name = await reader.ReadBytesAsync(nameLength);
-        var extra = await reader.ReadBytesAsync(extraLength);
-        var comment = await reader.ReadBytesAsync(commentLength);
-
-        ProcessReadData(name, extra, comment);
-    }
-
-    private void ProcessReadData(byte[] name, byte[] extra, byte[] comment)
-    {
+        // According to .ZIP File Format Specification
         //
         // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
         //

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

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -9,6 +8,4 @@ internal class IgnoreHeader : ZipHeader
         : base(type) { }
 
     internal override void Read(BinaryReader reader) { }
-
-    internal override ValueTask Read(AsyncBinaryReader reader) => default;
 }

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

@@ -1,12 +1,13 @@
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class LocalEntryHeader(ArchiveEncoding archiveEncoding)
-    : ZipFileEntry(ZipHeaderType.LocalEntry, archiveEncoding)
+internal class LocalEntryHeader : ZipFileEntry
 {
+    public LocalEntryHeader(ArchiveEncoding archiveEncoding)
+        : base(ZipHeaderType.LocalEntry, archiveEncoding) { }
+
     internal override void Read(BinaryReader reader)
     {
         Version = reader.ReadUInt16();
@@ -22,29 +23,7 @@ internal class LocalEntryHeader(ArchiveEncoding archiveEncoding)
         var name = reader.ReadBytes(nameLength);
         var extra = reader.ReadBytes(extraLength);
 
-        ProcessReadData(name, extra);
-    }
-
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        Version = await reader.ReadUInt16Async();
-        Flags = (HeaderFlags)await reader.ReadUInt16Async();
-        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
-        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
-        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
-        Crc = await reader.ReadUInt32Async();
-        CompressedSize = await reader.ReadUInt32Async();
-        UncompressedSize = await reader.ReadUInt32Async();
-        var nameLength = await reader.ReadUInt16Async();
-        var extraLength = await reader.ReadUInt16Async();
-        var name = await reader.ReadBytesAsync(nameLength);
-        var extra = await reader.ReadBytesAsync(extraLength);
-
-        ProcessReadData(name, extra);
-    }
-
-    private void ProcessReadData(byte[] name, byte[] extra)
-    {
+        // According to .ZIP File Format Specification
         //
         // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
         //

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

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -10,7 +9,4 @@ internal class SplitHeader : ZipHeader
         : base(ZipHeaderType.Split) { }
 
     internal override void Read(BinaryReader reader) => throw new NotImplementedException();
-
-    internal override ValueTask Read(AsyncBinaryReader reader) =>
-        throw new NotImplementedException();
 }

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

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -27,25 +26,6 @@ internal class Zip64DirectoryEndHeader : ZipHeader
         );
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        SizeOfDirectoryEndRecord = (long)await reader.ReadUInt64Async();
-        VersionMadeBy = await reader.ReadUInt16Async();
-        VersionNeededToExtract = await reader.ReadUInt16Async();
-        VolumeNumber = await reader.ReadUInt32Async();
-        FirstVolumeWithDirectory = await reader.ReadUInt32Async();
-        TotalNumberOfEntriesInDisk = (long)await reader.ReadUInt64Async();
-        TotalNumberOfEntries = (long)await reader.ReadUInt64Async();
-        DirectorySize = (long)await reader.ReadUInt64Async();
-        DirectoryStartOffsetRelativeToDisk = (long)await reader.ReadUInt64Async();
-        DataSector = await reader.ReadBytesAsync(
-            (int)(
-                SizeOfDirectoryEndRecord
-                - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
-            )
-        );
-    }
-
     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,10 +1,12 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class Zip64DirectoryEndLocatorHeader() : ZipHeader(ZipHeaderType.Zip64DirectoryEndLocator)
+internal class Zip64DirectoryEndLocatorHeader : ZipHeader
 {
+    public Zip64DirectoryEndLocatorHeader()
+        : base(ZipHeaderType.Zip64DirectoryEndLocator) { }
+
     internal override void Read(BinaryReader reader)
     {
         FirstVolumeWithDirectory = reader.ReadUInt32();
@@ -12,13 +14,6 @@ internal class Zip64DirectoryEndLocatorHeader() : ZipHeader(ZipHeaderType.Zip64D
         TotalNumberOfVolumes = reader.ReadUInt32();
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        FirstVolumeWithDirectory = await reader.ReadUInt32Async();
-        RelativeOffsetOfTheEndOfDirectoryRecord = (long)await reader.ReadUInt64Async();
-        TotalNumberOfVolumes = await reader.ReadUInt32Async();
-    }
-
     public uint FirstVolumeWithDirectory { get; private set; }
 
     public long RelativeOffsetOfTheEndOfDirectoryRecord { get; private set; }

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

@@ -2,14 +2,18 @@ using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal abstract class ZipFileEntry(ZipHeaderType type, ArchiveEncoding archiveEncoding)
-    : ZipHeader(type)
+internal abstract class ZipFileEntry : ZipHeader
 {
+    protected ZipFileEntry(ZipHeaderType type, ArchiveEncoding archiveEncoding)
+        : base(type)
+    {
+        Extra = new List<ExtraData>();
+        ArchiveEncoding = archiveEncoding;
+    }
+
     internal bool IsDirectory
     {
         get
@@ -26,7 +30,7 @@ internal abstract class ZipFileEntry(ZipHeaderType type, ArchiveEncoding archive
 
     internal Stream? PackedStream { get; set; }
 
-    internal ArchiveEncoding ArchiveEncoding { get; } = archiveEncoding;
+    internal ArchiveEncoding ArchiveEncoding { get; }
 
     internal string? Name { get; set; }
 
@@ -40,7 +44,7 @@ internal abstract class ZipFileEntry(ZipHeaderType type, ArchiveEncoding archive
 
     internal long UncompressedSize { get; set; }
 
-    internal List<ExtraData> Extra { get; set; } = new();
+    internal List<ExtraData> Extra { get; set; }
 
     public string? Password { get; set; }
 
@@ -59,24 +63,6 @@ internal abstract class ZipFileEntry(ZipHeaderType type, ArchiveEncoding archive
         return encryptionData;
     }
 
-    internal async Task<PkwareTraditionalEncryptionData> ComposeEncryptionDataAsync(
-        Stream archiveStream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (archiveStream is null)
-        {
-            throw new ArgumentNullException(nameof(archiveStream));
-        }
-
-        var buffer = new byte[12];
-        await archiveStream.ReadFullyAsync(buffer, 0, 12, cancellationToken).ConfigureAwait(false);
-
-        var encryptionData = PkwareTraditionalEncryptionData.ForRead(Password!, this, buffer);
-
-        return encryptionData;
-    }
-
     internal WinzipAesEncryptionData? WinzipAesEncryptionData { get; set; }
 
     /// <summary>

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

@@ -1,14 +1,18 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal abstract class ZipHeader(ZipHeaderType type)
+internal abstract class ZipHeader
 {
-    internal ZipHeaderType ZipHeaderType { get; } = type;
+    protected ZipHeader(ZipHeaderType type)
+    {
+        ZipHeaderType = type;
+        HasData = true;
+    }
+
+    internal ZipHeaderType ZipHeaderType { get; }
 
     internal abstract void Read(BinaryReader reader);
-    internal abstract ValueTask Read(AsyncBinaryReader reader);
 
-    internal bool HasData { get; set; } = true;
+    internal bool HasData { get; set; }
 }

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -1,5 +1,6 @@
 using System.IO;
 using SharpCompress.Common.Zip.Headers;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
@@ -7,13 +8,19 @@ internal class SeekableZipFilePart : ZipFilePart
 {
     private bool _isLocalHeaderLoaded;
     private readonly SeekableZipHeaderFactory _headerFactory;
+    private readonly bool _isMultiVolume;
 
     internal SeekableZipFilePart(
         SeekableZipHeaderFactory headerFactory,
         DirectoryEntryHeader header,
-        Stream stream
+        Stream stream,
+        bool isMultiVolume
     )
-        : base(header, stream) => _headerFactory = headerFactory;
+        : base(header, stream)
+    {
+        _headerFactory = headerFactory;
+        _isMultiVolume = isMultiVolume;
+    }
 
     internal override Stream GetCompressedStream()
     {
@@ -30,8 +37,20 @@ internal class SeekableZipFilePart : ZipFilePart
 
     protected override Stream CreateBaseStream()
     {
+        if (!_isMultiVolume && BaseStream is SourceStream ss)
+        {
+            if (ss.IsFileMode && ss.Files.Count == 1)
+            {
+                var fileStream = ss.CurrentFile.OpenRead();
+                fileStream.Position = Header.DataStartPosition.NotNull();
+                return fileStream;
+            }
+        }
         BaseStream.Position = Header.DataStartPosition.NotNull();
 
         return BaseStream;
     }
+
+    public override bool SupportsMultiThreading =>
+        !_isMultiVolume && BaseStream is SourceStream ss && ss.IsFileMode && ss.Files.Count == 1;
 }

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -19,74 +18,7 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
     internal SeekableZipHeaderFactory(string? password, ArchiveEncoding archiveEncoding)
         : base(StreamingMode.Seekable, password, archiveEncoding) { }
 
-    internal async IAsyncEnumerable<ZipHeader> ReadSeekableHeader(Stream stream)
-    {
-        var reader = new AsyncBinaryReader(stream);
-
-        await SeekBackToHeader(stream, reader);
-
-        var eocd_location = stream.Position;
-        var entry = new DirectoryEndHeader();
-        await entry.Read(reader);
-
-        if (entry.IsZip64)
-        {
-            _zip64 = true;
-
-            // ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR should be before the EOCD
-            stream.Seek(eocd_location - ZIP64_EOCD_LENGTH - 4, SeekOrigin.Begin);
-            uint zip64_locator = await reader.ReadUInt32Async();
-            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.Read(reader);
-
-            stream.Seek(zip64Locator.RelativeOffsetOfTheEndOfDirectoryRecord, SeekOrigin.Begin);
-            var zip64Signature = await reader.ReadUInt32Async();
-            if (zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
-            {
-                throw new ArchiveException("Failed to locate the Zip64 Header");
-            }
-
-            var zip64Entry = new Zip64DirectoryEndHeader();
-            await zip64Entry.Read(reader);
-            stream.Seek(zip64Entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
-        }
-        else
-        {
-            stream.Seek(entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
-        }
-
-        var position = stream.Position;
-        while (true)
-        {
-            stream.Position = position;
-            var signature = await reader.ReadUInt32Async();
-            var nextHeader = await ReadHeader(signature, reader, _zip64);
-            position = stream.Position;
-
-            if (nextHeader is null)
-            {
-                yield break;
-            }
-
-            if (nextHeader is DirectoryEntryHeader entryHeader)
-            {
-                //entry could be zero bytes so we need to know that.
-                entryHeader.HasData = entryHeader.CompressedSize != 0;
-                yield return entryHeader;
-            }
-            else if (nextHeader is DirectoryEndHeader endHeader)
-            {
-                yield return endHeader;
-            }
-        }
-    }
-
-    internal IEnumerable<ZipHeader> ReadSeekableHeader(Stream stream, bool useSync)
+    internal IEnumerable<ZipHeader> ReadSeekableHeader(Stream stream)
     {
         var reader = new BinaryReader(stream);
 
@@ -166,45 +98,6 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
         return true;
     }
 
-    private static async ValueTask SeekBackToHeader(Stream stream, AsyncBinaryReader reader)
-    {
-        // Minimum EOCD length
-        if (stream.Length < MINIMUM_EOCD_LENGTH)
-        {
-            throw new ArchiveException(
-                "Could not find Zip file Directory at the end of the file. File may be corrupted."
-            );
-        }
-
-        var len =
-            stream.Length < MAX_SEARCH_LENGTH_FOR_EOCD
-                ? (int)stream.Length
-                : MAX_SEARCH_LENGTH_FOR_EOCD;
-        // We search for marker in reverse to find the first occurance
-        byte[] needle = { 0x06, 0x05, 0x4b, 0x50 };
-
-        stream.Seek(-len, SeekOrigin.End);
-
-        var seek = await reader.ReadBytesAsync(len);
-
-        // Search in reverse
-        Array.Reverse(seek);
-
-        // don't exclude the minimum eocd region, otherwise you fail to locate the header in empty zip files
-        var max_search_area = len; // - MINIMUM_EOCD_LENGTH;
-
-        for (var pos_from_end = 0; pos_from_end < max_search_area; ++pos_from_end)
-        {
-            if (IsMatch(seek, pos_from_end, needle))
-            {
-                stream.Seek(-pos_from_end, SeekOrigin.End);
-                return;
-            }
-        }
-
-        throw new ArchiveException("Failed to locate the Zip Header");
-    }
-
     private static void SeekBackToHeader(Stream stream, BinaryReader reader)
     {
         // Minimum EOCD length

src/SharpCompress/Common/Zip/StreamingZipFilePart.cs

@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
@@ -33,28 +31,6 @@ internal sealed class StreamingZipFilePart : ZipFilePart
         return _decompressionStream;
     }
 
-    internal override async Task<Stream?> GetCompressedStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (!Header.HasData)
-        {
-            return Stream.Null;
-        }
-        _decompressionStream = await CreateDecompressionStreamAsync(
-                await GetCryptoStreamAsync(CreateBaseStream(), cancellationToken)
-                    .ConfigureAwait(false),
-                Header.CompressionMethod,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
-        if (LeaveStreamOpen)
-        {
-            return SharpCompressStream.Create(_decompressionStream, leaveOpen: true);
-        }
-        return _decompressionStream;
-    }
-
     internal BinaryReader FixStreamedFileLocation(ref SharpCompressStream rewindableStream)
     {
         if (Header.IsDirectory)

src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Buffers.Binary;
 using System.Security.Cryptography;
-using System.Text;
 
 namespace SharpCompress.Common.Zip;
 
@@ -20,24 +19,8 @@ internal class WinzipAesEncryptionData
     {
         _keySize = keySize;
 
-#if NETFRAMEWORK
+#if NETFRAMEWORK || NETSTANDARD2_0
         var rfc2898 = new Rfc2898DeriveBytes(password, salt, RFC2898_ITERATIONS);
-        KeyBytes = rfc2898.GetBytes(KeySizeInBytes);
-        IvBytes = rfc2898.GetBytes(KeySizeInBytes);
-        var generatedVerifyValue = rfc2898.GetBytes(2);
-#elif NET10_0_OR_GREATER
-        var derivedKeySize = (KeySizeInBytes * 2) + 2;
-        var passwordBytes = Encoding.UTF8.GetBytes(password);
-        var derivedKey = Rfc2898DeriveBytes.Pbkdf2(
-            passwordBytes,
-            salt,
-            RFC2898_ITERATIONS,
-            HashAlgorithmName.SHA1,
-            derivedKeySize
-        );
-        KeyBytes = derivedKey.AsSpan(0, KeySizeInBytes).ToArray();
-        IvBytes = derivedKey.AsSpan(KeySizeInBytes, KeySizeInBytes).ToArray();
-        var generatedVerifyValue = derivedKey.AsSpan((KeySizeInBytes * 2), 2).ToArray();
 #else
         var rfc2898 = new Rfc2898DeriveBytes(
             password,
@@ -45,10 +28,11 @@ internal class WinzipAesEncryptionData
             RFC2898_ITERATIONS,
             HashAlgorithmName.SHA1
         );
-        KeyBytes = rfc2898.GetBytes(KeySizeInBytes);
+#endif
+
+        KeyBytes = rfc2898.GetBytes(KeySizeInBytes); // 16 or 24 or 32 ???
         IvBytes = rfc2898.GetBytes(KeySizeInBytes);
         var generatedVerifyValue = rfc2898.GetBytes(2);
-#endif
 
         var verify = BinaryPrimitives.ReadInt16LittleEndian(passwordVerifyValue);
         var generated = BinaryPrimitives.ReadInt16LittleEndian(generatedVerifyValue);

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -2,8 +2,6 @@ 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.Compressors;
 using SharpCompress.Compressors.BZip2;
@@ -15,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;
 
@@ -266,220 +264,4 @@ internal abstract class ZipFilePart : FilePart
         }
         return plainStream;
     }
-
-    internal override async Task<Stream?> GetCompressedStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (!Header.HasData)
-        {
-            return Stream.Null;
-        }
-        var decompressionStream = await CreateDecompressionStreamAsync(
-                await GetCryptoStreamAsync(CreateBaseStream(), cancellationToken)
-                    .ConfigureAwait(false),
-                Header.CompressionMethod,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
-        if (LeaveStreamOpen)
-        {
-            return SharpCompressStream.Create(decompressionStream, leaveOpen: true);
-        }
-        return decompressionStream;
-    }
-
-    protected async Task<Stream> GetCryptoStreamAsync(
-        Stream plainStream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var isFileEncrypted = FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted);
-
-        if (Header.CompressedSize == 0 && isFileEncrypted)
-        {
-            throw new NotSupportedException("Cannot encrypt file with unknown size at start.");
-        }
-
-        if (
-            (
-                Header.CompressedSize == 0
-                && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)
-            ) || Header.IsZip64
-        )
-        {
-            plainStream = SharpCompressStream.Create(plainStream, leaveOpen: true); //make sure AES doesn't close
-        }
-        else
-        {
-            plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
-        }
-
-        if (isFileEncrypted)
-        {
-            switch (Header.CompressionMethod)
-            {
-                case ZipCompressionMethod.None:
-                case ZipCompressionMethod.Shrink:
-                case ZipCompressionMethod.Reduce1:
-                case ZipCompressionMethod.Reduce2:
-                case ZipCompressionMethod.Reduce3:
-                case ZipCompressionMethod.Reduce4:
-                case ZipCompressionMethod.Deflate:
-                case ZipCompressionMethod.Deflate64:
-                case ZipCompressionMethod.BZip2:
-                case ZipCompressionMethod.LZMA:
-                case ZipCompressionMethod.PPMd:
-                {
-                    return new PkwareTraditionalCryptoStream(
-                        plainStream,
-                        await Header
-                            .ComposeEncryptionDataAsync(plainStream, cancellationToken)
-                            .ConfigureAwait(false),
-                        CryptoMode.Decrypt
-                    );
-                }
-
-                case ZipCompressionMethod.WinzipAes:
-                {
-                    if (Header.WinzipAesEncryptionData != null)
-                    {
-                        return new WinzipAesCryptoStream(
-                            plainStream,
-                            Header.WinzipAesEncryptionData,
-                            Header.CompressedSize - 10
-                        );
-                    }
-                    return plainStream;
-                }
-
-                default:
-                {
-                    throw new InvalidOperationException("Header.CompressionMethod is invalid");
-                }
-            }
-        }
-        return plainStream;
-    }
-
-    protected async Task<Stream> CreateDecompressionStreamAsync(
-        Stream stream,
-        ZipCompressionMethod method,
-        CancellationToken cancellationToken = default
-    )
-    {
-        switch (method)
-        {
-            case ZipCompressionMethod.None:
-            {
-                if (Header.CompressedSize is 0)
-                {
-                    return new DataDescriptorStream(stream);
-                }
-
-                return stream;
-            }
-            case ZipCompressionMethod.Shrink:
-            {
-                return new ShrinkStream(
-                    stream,
-                    CompressionMode.Decompress,
-                    Header.CompressedSize,
-                    Header.UncompressedSize
-                );
-            }
-            case ZipCompressionMethod.Reduce1:
-            {
-                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 1);
-            }
-            case ZipCompressionMethod.Reduce2:
-            {
-                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 2);
-            }
-            case ZipCompressionMethod.Reduce3:
-            {
-                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 3);
-            }
-            case ZipCompressionMethod.Reduce4:
-            {
-                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 4);
-            }
-            case ZipCompressionMethod.Explode:
-            {
-                return new ExplodeStream(
-                    stream,
-                    Header.CompressedSize,
-                    Header.UncompressedSize,
-                    Header.Flags
-                );
-            }
-
-            case ZipCompressionMethod.Deflate:
-            {
-                return new DeflateStream(stream, CompressionMode.Decompress);
-            }
-            case ZipCompressionMethod.Deflate64:
-            {
-                return new Deflate64Stream(stream, CompressionMode.Decompress);
-            }
-            case ZipCompressionMethod.BZip2:
-            {
-                return new BZip2Stream(stream, CompressionMode.Decompress, false);
-            }
-            case ZipCompressionMethod.LZMA:
-            {
-                if (FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted))
-                {
-                    throw new NotSupportedException("LZMA with pkware encryption.");
-                }
-                var buffer = new byte[4];
-                await stream.ReadFullyAsync(buffer, 0, 4, cancellationToken).ConfigureAwait(false);
-                var version = BinaryPrimitives.ReadUInt16LittleEndian(buffer.AsSpan(0, 2));
-                var propsSize = BinaryPrimitives.ReadUInt16LittleEndian(buffer.AsSpan(2, 2));
-                var props = new byte[propsSize];
-                await stream
-                    .ReadFullyAsync(props, 0, propsSize, cancellationToken)
-                    .ConfigureAwait(false);
-                return new LzmaStream(
-                    props,
-                    stream,
-                    Header.CompressedSize > 0 ? Header.CompressedSize - 4 - props.Length : -1,
-                    FlagUtility.HasFlag(Header.Flags, HeaderFlags.Bit1)
-                        ? -1
-                        : Header.UncompressedSize
-                );
-            }
-            case ZipCompressionMethod.Xz:
-            {
-                return new XZStream(stream);
-            }
-            case ZipCompressionMethod.ZStandard:
-            {
-                return new DecompressionStream(stream);
-            }
-            case ZipCompressionMethod.PPMd:
-            {
-                var props = new byte[2];
-                await stream.ReadFullyAsync(props, 0, 2, cancellationToken).ConfigureAwait(false);
-                return new PpmdStream(new PpmdProperties(props), stream, false);
-            }
-            case ZipCompressionMethod.WinzipAes:
-            {
-                var data = Header.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
-                if (data is null)
-                {
-                    throw new InvalidFormatException("No Winzip AES extra data found.");
-                }
-                if (data.Length != 7)
-                {
-                    throw new InvalidFormatException("Winzip data length is not 7.");
-                }
-                throw new NotSupportedException("WinzipAes isn't supported for streaming");
-            }
-            default:
-            {
-                throw new NotSupportedException("CompressionMethod: " + Header.CompressionMethod);
-            }
-        }
-    }
 }

src/SharpCompress/Common/Zip/ZipHeaderFactory.cs

@@ -1,7 +1,6 @@
 using System;
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -35,82 +34,6 @@ internal class ZipHeaderFactory
         _archiveEncoding = archiveEncoding;
     }
 
-    protected async ValueTask<ZipHeader?> ReadHeader(
-        uint headerBytes,
-        AsyncBinaryReader reader,
-        bool zip64 = false
-    )
-    {
-        switch (headerBytes)
-        {
-            case ENTRY_HEADER_BYTES:
-            {
-                var entryHeader = new LocalEntryHeader(_archiveEncoding);
-                await entryHeader.Read(reader);
-                LoadHeader(entryHeader, reader.BaseStream);
-
-                _lastEntryHeader = entryHeader;
-                return entryHeader;
-            }
-            case DIRECTORY_START_HEADER_BYTES:
-            {
-                var entry = new DirectoryEntryHeader(_archiveEncoding);
-                await entry.Read(reader);
-                return entry;
-            }
-            case POST_DATA_DESCRIPTOR:
-            {
-                if (
-                    _lastEntryHeader != null
-                    && FlagUtility.HasFlag(
-                        _lastEntryHeader.NotNull().Flags,
-                        HeaderFlags.UsePostDataDescriptor
-                    )
-                )
-                {
-                    _lastEntryHeader.Crc = await reader.ReadUInt32Async();
-                    _lastEntryHeader.CompressedSize = zip64
-                        ? (long)await reader.ReadUInt64Async()
-                        : await reader.ReadUInt32Async();
-                    _lastEntryHeader.UncompressedSize = zip64
-                        ? (long)await reader.ReadUInt64Async()
-                        : await reader.ReadUInt32Async();
-                }
-                else
-                {
-                    await reader.ReadBytesAsync(zip64 ? 20 : 12);
-                }
-                return null;
-            }
-            case DIGITAL_SIGNATURE:
-                return null;
-            case DIRECTORY_END_HEADER_BYTES:
-            {
-                var entry = new DirectoryEndHeader();
-                await entry.Read(reader);
-                return entry;
-            }
-            case SPLIT_ARCHIVE_HEADER_BYTES:
-            {
-                return new SplitHeader();
-            }
-            case ZIP64_END_OF_CENTRAL_DIRECTORY:
-            {
-                var entry = new Zip64DirectoryEndHeader();
-                await entry.Read(reader);
-                return entry;
-            }
-            case ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR:
-            {
-                var entry = new Zip64DirectoryEndLocatorHeader();
-                await entry.Read(reader);
-                return entry;
-            }
-            default:
-                return null;
-        }
-    }
-
     protected ZipHeader? ReadHeader(uint headerBytes, BinaryReader reader, bool zip64 = false)
     {
         switch (headerBytes)

src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs

@@ -544,12 +544,6 @@ internal sealed class CBZip2OutputStream : Stream, IStreamStack
 
     private void EndBlock()
     {
-        // Skip block processing for empty input (no data written)
-        if (last < 0)
-        {
-            return;
-        }
-
         blockCRC = mCrc.GetFinalCRC();
         combinedCRC = (combinedCRC << 1) | (int)(((uint)combinedCRC) >> 31);
         combinedCRC ^= blockCRC;

src/SharpCompress/Compressors/LZMA/LzmaStream.cs

@@ -428,9 +428,7 @@ public class LzmaStream : Stream, IStreamStack
     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++;
 
@@ -457,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;
 
@@ -473,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++;
@@ -501,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;
         }

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();
@@ -52,10 +62,6 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
         base.Dispose(disposing);
         if (disposing)
         {
-#if DEBUG_STREAMS
-            this.DebugDispose(typeof(MultiVolumeReadOnlyStream));
-#endif
-
             if (filePartEnumerator != null)
             {
                 filePartEnumerator.Dispose();
@@ -71,7 +77,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 +137,12 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
                 break;
             }
         }
+        currentPartTotalReadBytes += totalRead;
+        currentEntryTotalReadBytes += totalRead;
+        streamListener.FireCompressedBytesRead(
+            currentPartTotalReadBytes,
+            currentEntryTotalReadBytes
+        );
         return totalRead;
     }
 
@@ -182,6 +202,12 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
                 break;
             }
         }
+        currentPartTotalReadBytes += totalRead;
+        currentEntryTotalReadBytes += totalRead;
+        streamListener.FireCompressedBytesRead(
+            currentPartTotalReadBytes,
+            currentEntryTotalReadBytes
+        );
         return totalRead;
     }
 
@@ -240,6 +266,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

@@ -82,9 +82,6 @@ internal class RarStream : Stream, IStreamStack
         {
             if (disposing)
             {
-#if DEBUG_STREAMS
-                this.DebugDispose(typeof(RarStream));
-#endif
                 ArrayPool<byte>.Shared.Return(this.tmpBuffer);
                 this.tmpBuffer = null;
             }

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,
-}

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

@@ -1,13 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/*-********************************************
- *  bitStream decoding API (read backward)
- **********************************************/
-public unsafe struct BIT_DStream_t
-{
-    public nuint bitContainer;
-    public uint bitsConsumed;
-    public sbyte* ptr;
-    public sbyte* start;
-    public sbyte* limitPtr;
-}

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

@@ -1,60 +0,0 @@
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using static SharpCompress.Compressors.ZStandard.UnsafeHelper;
-
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public static unsafe partial class Methods
-{
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint ZSTD_countTrailingZeros32(uint val)
-    {
-        assert(val != 0);
-        return (uint)BitOperations.TrailingZeroCount(val);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint ZSTD_countLeadingZeros32(uint val)
-    {
-        assert(val != 0);
-        return (uint)BitOperations.LeadingZeroCount(val);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint ZSTD_countTrailingZeros64(ulong val)
-    {
-        assert(val != 0);
-        return (uint)BitOperations.TrailingZeroCount(val);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint ZSTD_countLeadingZeros64(ulong val)
-    {
-        assert(val != 0);
-        return (uint)BitOperations.LeadingZeroCount(val);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint ZSTD_NbCommonBytes(nuint val)
-    {
-        assert(val != 0);
-        if (BitConverter.IsLittleEndian)
-        {
-            return MEM_64bits
-                ? (uint)BitOperations.TrailingZeroCount(val) >> 3
-                : (uint)BitOperations.TrailingZeroCount((uint)val) >> 3;
-        }
-
-        return MEM_64bits
-            ? (uint)BitOperations.LeadingZeroCount(val) >> 3
-            : (uint)BitOperations.LeadingZeroCount((uint)val) >> 3;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint ZSTD_highbit32(uint val)
-    {
-        assert(val != 0);
-        return (uint)BitOperations.Log2(val);
-    }
-}

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

@@ -1,739 +0,0 @@
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using static SharpCompress.Compressors.ZStandard.UnsafeHelper;
-#if NETCOREAPP3_0_OR_GREATER
-using System.Runtime.Intrinsics.X86;
-#endif
-
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public static unsafe partial class Methods
-{
-#if NET7_0_OR_GREATER
-    private static ReadOnlySpan<uint> Span_BIT_mask =>
-        new uint[32]
-        {
-            0,
-            1,
-            3,
-            7,
-            0xF,
-            0x1F,
-            0x3F,
-            0x7F,
-            0xFF,
-            0x1FF,
-            0x3FF,
-            0x7FF,
-            0xFFF,
-            0x1FFF,
-            0x3FFF,
-            0x7FFF,
-            0xFFFF,
-            0x1FFFF,
-            0x3FFFF,
-            0x7FFFF,
-            0xFFFFF,
-            0x1FFFFF,
-            0x3FFFFF,
-            0x7FFFFF,
-            0xFFFFFF,
-            0x1FFFFFF,
-            0x3FFFFFF,
-            0x7FFFFFF,
-            0xFFFFFFF,
-            0x1FFFFFFF,
-            0x3FFFFFFF,
-            0x7FFFFFFF,
-        };
-    private static uint* BIT_mask =>
-        (uint*)
-            System.Runtime.CompilerServices.Unsafe.AsPointer(
-                ref MemoryMarshal.GetReference(Span_BIT_mask)
-            );
-#else
-
-    private static readonly uint* BIT_mask = GetArrayPointer(
-        new uint[32]
-        {
-            0,
-            1,
-            3,
-            7,
-            0xF,
-            0x1F,
-            0x3F,
-            0x7F,
-            0xFF,
-            0x1FF,
-            0x3FF,
-            0x7FF,
-            0xFFF,
-            0x1FFF,
-            0x3FFF,
-            0x7FFF,
-            0xFFFF,
-            0x1FFFF,
-            0x3FFFF,
-            0x7FFFF,
-            0xFFFFF,
-            0x1FFFFF,
-            0x3FFFFF,
-            0x7FFFFF,
-            0xFFFFFF,
-            0x1FFFFFF,
-            0x3FFFFFF,
-            0x7FFFFFF,
-            0xFFFFFFF,
-            0x1FFFFFFF,
-            0x3FFFFFFF,
-            0x7FFFFFFF,
-        }
-    );
-#endif
-    /*-**************************************************************
-     *  bitStream encoding
-     ****************************************************************/
-    /*! BIT_initCStream() :
-     *  `dstCapacity` must be > sizeof(size_t)
-     *  @return : 0 if success,
-     *            otherwise an error code (can be tested using ERR_isError()) */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_initCStream(ref BIT_CStream_t bitC, void* startPtr, nuint dstCapacity)
-    {
-        bitC.bitContainer = 0;
-        bitC.bitPos = 0;
-        bitC.startPtr = (sbyte*)startPtr;
-        bitC.ptr = bitC.startPtr;
-        bitC.endPtr = bitC.startPtr + dstCapacity - sizeof(nuint);
-        if (dstCapacity <= (nuint)sizeof(nuint))
-            return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_dstSize_tooSmall));
-        return 0;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_getLowerBits(nuint bitContainer, uint nbBits)
-    {
-        assert(nbBits < sizeof(uint) * 32 / sizeof(uint));
-#if NETCOREAPP3_1_OR_GREATER
-        if (Bmi2.X64.IsSupported)
-        {
-            return (nuint)Bmi2.X64.ZeroHighBits(bitContainer, nbBits);
-        }
-
-        if (Bmi2.IsSupported)
-        {
-            return Bmi2.ZeroHighBits((uint)bitContainer, nbBits);
-        }
-#endif
-
-        return bitContainer & BIT_mask[nbBits];
-    }
-
-    /*! BIT_addBits() :
-     *  can add up to 31 bits into `bitC`.
-     *  Note : does not check for register overflow ! */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void BIT_addBits(
-        ref nuint bitC_bitContainer,
-        ref uint bitC_bitPos,
-        nuint value,
-        uint nbBits
-    )
-    {
-        assert(nbBits < sizeof(uint) * 32 / sizeof(uint));
-        assert(nbBits + bitC_bitPos < (uint)(sizeof(nuint) * 8));
-        bitC_bitContainer |= BIT_getLowerBits(value, nbBits) << (int)bitC_bitPos;
-        bitC_bitPos += nbBits;
-    }
-
-    /*! BIT_addBitsFast() :
-     *  works only if `value` is _clean_,
-     *  meaning all high bits above nbBits are 0 */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void BIT_addBitsFast(
-        ref nuint bitC_bitContainer,
-        ref uint bitC_bitPos,
-        nuint value,
-        uint nbBits
-    )
-    {
-        assert(value >> (int)nbBits == 0);
-        assert(nbBits + bitC_bitPos < (uint)(sizeof(nuint) * 8));
-        bitC_bitContainer |= value << (int)bitC_bitPos;
-        bitC_bitPos += nbBits;
-    }
-
-    /*! BIT_flushBitsFast() :
-     *  assumption : bitContainer has not overflowed
-     *  unsafe version; does not check buffer overflow */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void BIT_flushBitsFast(
-        ref nuint bitC_bitContainer,
-        ref uint bitC_bitPos,
-        ref sbyte* bitC_ptr,
-        sbyte* bitC_endPtr
-    )
-    {
-        nuint nbBytes = bitC_bitPos >> 3;
-        assert(bitC_bitPos < (uint)(sizeof(nuint) * 8));
-        assert(bitC_ptr <= bitC_endPtr);
-        MEM_writeLEST(bitC_ptr, bitC_bitContainer);
-        bitC_ptr += nbBytes;
-        bitC_bitPos &= 7;
-        bitC_bitContainer >>= (int)(nbBytes * 8);
-    }
-
-    /*! BIT_flushBits() :
-     *  assumption : bitContainer has not overflowed
-     *  safe version; check for buffer overflow, and prevents it.
-     *  note : does not signal buffer overflow.
-     *  overflow will be revealed later on using BIT_closeCStream() */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void BIT_flushBits(
-        ref nuint bitC_bitContainer,
-        ref uint bitC_bitPos,
-        ref sbyte* bitC_ptr,
-        sbyte* bitC_endPtr
-    )
-    {
-        nuint nbBytes = bitC_bitPos >> 3;
-        assert(bitC_bitPos < (uint)(sizeof(nuint) * 8));
-        assert(bitC_ptr <= bitC_endPtr);
-        MEM_writeLEST(bitC_ptr, bitC_bitContainer);
-        bitC_ptr += nbBytes;
-        if (bitC_ptr > bitC_endPtr)
-            bitC_ptr = bitC_endPtr;
-        bitC_bitPos &= 7;
-        bitC_bitContainer >>= (int)(nbBytes * 8);
-    }
-
-    /*! BIT_closeCStream() :
-     *  @return : size of CStream, in bytes,
-     *            or 0 if it could not fit into dstBuffer */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_closeCStream(
-        ref nuint bitC_bitContainer,
-        ref uint bitC_bitPos,
-        sbyte* bitC_ptr,
-        sbyte* bitC_endPtr,
-        sbyte* bitC_startPtr
-    )
-    {
-        BIT_addBitsFast(ref bitC_bitContainer, ref bitC_bitPos, 1, 1);
-        BIT_flushBits(ref bitC_bitContainer, ref bitC_bitPos, ref bitC_ptr, bitC_endPtr);
-        if (bitC_ptr >= bitC_endPtr)
-            return 0;
-        return (nuint)(bitC_ptr - bitC_startPtr) + (nuint)(bitC_bitPos > 0 ? 1 : 0);
-    }
-
-    /*-********************************************************
-     *  bitStream decoding
-     **********************************************************/
-    /*! BIT_initDStream() :
-     *  Initialize a BIT_DStream_t.
-     * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
-     * `srcSize` must be the *exact* size of the bitStream, in bytes.
-     * @return : size of stream (== srcSize), or an errorCode if a problem is detected
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_initDStream(BIT_DStream_t* bitD, void* srcBuffer, nuint srcSize)
-    {
-        if (srcSize < 1)
-        {
-            *bitD = new BIT_DStream_t();
-            return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong));
-        }
-
-        bitD->start = (sbyte*)srcBuffer;
-        bitD->limitPtr = bitD->start + sizeof(nuint);
-        if (srcSize >= (nuint)sizeof(nuint))
-        {
-            bitD->ptr = (sbyte*)srcBuffer + srcSize - sizeof(nuint);
-            bitD->bitContainer = MEM_readLEST(bitD->ptr);
-            {
-                byte lastByte = ((byte*)srcBuffer)[srcSize - 1];
-                bitD->bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0;
-                if (lastByte == 0)
-                    return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC));
-            }
-        }
-        else
-        {
-            bitD->ptr = bitD->start;
-            bitD->bitContainer = *(byte*)bitD->start;
-            switch (srcSize)
-            {
-                case 7:
-                    bitD->bitContainer += (nuint)((byte*)srcBuffer)[6] << sizeof(nuint) * 8 - 16;
-                    goto case 6;
-                case 6:
-                    bitD->bitContainer += (nuint)((byte*)srcBuffer)[5] << sizeof(nuint) * 8 - 24;
-                    goto case 5;
-                case 5:
-                    bitD->bitContainer += (nuint)((byte*)srcBuffer)[4] << sizeof(nuint) * 8 - 32;
-                    goto case 4;
-                case 4:
-                    bitD->bitContainer += (nuint)((byte*)srcBuffer)[3] << 24;
-                    goto case 3;
-                case 3:
-                    bitD->bitContainer += (nuint)((byte*)srcBuffer)[2] << 16;
-                    goto case 2;
-                case 2:
-                    bitD->bitContainer += (nuint)((byte*)srcBuffer)[1] << 8;
-                    goto default;
-                default:
-                    break;
-            }
-
-            {
-                byte lastByte = ((byte*)srcBuffer)[srcSize - 1];
-                bitD->bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0;
-                if (lastByte == 0)
-                    return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected));
-            }
-
-            bitD->bitsConsumed += (uint)((nuint)sizeof(nuint) - srcSize) * 8;
-        }
-
-        return srcSize;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_getUpperBits(nuint bitContainer, uint start)
-    {
-        return bitContainer >> (int)start;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_getMiddleBits(nuint bitContainer, uint start, uint nbBits)
-    {
-        uint regMask = (uint)(sizeof(nuint) * 8 - 1);
-        assert(nbBits < sizeof(uint) * 32 / sizeof(uint));
-#if NETCOREAPP3_1_OR_GREATER
-        if (Bmi2.X64.IsSupported)
-        {
-            return (nuint)Bmi2.X64.ZeroHighBits(bitContainer >> (int)(start & regMask), nbBits);
-        }
-
-        if (Bmi2.IsSupported)
-        {
-            return Bmi2.ZeroHighBits((uint)(bitContainer >> (int)(start & regMask)), nbBits);
-        }
-#endif
-
-        return (nuint)(bitContainer >> (int)(start & regMask) & ((ulong)1 << (int)nbBits) - 1);
-    }
-
-    /*! BIT_lookBits() :
-     *  Provides next n bits from local register.
-     *  local register is not modified.
-     *  On 32-bits, maxNbBits==24.
-     *  On 64-bits, maxNbBits==56.
-     * @return : value extracted */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_lookBits(BIT_DStream_t* bitD, uint nbBits)
-    {
-        return BIT_getMiddleBits(
-            bitD->bitContainer,
-            (uint)(sizeof(nuint) * 8) - bitD->bitsConsumed - nbBits,
-            nbBits
-        );
-    }
-
-    /*! BIT_lookBitsFast() :
-     *  unsafe version; only works if nbBits >= 1 */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_lookBitsFast(BIT_DStream_t* bitD, uint nbBits)
-    {
-        uint regMask = (uint)(sizeof(nuint) * 8 - 1);
-        assert(nbBits >= 1);
-        return bitD->bitContainer
-            << (int)(bitD->bitsConsumed & regMask)
-            >> (int)(regMask + 1 - nbBits & regMask);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void BIT_skipBits(BIT_DStream_t* bitD, uint nbBits)
-    {
-        bitD->bitsConsumed += nbBits;
-    }
-
-    /*! BIT_readBits() :
-     *  Read (consume) next n bits from local register and update.
-     *  Pay attention to not read more than nbBits contained into local register.
-     * @return : extracted value. */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_readBits(BIT_DStream_t* bitD, uint nbBits)
-    {
-        nuint value = BIT_lookBits(bitD, nbBits);
-        BIT_skipBits(bitD, nbBits);
-        return value;
-    }
-
-    /*! BIT_readBitsFast() :
-     *  unsafe version; only works if nbBits >= 1 */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_readBitsFast(BIT_DStream_t* bitD, uint nbBits)
-    {
-        nuint value = BIT_lookBitsFast(bitD, nbBits);
-        assert(nbBits >= 1);
-        BIT_skipBits(bitD, nbBits);
-        return value;
-    }
-
-    /*! BIT_reloadDStream_internal() :
-     *  Simple variant of BIT_reloadDStream(), with two conditions:
-     *  1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8
-     *  2. look window is valid after shifted down : bitD->ptr >= bitD->start
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static BIT_DStream_status BIT_reloadDStream_internal(BIT_DStream_t* bitD)
-    {
-        assert(bitD->bitsConsumed <= (uint)(sizeof(nuint) * 8));
-        bitD->ptr -= bitD->bitsConsumed >> 3;
-        assert(bitD->ptr >= bitD->start);
-        bitD->bitsConsumed &= 7;
-        bitD->bitContainer = MEM_readLEST(bitD->ptr);
-        return BIT_DStream_status.BIT_DStream_unfinished;
-    }
-
-    /*! BIT_reloadDStreamFast() :
-     *  Similar to BIT_reloadDStream(), but with two differences:
-     *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
-     *  2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
-     *     point you must use BIT_reloadDStream() to reload.
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
-    {
-        if (bitD->ptr < bitD->limitPtr)
-            return BIT_DStream_status.BIT_DStream_overflow;
-        return BIT_reloadDStream_internal(bitD);
-    }
-
-#if NET7_0_OR_GREATER
-    private static ReadOnlySpan<byte> Span_static_zeroFilled =>
-        new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };
-    private static nuint* static_zeroFilled =>
-        (nuint*)
-            System.Runtime.CompilerServices.Unsafe.AsPointer(
-                ref MemoryMarshal.GetReference(Span_static_zeroFilled)
-            );
-#else
-
-    private static readonly nuint* static_zeroFilled = (nuint*)GetArrayPointer(
-        new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }
-    );
-#endif
-    /*! BIT_reloadDStream() :
-     *  Refill `bitD` from buffer previously set in BIT_initDStream() .
-     *  This function is safe, it guarantees it will not never beyond src buffer.
-     * @return : status of `BIT_DStream_t` internal register.
-     *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
-    {
-        if (bitD->bitsConsumed > (uint)(sizeof(nuint) * 8))
-        {
-            bitD->ptr = (sbyte*)&static_zeroFilled[0];
-            return BIT_DStream_status.BIT_DStream_overflow;
-        }
-
-        assert(bitD->ptr >= bitD->start);
-        if (bitD->ptr >= bitD->limitPtr)
-        {
-            return BIT_reloadDStream_internal(bitD);
-        }
-
-        if (bitD->ptr == bitD->start)
-        {
-            if (bitD->bitsConsumed < (uint)(sizeof(nuint) * 8))
-                return BIT_DStream_status.BIT_DStream_endOfBuffer;
-            return BIT_DStream_status.BIT_DStream_completed;
-        }
-
-        {
-            uint nbBytes = bitD->bitsConsumed >> 3;
-            BIT_DStream_status result = BIT_DStream_status.BIT_DStream_unfinished;
-            if (bitD->ptr - nbBytes < bitD->start)
-            {
-                nbBytes = (uint)(bitD->ptr - bitD->start);
-                result = BIT_DStream_status.BIT_DStream_endOfBuffer;
-            }
-
-            bitD->ptr -= nbBytes;
-            bitD->bitsConsumed -= nbBytes * 8;
-            bitD->bitContainer = MEM_readLEST(bitD->ptr);
-            return result;
-        }
-    }
-
-    /*! BIT_endOfDStream() :
-     * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint BIT_endOfDStream(BIT_DStream_t* DStream)
-    {
-        return DStream->ptr == DStream->start && DStream->bitsConsumed == (uint)(sizeof(nuint) * 8)
-            ? 1U
-            : 0U;
-    }
-
-    /*-********************************************************
-     *  bitStream decoding
-     **********************************************************/
-    /*! BIT_initDStream() :
-     *  Initialize a BIT_DStream_t.
-     * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
-     * `srcSize` must be the *exact* size of the bitStream, in bytes.
-     * @return : size of stream (== srcSize), or an errorCode if a problem is detected
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_initDStream(ref BIT_DStream_t bitD, void* srcBuffer, nuint srcSize)
-    {
-        if (srcSize < 1)
-        {
-            bitD = new BIT_DStream_t();
-            return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_srcSize_wrong));
-        }
-
-        bitD.start = (sbyte*)srcBuffer;
-        bitD.limitPtr = bitD.start + sizeof(nuint);
-        if (srcSize >= (nuint)sizeof(nuint))
-        {
-            bitD.ptr = (sbyte*)srcBuffer + srcSize - sizeof(nuint);
-            bitD.bitContainer = MEM_readLEST(bitD.ptr);
-            {
-                byte lastByte = ((byte*)srcBuffer)[srcSize - 1];
-                bitD.bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0;
-                if (lastByte == 0)
-                    return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_GENERIC));
-            }
-        }
-        else
-        {
-            bitD.ptr = bitD.start;
-            bitD.bitContainer = *(byte*)bitD.start;
-            switch (srcSize)
-            {
-                case 7:
-                    bitD.bitContainer += (nuint)((byte*)srcBuffer)[6] << sizeof(nuint) * 8 - 16;
-                    goto case 6;
-                case 6:
-                    bitD.bitContainer += (nuint)((byte*)srcBuffer)[5] << sizeof(nuint) * 8 - 24;
-                    goto case 5;
-                case 5:
-                    bitD.bitContainer += (nuint)((byte*)srcBuffer)[4] << sizeof(nuint) * 8 - 32;
-                    goto case 4;
-                case 4:
-                    bitD.bitContainer += (nuint)((byte*)srcBuffer)[3] << 24;
-                    goto case 3;
-                case 3:
-                    bitD.bitContainer += (nuint)((byte*)srcBuffer)[2] << 16;
-                    goto case 2;
-                case 2:
-                    bitD.bitContainer += (nuint)((byte*)srcBuffer)[1] << 8;
-                    goto default;
-                default:
-                    break;
-            }
-
-            {
-                byte lastByte = ((byte*)srcBuffer)[srcSize - 1];
-                bitD.bitsConsumed = lastByte != 0 ? 8 - ZSTD_highbit32(lastByte) : 0;
-                if (lastByte == 0)
-                    return unchecked((nuint)(-(int)ZSTD_ErrorCode.ZSTD_error_corruption_detected));
-            }
-
-            bitD.bitsConsumed += (uint)((nuint)sizeof(nuint) - srcSize) * 8;
-        }
-
-        return srcSize;
-    }
-
-    /*! BIT_lookBits() :
-     *  Provides next n bits from local register.
-     *  local register is not modified.
-     *  On 32-bits, maxNbBits==24.
-     *  On 64-bits, maxNbBits==56.
-     * @return : value extracted */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_lookBits(nuint bitD_bitContainer, uint bitD_bitsConsumed, uint nbBits)
-    {
-        return BIT_getMiddleBits(
-            bitD_bitContainer,
-            (uint)(sizeof(nuint) * 8) - bitD_bitsConsumed - nbBits,
-            nbBits
-        );
-    }
-
-    /*! BIT_lookBitsFast() :
-     *  unsafe version; only works if nbBits >= 1 */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_lookBitsFast(
-        nuint bitD_bitContainer,
-        uint bitD_bitsConsumed,
-        uint nbBits
-    )
-    {
-        uint regMask = (uint)(sizeof(nuint) * 8 - 1);
-        assert(nbBits >= 1);
-        return bitD_bitContainer
-            << (int)(bitD_bitsConsumed & regMask)
-            >> (int)(regMask + 1 - nbBits & regMask);
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static void BIT_skipBits(ref uint bitD_bitsConsumed, uint nbBits)
-    {
-        bitD_bitsConsumed += nbBits;
-    }
-
-    /*! BIT_readBits() :
-     *  Read (consume) next n bits from local register and update.
-     *  Pay attention to not read more than nbBits contained into local register.
-     * @return : extracted value. */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_readBits(
-        nuint bitD_bitContainer,
-        ref uint bitD_bitsConsumed,
-        uint nbBits
-    )
-    {
-        nuint value = BIT_lookBits(bitD_bitContainer, bitD_bitsConsumed, nbBits);
-        BIT_skipBits(ref bitD_bitsConsumed, nbBits);
-        return value;
-    }
-
-    /*! BIT_readBitsFast() :
-     *  unsafe version; only works if nbBits >= 1 */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nuint BIT_readBitsFast(
-        nuint bitD_bitContainer,
-        ref uint bitD_bitsConsumed,
-        uint nbBits
-    )
-    {
-        nuint value = BIT_lookBitsFast(bitD_bitContainer, bitD_bitsConsumed, nbBits);
-        assert(nbBits >= 1);
-        BIT_skipBits(ref bitD_bitsConsumed, nbBits);
-        return value;
-    }
-
-    /*! BIT_reloadDStreamFast() :
-     *  Similar to BIT_reloadDStream(), but with two differences:
-     *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!
-     *  2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
-     *     point you must use BIT_reloadDStream() to reload.
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static BIT_DStream_status BIT_reloadDStreamFast(
-        ref nuint bitD_bitContainer,
-        ref uint bitD_bitsConsumed,
-        ref sbyte* bitD_ptr,
-        sbyte* bitD_start,
-        sbyte* bitD_limitPtr
-    )
-    {
-        if (bitD_ptr < bitD_limitPtr)
-            return BIT_DStream_status.BIT_DStream_overflow;
-        return BIT_reloadDStream_internal(
-            ref bitD_bitContainer,
-            ref bitD_bitsConsumed,
-            ref bitD_ptr,
-            bitD_start
-        );
-    }
-
-    /*! BIT_reloadDStream() :
-     *  Refill `bitD` from buffer previously set in BIT_initDStream() .
-     *  This function is safe, it guarantees it will not never beyond src buffer.
-     * @return : status of `BIT_DStream_t` internal register.
-     *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static BIT_DStream_status BIT_reloadDStream(
-        ref nuint bitD_bitContainer,
-        ref uint bitD_bitsConsumed,
-        ref sbyte* bitD_ptr,
-        sbyte* bitD_start,
-        sbyte* bitD_limitPtr
-    )
-    {
-        if (bitD_bitsConsumed > (uint)(sizeof(nuint) * 8))
-        {
-            bitD_ptr = (sbyte*)&static_zeroFilled[0];
-            return BIT_DStream_status.BIT_DStream_overflow;
-        }
-
-        assert(bitD_ptr >= bitD_start);
-        if (bitD_ptr >= bitD_limitPtr)
-        {
-            return BIT_reloadDStream_internal(
-                ref bitD_bitContainer,
-                ref bitD_bitsConsumed,
-                ref bitD_ptr,
-                bitD_start
-            );
-        }
-
-        if (bitD_ptr == bitD_start)
-        {
-            if (bitD_bitsConsumed < (uint)(sizeof(nuint) * 8))
-                return BIT_DStream_status.BIT_DStream_endOfBuffer;
-            return BIT_DStream_status.BIT_DStream_completed;
-        }
-
-        {
-            uint nbBytes = bitD_bitsConsumed >> 3;
-            BIT_DStream_status result = BIT_DStream_status.BIT_DStream_unfinished;
-            if (bitD_ptr - nbBytes < bitD_start)
-            {
-                nbBytes = (uint)(bitD_ptr - bitD_start);
-                result = BIT_DStream_status.BIT_DStream_endOfBuffer;
-            }
-
-            bitD_ptr -= nbBytes;
-            bitD_bitsConsumed -= nbBytes * 8;
-            bitD_bitContainer = MEM_readLEST(bitD_ptr);
-            return result;
-        }
-    }
-
-    /*! BIT_reloadDStream_internal() :
-     *  Simple variant of BIT_reloadDStream(), with two conditions:
-     *  1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8
-     *  2. look window is valid after shifted down : bitD->ptr >= bitD->start
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static BIT_DStream_status BIT_reloadDStream_internal(
-        ref nuint bitD_bitContainer,
-        ref uint bitD_bitsConsumed,
-        ref sbyte* bitD_ptr,
-        sbyte* bitD_start
-    )
-    {
-        assert(bitD_bitsConsumed <= (uint)(sizeof(nuint) * 8));
-        bitD_ptr -= bitD_bitsConsumed >> 3;
-        assert(bitD_ptr >= bitD_start);
-        bitD_bitsConsumed &= 7;
-        bitD_bitContainer = MEM_readLEST(bitD_ptr);
-        return BIT_DStream_status.BIT_DStream_unfinished;
-    }
-
-    /*! BIT_endOfDStream() :
-     * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static uint BIT_endOfDStream(
-        uint DStream_bitsConsumed,
-        sbyte* DStream_ptr,
-        sbyte* DStream_start
-    )
-    {
-        return DStream_ptr == DStream_start && DStream_bitsConsumed == (uint)(sizeof(nuint) * 8)
-            ? 1U
-            : 0U;
-    }
-}

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

@@ -1,8 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public struct BlockSummary
-{
-    public nuint nbSequences;
-    public nuint blockSize;
-    public nuint litSize;
-}

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

@@ -1,20 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/**
- * COVER_best_t is used for two purposes:
- * 1. Synchronizing threads.
- * 2. Saving the best parameters and dictionary.
- *
- * All of the methods except COVER_best_init() are thread safe if zstd is
- * compiled with multithreaded support.
- */
-public unsafe struct COVER_best_s
-{
-    public void* mutex;
-    public void* cond;
-    public nuint liveJobs;
-    public void* dict;
-    public nuint dictSize;
-    public ZDICT_cover_params_t parameters;
-    public nuint compressedSize;
-}

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

@@ -1,19 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/*-*************************************
- * Context
- ***************************************/
-public unsafe struct COVER_ctx_t
-{
-    public byte* samples;
-    public nuint* offsets;
-    public nuint* samplesSizes;
-    public nuint nbSamples;
-    public nuint nbTrainSamples;
-    public nuint nbTestSamples;
-    public uint* suffix;
-    public nuint suffixSize;
-    public uint* freqs;
-    public uint* dmerAt;
-    public uint d;
-}

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

@@ -1,11 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/**
- * Struct used for the dictionary selection function.
- */
-public unsafe struct COVER_dictSelection
-{
-    public byte* dictContent;
-    public nuint dictSize;
-    public nuint totalCompressedSize;
-}

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

@@ -1,10 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/**
- *Number of epochs and size of each epoch.
- */
-public struct COVER_epoch_info_t
-{
-    public uint num;
-    public uint size;
-}

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

@@ -1,7 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public struct COVER_map_pair_t_s
-{
-    public uint key;
-    public uint value;
-}

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

@@ -1,9 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public unsafe struct COVER_map_s
-{
-    public COVER_map_pair_t_s* data;
-    public uint sizeLog;
-    public uint size;
-    public uint sizeMask;
-}

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

@@ -1,11 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/**
- * A segment is a range in the source as well as the score of the segment.
- */
-public struct COVER_segment_t
-{
-    public uint begin;
-    public uint end;
-    public uint score;
-}

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

@@ -1,12 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-/**
- * Parameters for COVER_tryParameters().
- */
-public unsafe struct COVER_tryParameters_data_s
-{
-    public COVER_ctx_t* ctx;
-    public COVER_best_s* best;
-    public nuint dictBufferCapacity;
-    public ZDICT_cover_params_t parameters;
-}

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

@@ -1,849 +0,0 @@
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public static unsafe partial class Methods
-{
-    private static readonly ZSTD_compressionParameters[][] ZSTD_defaultCParameters =
-        new ZSTD_compressionParameters[4][]
-        {
-            new ZSTD_compressionParameters[23]
-            {
-                new ZSTD_compressionParameters(
-                    windowLog: 19,
-                    chainLog: 12,
-                    hashLog: 13,
-                    searchLog: 1,
-                    minMatch: 6,
-                    targetLength: 1,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 19,
-                    chainLog: 13,
-                    hashLog: 14,
-                    searchLog: 1,
-                    minMatch: 7,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 20,
-                    chainLog: 15,
-                    hashLog: 16,
-                    searchLog: 1,
-                    minMatch: 6,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 21,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_dfast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 21,
-                    chainLog: 18,
-                    hashLog: 18,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_dfast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 21,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 3,
-                    minMatch: 5,
-                    targetLength: 2,
-                    strategy: ZSTD_strategy.ZSTD_greedy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 21,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 3,
-                    minMatch: 5,
-                    targetLength: 4,
-                    strategy: ZSTD_strategy.ZSTD_lazy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 21,
-                    chainLog: 19,
-                    hashLog: 20,
-                    searchLog: 4,
-                    minMatch: 5,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 21,
-                    chainLog: 19,
-                    hashLog: 20,
-                    searchLog: 4,
-                    minMatch: 5,
-                    targetLength: 16,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 20,
-                    hashLog: 21,
-                    searchLog: 4,
-                    minMatch: 5,
-                    targetLength: 16,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 21,
-                    hashLog: 22,
-                    searchLog: 5,
-                    minMatch: 5,
-                    targetLength: 16,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 21,
-                    hashLog: 22,
-                    searchLog: 6,
-                    minMatch: 5,
-                    targetLength: 16,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 22,
-                    hashLog: 23,
-                    searchLog: 6,
-                    minMatch: 5,
-                    targetLength: 32,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 22,
-                    hashLog: 22,
-                    searchLog: 4,
-                    minMatch: 5,
-                    targetLength: 32,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 22,
-                    hashLog: 23,
-                    searchLog: 5,
-                    minMatch: 5,
-                    targetLength: 32,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 23,
-                    hashLog: 23,
-                    searchLog: 6,
-                    minMatch: 5,
-                    targetLength: 32,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 22,
-                    chainLog: 22,
-                    hashLog: 22,
-                    searchLog: 5,
-                    minMatch: 5,
-                    targetLength: 48,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 23,
-                    chainLog: 23,
-                    hashLog: 22,
-                    searchLog: 5,
-                    minMatch: 4,
-                    targetLength: 64,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 23,
-                    chainLog: 23,
-                    hashLog: 22,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 64,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 23,
-                    chainLog: 24,
-                    hashLog: 22,
-                    searchLog: 7,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 25,
-                    chainLog: 25,
-                    hashLog: 23,
-                    searchLog: 7,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 26,
-                    chainLog: 26,
-                    hashLog: 24,
-                    searchLog: 7,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 27,
-                    chainLog: 27,
-                    hashLog: 25,
-                    searchLog: 9,
-                    minMatch: 3,
-                    targetLength: 999,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-            },
-            new ZSTD_compressionParameters[23]
-            {
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 12,
-                    hashLog: 13,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 1,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 13,
-                    hashLog: 14,
-                    searchLog: 1,
-                    minMatch: 6,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 14,
-                    hashLog: 14,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_dfast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 16,
-                    hashLog: 16,
-                    searchLog: 1,
-                    minMatch: 4,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_dfast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 3,
-                    minMatch: 5,
-                    targetLength: 2,
-                    strategy: ZSTD_strategy.ZSTD_greedy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 17,
-                    hashLog: 18,
-                    searchLog: 5,
-                    minMatch: 5,
-                    targetLength: 2,
-                    strategy: ZSTD_strategy.ZSTD_greedy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 3,
-                    minMatch: 5,
-                    targetLength: 4,
-                    strategy: ZSTD_strategy.ZSTD_lazy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 4,
-                    minMatch: 4,
-                    targetLength: 4,
-                    strategy: ZSTD_strategy.ZSTD_lazy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 4,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 5,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 6,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 5,
-                    minMatch: 4,
-                    targetLength: 12,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 7,
-                    minMatch: 4,
-                    targetLength: 12,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 4,
-                    minMatch: 4,
-                    targetLength: 16,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 4,
-                    minMatch: 3,
-                    targetLength: 32,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 18,
-                    hashLog: 19,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 128,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 128,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 8,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 128,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 8,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 10,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 12,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 18,
-                    chainLog: 19,
-                    hashLog: 19,
-                    searchLog: 13,
-                    minMatch: 3,
-                    targetLength: 999,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-            },
-            new ZSTD_compressionParameters[23]
-            {
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 12,
-                    hashLog: 12,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 1,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 12,
-                    hashLog: 13,
-                    searchLog: 1,
-                    minMatch: 6,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 13,
-                    hashLog: 15,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 15,
-                    hashLog: 16,
-                    searchLog: 2,
-                    minMatch: 5,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_dfast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 17,
-                    hashLog: 17,
-                    searchLog: 2,
-                    minMatch: 4,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_dfast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 3,
-                    minMatch: 4,
-                    targetLength: 2,
-                    strategy: ZSTD_strategy.ZSTD_greedy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 3,
-                    minMatch: 4,
-                    targetLength: 4,
-                    strategy: ZSTD_strategy.ZSTD_lazy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 3,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 4,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 5,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 16,
-                    hashLog: 17,
-                    searchLog: 6,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 17,
-                    hashLog: 17,
-                    searchLog: 5,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 7,
-                    minMatch: 4,
-                    targetLength: 12,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 3,
-                    minMatch: 4,
-                    targetLength: 12,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 4,
-                    minMatch: 3,
-                    targetLength: 32,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 128,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 8,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 10,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 5,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 7,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 9,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 17,
-                    chainLog: 18,
-                    hashLog: 17,
-                    searchLog: 11,
-                    minMatch: 3,
-                    targetLength: 999,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-            },
-            new ZSTD_compressionParameters[23]
-            {
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 12,
-                    hashLog: 13,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 1,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 15,
-                    searchLog: 1,
-                    minMatch: 5,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 15,
-                    searchLog: 1,
-                    minMatch: 4,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_fast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 15,
-                    searchLog: 2,
-                    minMatch: 4,
-                    targetLength: 0,
-                    strategy: ZSTD_strategy.ZSTD_dfast
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 14,
-                    searchLog: 4,
-                    minMatch: 4,
-                    targetLength: 2,
-                    strategy: ZSTD_strategy.ZSTD_greedy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 14,
-                    searchLog: 3,
-                    minMatch: 4,
-                    targetLength: 4,
-                    strategy: ZSTD_strategy.ZSTD_lazy
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 14,
-                    searchLog: 4,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 14,
-                    searchLog: 6,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 14,
-                    hashLog: 14,
-                    searchLog: 8,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_lazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 14,
-                    searchLog: 5,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 14,
-                    searchLog: 9,
-                    minMatch: 4,
-                    targetLength: 8,
-                    strategy: ZSTD_strategy.ZSTD_btlazy2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 14,
-                    searchLog: 3,
-                    minMatch: 4,
-                    targetLength: 12,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 14,
-                    searchLog: 4,
-                    minMatch: 3,
-                    targetLength: 24,
-                    strategy: ZSTD_strategy.ZSTD_btopt
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 14,
-                    searchLog: 5,
-                    minMatch: 3,
-                    targetLength: 32,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 64,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 7,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 5,
-                    minMatch: 3,
-                    targetLength: 48,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 6,
-                    minMatch: 3,
-                    targetLength: 128,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 7,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 8,
-                    minMatch: 3,
-                    targetLength: 256,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 8,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 9,
-                    minMatch: 3,
-                    targetLength: 512,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-                new ZSTD_compressionParameters(
-                    windowLog: 14,
-                    chainLog: 15,
-                    hashLog: 15,
-                    searchLog: 10,
-                    minMatch: 3,
-                    targetLength: 999,
-                    strategy: ZSTD_strategy.ZSTD_btultra2
-                ),
-            },
-        };
-}

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

@@ -1,61 +0,0 @@
-using System.Runtime.CompilerServices;
-
-namespace SharpCompress.Compressors.ZStandard.Unsafe;
-
-public static unsafe partial class Methods
-{
-    /* @return 1 if @u is a 2^n value, 0 otherwise
-     * useful to check a value is valid for alignment restrictions */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static int ZSTD_isPower2(nuint u)
-    {
-        return (u & u - 1) == 0 ? 1 : 0;
-    }
-
-    /**
-     * Helper function to perform a wrapped pointer difference without triggering
-     * UBSAN.
-     *
-     * @returns lhs - rhs with wrapping
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static nint ZSTD_wrappedPtrDiff(byte* lhs, byte* rhs)
-    {
-        return (nint)(lhs - rhs);
-    }
-
-    /**
-     * Helper function to perform a wrapped pointer add without triggering UBSAN.
-     *
-     * @return ptr + add with wrapping
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static byte* ZSTD_wrappedPtrAdd(byte* ptr, nint add)
-    {
-        return ptr + add;
-    }
-
-    /**
-     * Helper function to perform a wrapped pointer subtraction without triggering
-     * UBSAN.
-     *
-     * @return ptr - sub with wrapping
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static byte* ZSTD_wrappedPtrSub(byte* ptr, nint sub)
-    {
-        return ptr - sub;
-    }
-
-    /**
-     * Helper function to add to a pointer that works around C's undefined behavior
-     * of adding 0 to NULL.
-     *
-     * @returns `ptr + add` except it defines `NULL + 0 == NULL`.
-     */
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private static byte* ZSTD_maybeNullPtrAdd(byte* ptr, nint add)
-    {
-        return add > 0 ? ptr + add : ptr;
-    }
-}