Merge branch 'master' into adam/zstd

.config/dotnet-tools.json

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

.copilot-agent.yml

@@ -1,7 +0,0 @@
-enabled: true
-agent:
-  name: copilot-coding-agent
-  allow:
-    - paths: ["src/**/*", "tests/**/*", "README.md", "AGENTS.md"]
-      actions: ["create", "modify"]
-  require_review_before_merge: true

.github/COPILOT_AGENT_README.md

@@ -1,15 +0,0 @@
-# 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/agents/copilot-agent.yml

@@ -1,17 +0,0 @@
-enabled: true
-agent:
-  name: copilot-coding-agent
-  allow:
-    - paths: ["src/**/*", "tests/**/*", "README.md", "AGENTS.md"]
-      actions: ["create", "modify", "delete"]
-  require_review_before_merge: true
-  required_approvals: 1
-  allowed_merge_strategies:
-    - squash
-    - merge
-  auto_merge_on_green: false
-  run_workflows: true
-notes: |
-  - This manifest expresses the policy for the Copilot coding agent in this repository.
-  - It does NOT install or authorize the agent; a repository admin must install the Copilot coding agent app and grant the repository the necessary permissions (contents: write, pull_requests: write, checks: write, actions: write/read, issues: write) to allow the agent to act.
-  - Keep allow paths narrow and prefer require_review_before_merge during initial rollout.

.github/workflows/dotnetcore.yml

@@ -14,12 +14,12 @@ jobs:
         os: [windows-latest, ubuntu-latest]
 
     steps:
-    - uses: actions/checkout@v6
-    - uses: actions/setup-dotnet@v5
+    - uses: actions/checkout@v4
+    - uses: actions/setup-dotnet@v4
       with:
         dotnet-version: 8.0.x
     - run: dotnet run --project build/build.csproj
-    - uses: actions/upload-artifact@v5
+    - uses: actions/upload-artifact@v4
       with:
         name: ${{ matrix.os }}-sharpcompress.nupkg
         path: artifacts/*

.gitignore

@@ -11,8 +11,6 @@ TestResults/
 packages/*/
 project.lock.json
 tests/TestArchives/Scratch
-tests/TestArchives/*/Scratch
-tests/TestArchives/*/Scratch2
 .vs
 tools
 .vscode
@@ -20,3 +18,4 @@ tools
 
 .DS_Store
 *.snupkg
+/tests/TestArchives/6d23a38c-f064-4ef1-ad89-b942396f53b9/Scratch

AGENTS.md

@@ -1,24 +1,19 @@
 ---
-description: 'Guidelines for building SharpCompress - A C# compression library'
+description: 'Guidelines for building C# applications'
 applyTo: '**/*.cs'
 ---
 
-# SharpCompress Development
-
-## About SharpCompress
-SharpCompress is a pure C# compression library supporting multiple archive formats (Zip, Tar, GZip, BZip2, 7Zip, Rar, LZip, XZ, ZStandard) for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0, and .NET 8.0. The library provides both seekable Archive APIs and forward-only Reader/Writer APIs for streaming scenarios.
+# C# Development
 
 ## C# Instructions
 - Always use the latest version C#, currently C# 13 features.
 - Write clear and concise comments for each function.
-- Follow the existing code style and patterns in the codebase.
 
 ## General Instructions
 - Make only high confidence suggestions when reviewing code changes.
 - Write code with good maintainability practices, including comments on why certain design decisions were made.
 - Handle edge cases and write clear exception handling.
 - For libraries or external dependencies, mention their usage and purpose in comments.
-- Preserve backward compatibility when making changes to public APIs.
 
 ## Naming Conventions
 
@@ -28,26 +23,20 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 
 ## Code Formatting
 
-- Use CSharpier for code formatting to ensure consistent style across the project
-- CSharpier is configured as a local tool in `.config/dotnet-tools.json`
-- 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
+- Use CSharpier for all code formatting to ensure consistent style across the project.
+- Install CSharpier globally: `dotnet tool install -g csharpier`
+- Format files with: `dotnet csharpier format .`
+- Configure your IDE to format on save using CSharpier.
+- CSharpier configuration can be customized via `.csharpierrc` file in the project root.
+- Trust CSharpier's opinionated formatting decisions to maintain consistency.
 
 ## Project Setup and Structure
 
-- The project targets multiple frameworks: .NET Framework 4.62, .NET Standard 2.1, .NET 6.0, and .NET 8.0
-- Main library is in `src/SharpCompress/`
-- Tests are in `tests/SharpCompress.Test/`
-- Performance tests are in `tests/SharpCompress.Performance/`
-- Test archives are in `tests/TestArchives/`
-- Build project is in `build/`
-- Use `dotnet build` to build the solution
-- Use `dotnet test` to run tests
-- Solution file: `SharpCompress.sln`
+- Guide users through creating a new .NET project with the appropriate templates.
+- Explain the purpose of each generated file and folder to build understanding of the project structure.
+- Demonstrate how to organize code using feature folders or domain-driven design principles.
+- Show proper separation of concerns with models, services, and data access layers.
+- Explain the Program.cs and configuration system in ASP.NET Core 9 including environment-specific settings.
 
 ## Nullable Reference Types
 
@@ -55,64 +44,21 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 - Always use `is null` or `is not null` instead of `== null` or `!= null`.
 - Trust the C# null annotations and don't add null checks when the type system says a value cannot be null.
 
-## SharpCompress-Specific Guidelines
-
-### Supported Formats
-SharpCompress supports multiple archive and compression formats:
-- **Archive Formats**: Zip, Tar, 7Zip, Rar (read-only)
-- **Compression**: DEFLATE, BZip2, LZMA/LZMA2, PPMd, ZStandard (decompress only), Deflate64 (decompress only)
-- **Combined Formats**: Tar.GZip, Tar.BZip2, Tar.LZip, Tar.XZ, Tar.ZStandard
-- See FORMATS.md for complete format support matrix
-
-### Stream Handling Rules
-- **Disposal**: As of version 0.21, SharpCompress closes wrapped streams by default
-- Use `ReaderOptions` or `WriterOptions` with `LeaveStreamOpen = true` to control stream disposal
-- Use `NonDisposingStream` wrapper when working with compression streams directly to prevent disposal
-- Always dispose of readers, writers, and archives in `using` blocks
-- For forward-only operations, use Reader/Writer APIs; for random access, use Archive APIs
-
-### Async/Await Patterns
-- All I/O operations support async/await with `CancellationToken`
-- Async methods follow the naming convention: `MethodNameAsync`
-- Key async methods:
-  - `WriteEntryToAsync` - Extract entry asynchronously
-  - `WriteAllToDirectoryAsync` - Extract all entries asynchronously
-  - `WriteAsync` - Write entry asynchronously
-  - `WriteAllAsync` - Write directory asynchronously
-  - `OpenEntryStreamAsync` - Open entry stream asynchronously
-- Always provide `CancellationToken` parameter in async methods
-
-### Archive APIs vs Reader/Writer APIs
-- **Archive API**: Use for random access with seekable streams (e.g., `ZipArchive`, `TarArchive`)
-- **Reader API**: Use for forward-only reading on non-seekable streams (e.g., `ZipReader`, `TarReader`)
-- **Writer API**: Use for forward-only writing on streams (e.g., `ZipWriter`, `TarWriter`)
-- 7Zip only supports Archive API due to format limitations
-
-### Tar-Specific Considerations
-- Tar format requires file size in the header
-- If no size is specified to TarWriter and the stream is not seekable, an exception will be thrown
-- Tar combined with compression (GZip, BZip2, LZip, XZ) is supported
-
-### Zip-Specific Considerations
-- Supports Zip64 for large files (seekable streams only)
-- Supports PKWare and WinZip AES encryption
-- Multiple compression methods: None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA, PPMd
-- Encrypted LZMA is not supported
-
-### Performance Considerations
-- For large files, use Reader/Writer APIs with non-seekable streams to avoid loading entire file in memory
-- Leverage async I/O for better scalability
-- Consider compression level trade-offs (speed vs. size)
-- Use appropriate buffer sizes for stream operations
-
 ## Testing
 
 - Always include test cases for critical paths of the application.
-- Test with multiple archive formats when making changes to core functionality.
-- Include tests for both Archive and Reader/Writer APIs when applicable.
-- Test async operations with cancellation tokens.
+- Guide users through creating unit tests.
 - Do not emit "Act", "Arrange" or "Assert" comments.
 - Copy existing style in nearby files for test method names and capitalization.
-- 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.
+- Explain integration testing approaches for API endpoints.
+- Demonstrate how to mock dependencies for effective testing.
+- Show how to test authentication and authorization logic.
+- Explain test-driven development principles as applied to API development.
+
+## Performance Optimization
+
+- Guide users on implementing caching strategies (in-memory, distributed, response caching).
+- Explain asynchronous programming patterns and why they matter for API performance.
+- Demonstrate pagination, filtering, and sorting for large data sets.
+- Show how to implement compression and other performance optimizations.
+- Explain how to measure and benchmark API performance.

Directory.Packages.props

@@ -1,11 +1,10 @@
 <Project>
   <ItemGroup>
     <PackageVersion Include="Bullseye" Version="6.0.0" />
-    <PackageVersion Include="AwesomeAssertions" Version="9.3.0" />
+    <PackageVersion Include="AwesomeAssertions" Version="9.2.0" />
     <PackageVersion Include="Glob" Version="1.1.9" />
-    <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="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
     <PackageVersion Include="SimpleExec" Version="12.0.0" />
     <PackageVersion Include="System.Buffers" Version="4.6.1" />
@@ -13,8 +12,8 @@
     <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="xunit.SkippableFact" Version="1.5.23" />
     <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>

README.md

@@ -1,11 +1,9 @@
 # SharpCompress
 
-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.
+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 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).
 
-**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [Async Usage](#async-usage) section below.
-
 GitHub Actions Build -
 [![SharpCompress](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml/badge.svg)](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml)
 [![Static Badge](https://img.shields.io/badge/API%20Docs-DNDocs-190088?logo=readme&logoColor=white)](https://dndocs.com/d/sharpcompress/api/index.html)
@@ -34,82 +32,6 @@ Hi everyone. I hope you're using SharpCompress and finding it useful. Please giv
 
 Please do not email me directly to ask for help. If you think there is a real issue, please report it here.
 
-## Async Usage
-
-SharpCompress now provides full async/await support for all I/O operations, allowing for better performance and scalability in modern applications.
-
-### Async Reading Examples
-
-Extract entries asynchronously:
-```csharp
-using (Stream stream = File.OpenRead("archive.zip"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        if (!reader.Entry.IsDirectory)
-        {
-            // Async extraction
-            await reader.WriteEntryToDirectoryAsync(
-                @"C:\temp",
-                new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-                cancellationToken
-            );
-        }
-    }
-}
-```
-
-Extract all entries to directory asynchronously:
-```csharp
-using (Stream stream = File.OpenRead("archive.tar.gz"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    await reader.WriteAllToDirectoryAsync(
-        @"C:\temp",
-        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-        cancellationToken
-    );
-}
-```
-
-Open entry stream asynchronously:
-```csharp
-using (var archive = ZipArchive.Open("archive.zip"))
-{
-    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
-    {
-        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
-        {
-            // Process stream asynchronously
-            await entryStream.CopyToAsync(outputStream, cancellationToken);
-        }
-    }
-}
-```
-
-### Async Writing Examples
-
-Write files asynchronously:
-```csharp
-using (Stream stream = File.OpenWrite("output.zip"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    await writer.WriteAsync("file1.txt", fileStream, DateTime.Now, cancellationToken);
-}
-```
-
-Write all files from directory asynchronously:
-```csharp
-using (Stream stream = File.OpenWrite("output.tar.gz"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
-{
-    await writer.WriteAllAsync(@"D:\files", "*", SearchOption.AllDirectories, cancellationToken);
-}
-```
-
-All async methods support `CancellationToken` for graceful cancellation of long-running operations.
-
 ## Want to contribute?
 
 I'm always looking for help or ideas. Please submit code or email with ideas. Unfortunately, just letting me know you'd like to help is not enough because I really have no overall plan of what needs to be done. I'll definitely accept code submissions and add you as a member of the project!

SharpCompress.sln

@@ -21,14 +21,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425
 		Directory.Packages.props = Directory.Packages.props
 		NuGet.config = NuGet.config
 		.github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml
-		USAGE.md = USAGE.md
-		README.md = README.md
-		FORMATS.md = FORMATS.md
-		AGENTS.md = AGENTS.md
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.Performance", "tests\SharpCompress.Performance\SharpCompress.Performance.csproj", "{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -47,10 +41,6 @@ Global
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -58,6 +48,5 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
 	EndGlobalSection
 EndGlobal

USAGE.md

@@ -1,18 +1,5 @@
 # SharpCompress Usage
 
-## Async/Await Support
-
-SharpCompress now provides full async/await support for all I/O operations. All `Read`, `Write`, and extraction operations have async equivalents ending in `Async` that accept an optional `CancellationToken`. This enables better performance and scalability for I/O-bound operations.
-
-**Key Async Methods:**
-- `reader.WriteEntryToAsync(stream, cancellationToken)` - Extract entry asynchronously  
-- `reader.WriteAllToDirectoryAsync(path, options, cancellationToken)` - Extract all asynchronously
-- `writer.WriteAsync(filename, stream, modTime, cancellationToken)` - Write entry asynchronously
-- `writer.WriteAllAsync(directory, pattern, searchOption, cancellationToken)` - Write directory asynchronously
-- `entry.OpenEntryStreamAsync(cancellationToken)` - Open entry stream asynchronously
-
-See [Async Examples](#async-examples) section below for usage patterns.
-
 ## Stream Rules (changed with 0.21)
 
 When dealing with Streams, the rule should be that you don't close a stream you didn't create. This, in effect, should mean you should always put a Stream in a using block to dispose it. 
@@ -185,133 +172,3 @@ foreach(var entry in tr.Entries)
     Console.WriteLine($"{entry.Key}");
 }
 ```
-
-## Async Examples
-
-### Async Reader Examples
-
-**Extract single entry asynchronously:**
-```C#
-using (Stream stream = File.OpenRead("archive.zip"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        if (!reader.Entry.IsDirectory)
-        {
-            using (var entryStream = reader.OpenEntryStream())
-            {
-                using (var outputStream = File.Create("output.bin"))
-                {
-                    await reader.WriteEntryToAsync(outputStream, cancellationToken);
-                }
-            }
-        }
-    }
-}
-```
-
-**Extract all entries asynchronously:**
-```C#
-using (Stream stream = File.OpenRead("archive.tar.gz"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    await reader.WriteAllToDirectoryAsync(
-        @"D:\temp",
-        new ExtractionOptions()
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        },
-        cancellationToken
-    );
-}
-```
-
-**Open and process entry stream asynchronously:**
-```C#
-using (var archive = ZipArchive.Open("archive.zip"))
-{
-    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
-    {
-        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
-        {
-            // Process the decompressed stream asynchronously
-            await ProcessStreamAsync(entryStream, cancellationToken);
-        }
-    }
-}
-```
-
-### Async Writer Examples
-
-**Write single file asynchronously:**
-```C#
-using (Stream archiveStream = File.OpenWrite("output.zip"))
-using (var writer = WriterFactory.Open(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    using (Stream fileStream = File.OpenRead("input.txt"))
-    {
-        await writer.WriteAsync("entry.txt", fileStream, DateTime.Now, cancellationToken);
-    }
-}
-```
-
-**Write entire directory asynchronously:**
-```C#
-using (Stream stream = File.OpenWrite("backup.tar.gz"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
-{
-    await writer.WriteAllAsync(
-        @"D:\files",
-        "*",
-        SearchOption.AllDirectories,
-        cancellationToken
-    );
-}
-```
-
-**Write with progress tracking and cancellation:**
-```C#
-var cts = new CancellationTokenSource();
-
-// Set timeout or cancel from UI
-cts.CancelAfter(TimeSpan.FromMinutes(5));
-
-using (Stream stream = File.OpenWrite("archive.zip"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    try
-    {
-        await writer.WriteAllAsync(@"D:\data", "*", SearchOption.AllDirectories, cts.Token);
-    }
-    catch (OperationCanceledException)
-    {
-        Console.WriteLine("Operation was cancelled");
-    }
-}
-```
-
-### Archive Async Examples
-
-**Extract from archive asynchronously:**
-```C#
-using (var archive = ZipArchive.Open("archive.zip"))
-{
-    using (var reader = archive.ExtractAllEntries())
-    {
-        await reader.WriteAllToDirectoryAsync(
-            @"C:\output",
-            new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-            cancellationToken
-        );
-    }
-}
-```
-
-**Benefits of Async Operations:**
-- Non-blocking I/O for better application responsiveness
-- Improved scalability for server applications
-- Support for cancellation via CancellationToken
-- Better resource utilization in async/await contexts
-- Compatible with modern .NET async patterns

src/SharpCompress/Archives/AbstractArchive.cs

@@ -144,12 +144,6 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
     /// <returns></returns>
     public IReader ExtractAllEntries()
     {
-        if (!IsSolid && Type != ArchiveType.SevenZip)
-        {
-            throw new InvalidOperationException(
-                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
-            );
-        }
         ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
         return CreateReaderForSolidExtraction();
     }
@@ -172,9 +166,4 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
             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/AbstractWritableArchive.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.IO;
 using SharpCompress.Writers;
@@ -96,9 +94,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         DateTime? modified
     ) => AddEntry(key, source, closeStream, size, modified);
 
-    IArchiveEntry IWritableArchive.AddDirectoryEntry(string key, DateTime? modified) =>
-        AddDirectoryEntry(key, modified);
-
     public TEntry AddEntry(
         string key,
         Stream source,
@@ -139,22 +134,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         return false;
     }
 
-    public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
-    {
-        if (key.Length > 0 && key[0] is '/' or '\\')
-        {
-            key = key.Substring(1);
-        }
-        if (DoesKeyMatchExisting(key))
-        {
-            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-        }
-        var entry = CreateDirectoryEntry(key, modified);
-        newEntries.Add(entry);
-        RebuildModifiedCollection();
-        return entry;
-    }
-
     public void SaveTo(Stream stream, WriterOptions options)
     {
         //reset streams of new entries
@@ -162,18 +141,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         SaveTo(stream, options, OldEntries, newEntries);
     }
 
-    public async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        //reset streams of new entries
-        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-        await SaveToAsync(stream, options, OldEntries, newEntries, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     protected TEntry CreateEntry(
         string key,
         Stream source,
@@ -199,8 +166,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         bool closeStream
     );
 
-    protected abstract TEntry CreateDirectoryEntry(string key, DateTime? modified);
-
     protected abstract void SaveTo(
         Stream stream,
         WriterOptions options,
@@ -208,14 +173,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         IEnumerable<TEntry> newEntries
     );
 
-    protected abstract Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<TEntry> oldEntries,
-        IEnumerable<TEntry> newEntries,
-        CancellationToken cancellationToken = default
-    );
-
     public override void Dispose()
     {
         base.Dispose();

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -20,7 +20,7 @@ public static class ArchiveFactory
     public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+        stream = new SharpCompressStream(stream, bufferSize: readerOptions.BufferSize);
         return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
@@ -45,7 +45,7 @@ public static class ArchiveFactory
     /// <param name="options"></param>
     public static IArchive Open(string filePath, ReaderOptions? options = null)
     {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), options);
     }
 
@@ -68,7 +68,7 @@ public static class ArchiveFactory
     /// <param name="options"></param>
     public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
     {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
         var filesArray = fileInfos.ToArray();
         if (filesArray.Length == 0)
         {
@@ -81,7 +81,7 @@ public static class ArchiveFactory
             return Open(fileInfo, options);
         }
 
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
         return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
@@ -94,7 +94,7 @@ public static class ArchiveFactory
     /// <param name="options"></param>
     public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
     {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
         var streamsArray = streams.ToArray();
         if (streamsArray.Length == 0)
         {
@@ -107,7 +107,7 @@ public static class ArchiveFactory
             return Open(firstStream, options);
         }
 
-        firstStream.NotNull(nameof(firstStream));
+        firstStream.CheckNotNull(nameof(firstStream));
         options ??= new ReaderOptions();
 
         return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
@@ -129,7 +129,7 @@ public static class ArchiveFactory
     private static T FindFactory<T>(FileInfo finfo)
         where T : IFactory
     {
-        finfo.NotNull(nameof(finfo));
+        finfo.CheckNotNull(nameof(finfo));
         using Stream stream = finfo.OpenRead();
         return FindFactory<T>(stream);
     }
@@ -137,7 +137,7 @@ public static class ArchiveFactory
     private static T FindFactory<T>(Stream stream)
         where T : IFactory
     {
-        stream.NotNull(nameof(stream));
+        stream.CheckNotNull(nameof(stream));
         if (!stream.CanRead || !stream.CanSeek)
         {
             throw new ArgumentException("Stream should be readable and seekable");
@@ -172,7 +172,7 @@ public static class ArchiveFactory
         int bufferSize = ReaderOptions.DefaultBufferSize
     )
     {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
         using Stream s = File.OpenRead(filePath);
         return IsArchive(s, out type, bufferSize);
     }
@@ -184,7 +184,7 @@ public static class ArchiveFactory
     )
     {
         type = null;
-        stream.NotNull(nameof(stream));
+        stream.CheckNotNull(nameof(stream));
 
         if (!stream.CanRead || !stream.CanSeek)
         {
@@ -215,7 +215,7 @@ public static class ArchiveFactory
     /// <returns></returns>
     public static IEnumerable<string> GetFileParts(string part1)
     {
-        part1.NotNullOrEmpty(nameof(part1));
+        part1.CheckNotNullOrEmpty(nameof(part1));
         return GetFileParts(new FileInfo(part1)).Select(a => a.FullName);
     }
 
@@ -226,7 +226,7 @@ public static class ArchiveFactory
     /// <returns></returns>
     public static IEnumerable<FileInfo> GetFileParts(FileInfo part1)
     {
-        part1.NotNull(nameof(part1));
+        part1.CheckNotNull(nameof(part1));
         yield return part1;
 
         foreach (var factory in Factory.Factories.OfType<IFactory>())

src/SharpCompress/Archives/GZip/GZipArchive.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.GZip;
 using SharpCompress.IO;
@@ -23,7 +21,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -34,7 +32,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
     {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
         return new GZipArchive(
             new SourceStream(
                 fileInfo,
@@ -54,7 +52,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new GZipArchive(
             new SourceStream(
@@ -72,7 +70,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
         var strms = streams.ToArray();
         return new GZipArchive(
             new SourceStream(
@@ -90,7 +88,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        stream.NotNull(nameof(stream));
+        stream.CheckNotNull(nameof(stream));
 
         if (stream is not { CanSeek: true })
         {
@@ -138,16 +136,6 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         SaveTo(stream, new WriterOptions(CompressionType.GZip));
     }
 
-    public Task SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
-        SaveToAsync(new FileInfo(filePath), cancellationToken);
-
-    public async Task SaveToAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     public static bool IsGZipFile(Stream stream)
     {
         // read the header on the first read
@@ -185,11 +173,6 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
     }
 
-    protected override GZipArchiveEntry CreateDirectoryEntry(
-        string directoryPath,
-        DateTime? modified
-    ) => throw new NotSupportedException("GZip archives do not support directory entries.");
-
     protected override void SaveTo(
         Stream stream,
         WriterOptions options,
@@ -213,28 +196,6 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         }
     }
 
-    protected override async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<GZipArchiveEntry> oldEntries,
-        IEnumerable<GZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (Entries.Count > 1)
-        {
-            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
-        }
-        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
-        {
-            using var entryStream = entry.OpenEntryStream();
-            await writer
-                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
-                .ConfigureAwait(false);
-        }
-    }
-
     protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
     {
         var stream = volumes.Single().Stream;

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.GZip;
 
 namespace SharpCompress.Archives.GZip;
@@ -15,20 +13,13 @@ public class GZipArchiveEntry : GZipEntry, IArchiveEntry
     {
         //this is to reset the stream to be read multiple times
         var part = (GZipFilePart)Parts.Single();
-        var rawStream = part.GetRawStream();
-        if (rawStream.CanSeek && rawStream.Position != part.EntryStartPosition)
+        if (part.GetRawStream().Position != part.EntryStartPosition)
         {
-            rawStream.Position = part.EntryStartPosition;
+            part.GetRawStream().Position = part.EntryStartPosition;
         }
         return Parts.Single().GetCompressedStream().NotNull();
     }
 
-    public virtual Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
-    {
-        // GZip synchronous implementation is fast enough, just wrap it
-        return Task.FromResult(OpenEntryStream());
-    }
-
     #region IArchiveEntry Members
 
     public IArchive Archive { get; }

src/SharpCompress/Archives/IArchive.cs

@@ -45,14 +45,4 @@ 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/IArchiveEntry.cs

@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 
 namespace SharpCompress.Archives;
@@ -13,12 +11,6 @@ public interface IArchiveEntry : IEntry
     /// </summary>
     Stream OpenEntryStream();
 
-    /// <summary>
-    /// Opens the current entry as a stream that will decompress as it is read asynchronously.
-    /// Read the entire stream or use SkipEntry on EntryStream.
-    /// </summary>
-    Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
-
     /// <summary>
     /// The archive can find all the parts of the archive needed to extract this entry.
     /// </summary>

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
@@ -27,35 +25,7 @@ public static class IArchiveEntryExtensions
         using (entryStream)
         {
             using Stream s = new ListeningStream(streamListener, entryStream);
-            s.CopyTo(streamToWriteTo);
-        }
-        streamListener.FireEntryExtractionEnd(archiveEntry);
-    }
-
-    public static async Task WriteToAsync(
-        this IArchiveEntry archiveEntry,
-        Stream streamToWriteTo,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (archiveEntry.IsDirectory)
-        {
-            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-        }
-
-        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)
-        {
-            using Stream s = new ListeningStream(streamListener, entryStream);
-            await s.CopyToAsync(streamToWriteTo, 81920, cancellationToken).ConfigureAwait(false);
+            s.TransferTo(streamToWriteTo);
         }
         streamListener.FireEntryExtractionEnd(archiveEntry);
     }
@@ -75,23 +45,6 @@ public static class IArchiveEntryExtensions
             entry.WriteToFile
         );
 
-    /// <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>
@@ -110,25 +63,4 @@ public static class IArchiveEntryExtensions
                 entry.WriteTo(fs);
             }
         );
-
-    /// <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

@@ -45,10 +45,12 @@ public static class IArchiveExtensions
         var seenDirectories = new HashSet<string>();
 
         // Extract
-        foreach (var entry in archive.Entries)
+        var entries = archive.ExtractAllEntries();
+        while (entries.MoveToNextEntry())
         {
             cancellationToken.ThrowIfCancellationRequested();
 
+            var entry = entries.Entry;
             if (entry.IsDirectory)
             {
                 var dirPath = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
@@ -75,7 +77,7 @@ public static class IArchiveExtensions
 
             // Write file
             using var fs = File.OpenWrite(path);
-            entry.WriteTo(fs);
+            entries.WriteEntryTo(fs);
 
             // Update progress
             bytesRead += entry.Size;

src/SharpCompress/Archives/IWritableArchive.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
@@ -18,16 +16,8 @@ public interface IWritableArchive : IArchive
         DateTime? modified = null
     );
 
-    IArchiveEntry AddDirectoryEntry(string key, DateTime? modified = null);
-
     void SaveTo(Stream stream, WriterOptions options);
 
-    Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    );
-
     /// <summary>
     /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
     /// </summary>

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
@@ -44,24 +42,6 @@ public static class IWritableArchiveExtensions
         writableArchive.SaveTo(stream, options);
     }
 
-    public static Task SaveToAsync(
-        this IWritableArchive writableArchive,
-        string filePath,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    ) => writableArchive.SaveToAsync(new FileInfo(filePath), options, cancellationToken);
-
-    public static async Task SaveToAsync(
-        this IWritableArchive writableArchive,
-        FileInfo fileInfo,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await writableArchive.SaveToAsync(stream, options, cancellationToken).ConfigureAwait(false);
-    }
-
     public static void AddAllFromDirectory(
         this IWritableArchive writableArchive,
         string filePath,

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -47,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;
@@ -57,18 +57,12 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
             return sourceStream.Streams.Select(a => new StreamRarArchiveVolume(
                 a,
                 ReaderOptions,
-                i++,
-                IsMultiVolume
+                i++
             ));
         }
 
         //split mode or single file
-        return new StreamRarArchiveVolume(
-            sourceStream,
-            ReaderOptions,
-            0,
-            IsMultiVolume
-        ).AsEnumerable();
+        return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
     }
 
     protected override IReader CreateReaderForSolidExtraction()
@@ -89,7 +83,6 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     }
 
     public override bool IsSolid => Volumes.First().IsSolidArchive;
-    public override bool SupportsMultiThreading => !IsMultiVolume && !IsSolid;
 
     public virtual int MinVersion => Volumes.First().MinVersion;
     public virtual int MaxVersion => Volumes.First().MaxVersion;
@@ -102,7 +95,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="options"></param>
     public static RarArchive Open(string filePath, ReaderOptions? options = null)
     {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
         var fileInfo = new FileInfo(filePath);
         return new RarArchive(
             new SourceStream(
@@ -120,7 +113,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="options"></param>
     public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
     {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
         return new RarArchive(
             new SourceStream(
                 fileInfo,
@@ -137,7 +130,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="options"></param>
     public static RarArchive Open(Stream stream, ReaderOptions? options = null)
     {
-        stream.NotNull(nameof(stream));
+        stream.CheckNotNull(nameof(stream));
 
         if (stream is not { CanSeek: true })
         {
@@ -157,7 +150,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new RarArchive(
             new SourceStream(
@@ -175,7 +168,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="readerOptions"></param>
     public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
         var strms = streams.ToArray();
         return new RarArchive(
             new SourceStream(

src/SharpCompress/Archives/Rar/RarArchiveEntry.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;
@@ -70,50 +68,20 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
 
     public Stream OpenEntryStream()
     {
-        RarStream stream;
         if (IsRarV3)
         {
-            stream = new RarStream(
+            return new RarStream(
                 archive.UnpackV1.Value,
                 FileHeader,
                 new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
             );
         }
-        else
-        {
-            stream = new RarStream(
-                archive.UnpackV2017.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-            );
-        }
 
-        stream.Initialize();
-        return stream;
-    }
-
-    public async Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
-    {
-        RarStream stream;
-        if (IsRarV3)
-        {
-            stream = new RarStream(
-                archive.UnpackV1.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-            );
-        }
-        else
-        {
-            stream = new RarStream(
-                archive.UnpackV2017.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-            );
-        }
-
-        await stream.InitializeAsync(cancellationToken);
-        return stream;
+        return new RarStream(
+            archive.UnpackV2017.Value,
+            FileHeader,
+            new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+        );
     }
 
     public bool IsComplete
@@ -134,6 +102,4 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             );
         }
     }
-
-    public override bool SupportsMultiThreading => Parts.Single().SupportsMultiThreading;
 }

src/SharpCompress/Archives/Rar/SeekableFilePart.cs

@@ -1,29 +1,25 @@
 using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
-using SharpCompress.IO;
 
 namespace SharpCompress.Archives.Rar;
 
-internal class SeekableRarFilePart : RarFilePart
+internal class SeekableFilePart : RarFilePart
 {
     private readonly Stream _stream;
     private readonly string? _password;
-    private readonly bool _isMultiVolume;
 
-    internal SeekableRarFilePart(
+    internal SeekableFilePart(
         MarkHeader mh,
         FileHeader fh,
         int index,
         Stream stream,
-        string? password,
-        bool isMultiVolume
+        string? password
     )
         : base(mh, fh, index)
     {
         _stream = stream;
         _password = password;
-        _isMultiVolume = isMultiVolume;
     }
 
     internal override Stream GetCompressedStream()
@@ -46,7 +42,4 @@ internal class SeekableRarFilePart : 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,28 +9,11 @@ namespace SharpCompress.Archives.Rar;
 
 internal class StreamRarArchiveVolume : RarVolume
 {
-    private readonly bool _isMultiVolume;
-
-    internal StreamRarArchiveVolume(
-        Stream stream,
-        ReaderOptions options,
-        int index,
-        bool isMultiVolume
-    )
-        : base(StreamingMode.Seekable, stream, options, index)
-    {
-        _isMultiVolume = isMultiVolume;
-    }
+    internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index)
+        : base(StreamingMode.Seekable, stream, options, index) { }
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
 
     internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
-        new SeekableRarFilePart(
-            markHeader,
-            fileHeader,
-            Index,
-            Stream,
-            ReaderOptions.Password,
-            _isMultiVolume
-        );
+        new SeekableFilePart(markHeader, fileHeader, Index, Stream, ReaderOptions.Password);
 }

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -21,7 +21,7 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
     /// <param name="readerOptions"></param>
     public static SevenZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        filePath.NotNullOrEmpty("filePath");
+        filePath.CheckNotNullOrEmpty("filePath");
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -32,7 +32,7 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
     /// <param name="readerOptions"></param>
     public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
     {
-        fileInfo.NotNull("fileInfo");
+        fileInfo.CheckNotNull("fileInfo");
         return new SevenZipArchive(
             new SourceStream(
                 fileInfo,
@@ -52,7 +52,7 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new SevenZipArchive(
             new SourceStream(
@@ -73,7 +73,7 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         ReaderOptions? readerOptions = null
     )
     {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
         var strms = streams.ToArray();
         return new SevenZipArchive(
             new SourceStream(
@@ -91,7 +91,7 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
     /// <param name="readerOptions"></param>
     public static SevenZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        stream.NotNull("stream");
+        stream.CheckNotNull("stream");
 
         if (stream is not { CanSeek: true })
         {

src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs

@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.SevenZip;
 
 namespace SharpCompress.Archives.SevenZip;
@@ -12,9 +10,6 @@ public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
 
     public Stream OpenEntryStream() => FilePart.GetCompressedStream();
 
-    public Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        Task.FromResult(OpenEntryStream());
-
     public IArchive Archive { get; }
 
     public bool IsComplete => true;

src/SharpCompress/Archives/Tar/TarArchive.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.Tar;
 using SharpCompress.Common.Tar.Headers;
@@ -24,7 +22,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -35,7 +33,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
     {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
         return new TarArchive(
             new SourceStream(
                 fileInfo,
@@ -55,7 +53,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new TarArchive(
             new SourceStream(
@@ -73,7 +71,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
         var strms = streams.ToArray();
         return new TarArchive(
             new SourceStream(
@@ -91,7 +89,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        stream.NotNull(nameof(stream));
+        stream.CheckNotNull(nameof(stream));
 
         if (stream is not { CanSeek: true })
         {
@@ -180,7 +178,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
                         using (var entryStream = entry.OpenEntryStream())
                         {
                             using var memoryStream = new MemoryStream();
-                            entryStream.CopyTo(memoryStream);
+                            entryStream.TransferTo(memoryStream);
                             memoryStream.Position = 0;
                             var bytes = memoryStream.ToArray();
 
@@ -224,11 +222,6 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
             closeStream
         );
 
-    protected override TarArchiveEntry CreateDirectoryEntry(
-        string directoryPath,
-        DateTime? modified
-    ) => new TarWritableArchiveEntry(this, directoryPath, modified);
-
     protected override void SaveTo(
         Stream stream,
         WriterOptions options,
@@ -237,62 +230,15 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     )
     {
         using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
-            if (entry.IsDirectory)
-            {
-                writer.WriteDirectory(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entry.LastModifiedTime
-                );
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                writer.Write(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entryStream,
-                    entry.LastModifiedTime,
-                    entry.Size
-                );
-            }
-        }
-    }
-
-    protected override async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<TarArchiveEntry> oldEntries,
-        IEnumerable<TarArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        entry.LastModifiedTime,
-                        entry.Size,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(
+                entry.Key.NotNull("Entry Key is null"),
+                entryStream,
+                entry.LastModifiedTime,
+                entry.Size
+            );
         }
     }
 

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 
@@ -14,10 +12,6 @@ public class TarArchiveEntry : TarEntry, IArchiveEntry
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public virtual Task<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    ) => Task.FromResult(OpenEntryStream());
-
     #region IArchiveEntry Members
 
     public IArchive Archive { get; }

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -9,8 +9,7 @@ namespace SharpCompress.Archives.Tar;
 internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
 {
     private readonly bool closeStream;
-    private readonly Stream? stream;
-    private readonly bool isDirectory;
+    private readonly Stream stream;
 
     internal TarWritableArchiveEntry(
         TarArchive archive,
@@ -28,22 +27,6 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
         Size = size;
         LastModifiedTime = lastModified;
         this.closeStream = closeStream;
-        isDirectory = false;
-    }
-
-    internal TarWritableArchiveEntry(
-        TarArchive archive,
-        string directoryPath,
-        DateTime? lastModified
-    )
-        : base(archive, null, CompressionType.None)
-    {
-        stream = null;
-        Key = directoryPath;
-        Size = 0;
-        LastModifiedTime = lastModified;
-        closeStream = false;
-        isDirectory = true;
     }
 
     public override long Crc => 0;
@@ -64,19 +47,15 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
 
     public override bool IsEncrypted => false;
 
-    public override bool IsDirectory => isDirectory;
+    public override bool IsDirectory => false;
 
     public override bool IsSplitAfter => false;
 
     internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
-    Stream IWritableArchiveEntry.Stream => stream ?? Stream.Null;
+    Stream IWritableArchiveEntry.Stream => stream;
 
     public override Stream OpenEntryStream()
     {
-        if (stream is null)
-        {
-            return Stream.Null;
-        }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
         return SharpCompressStream.Create(stream, leaveOpen: true);
@@ -84,7 +63,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
 
     internal override void Close()
     {
-        if (closeStream && stream is not null)
+        if (closeStream)
         {
             stream.Dispose();
         }

src/SharpCompress/Archives/Zip/ZipArchive.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.Zip;
 using SharpCompress.Common.Zip.Headers;
@@ -45,7 +43,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -56,7 +54,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
     {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
         return new ZipArchive(
             new SourceStream(
                 fileInfo,
@@ -76,7 +74,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new ZipArchive(
             new SourceStream(
@@ -94,7 +92,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
         var strms = streams.ToArray();
         return new ZipArchive(
             new SourceStream(
@@ -112,7 +110,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        stream.NotNull(nameof(stream));
+        stream.CheckNotNull(nameof(stream));
 
         if (stream is not { CanSeek: true })
         {
@@ -283,12 +281,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 
                             yield return new ZipArchiveEntry(
                                 this,
-                                new SeekableZipFilePart(
-                                    headerFactory.NotNull(),
-                                    deh,
-                                    s,
-                                    IsMultiVolume
-                                )
+                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
                             );
                         }
                         break;
@@ -313,59 +306,14 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     )
     {
         using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
-            if (entry.IsDirectory)
-            {
-                writer.WriteDirectory(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entry.LastModifiedTime
-                );
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                writer.Write(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entryStream,
-                    entry.LastModifiedTime
-                );
-            }
-        }
-    }
-
-    protected override async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<ZipArchiveEntry> oldEntries,
-        IEnumerable<ZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(
+                entry.Key.NotNull("Entry Key is null"),
+                entryStream,
+                entry.LastModifiedTime
+            );
         }
     }
 
@@ -377,11 +325,6 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         bool closeStream
     ) => new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
 
-    protected override ZipArchiveEntry CreateDirectoryEntry(
-        string directoryPath,
-        DateTime? modified
-    ) => new ZipWritableArchiveEntry(this, directoryPath, modified);
-
     public static ZipArchive Create() => new();
 
     protected override IReader CreateReaderForSolidExtraction()
@@ -390,6 +333,4 @@ 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

@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip;
 
 namespace SharpCompress.Archives.Zip;
@@ -13,17 +11,11 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public virtual Task<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    ) => Task.FromResult(OpenEntryStream());
-
     #region IArchiveEntry Members
 
     public IArchive Archive { get; }
 
     public bool IsComplete => true;
 
-    public override bool SupportsMultiThreading => Parts.Single().SupportsMultiThreading;
-
     #endregion
 }

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -9,8 +9,7 @@ namespace SharpCompress.Archives.Zip;
 internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
 {
     private readonly bool closeStream;
-    private readonly Stream? stream;
-    private readonly bool isDirectory;
+    private readonly Stream stream;
     private bool isDisposed;
 
     internal ZipWritableArchiveEntry(
@@ -28,22 +27,6 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
         Size = size;
         LastModifiedTime = lastModified;
         this.closeStream = closeStream;
-        isDirectory = false;
-    }
-
-    internal ZipWritableArchiveEntry(
-        ZipArchive archive,
-        string directoryPath,
-        DateTime? lastModified
-    )
-        : base(archive, null)
-    {
-        stream = null;
-        Key = directoryPath;
-        Size = 0;
-        LastModifiedTime = lastModified;
-        closeStream = false;
-        isDirectory = true;
     }
 
     public override long Crc => 0;
@@ -64,20 +47,16 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
 
     public override bool IsEncrypted => false;
 
-    public override bool IsDirectory => isDirectory;
+    public override bool IsDirectory => false;
 
     public override bool IsSplitAfter => false;
 
     internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
 
-    Stream IWritableArchiveEntry.Stream => stream ?? Stream.Null;
+    Stream IWritableArchiveEntry.Stream => stream;
 
     public override Stream OpenEntryStream()
     {
-        if (stream is null)
-        {
-            return Stream.Null;
-        }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
         return SharpCompressStream.Create(stream, leaveOpen: true);
@@ -85,7 +64,7 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
 
     internal override void Close()
     {
-        if (closeStream && !isDisposed && stream is not null)
+        if (closeStream && !isDisposed)
         {
             stream.Dispose();
             isDisposed = true;

src/SharpCompress/AssemblyInfo.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Runtime.CompilerServices;
 
-[assembly: CLSCompliant(true)]
+[assembly: CLSCompliant(false)]
 [assembly: InternalsVisibleTo(
     "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc"
 )]

src/SharpCompress/Common/Arc/ArcEntry.cs

@@ -7,54 +7,53 @@ using System.Threading.Tasks;
 using SharpCompress.Common.GZip;
 using SharpCompress.Common.Tar;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public class ArcEntry : Entry
 {
-    public class ArcEntry : Entry
+    private readonly ArcFilePart? _filePart;
+
+    internal ArcEntry(ArcFilePart? filePart)
     {
-        private readonly ArcFilePart? _filePart;
-
-        internal ArcEntry(ArcFilePart? filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override long Crc
-        {
-            get
-            {
-                if (_filePart == null)
-                {
-                    return 0;
-                }
-                return _filePart.Header.Crc16;
-            }
-        }
-
-        public override string? Key => _filePart?.Header.Name;
-
-        public override string? LinkTarget => null;
-
-        public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
-
-        public override CompressionType CompressionType =>
-            _filePart?.Header.CompressionMethod ?? CompressionType.Unknown;
-
-        public override long Size => throw new NotImplementedException();
-
-        public override DateTime? LastModifiedTime => null;
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => false;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+        _filePart = filePart;
     }
+
+    public override long Crc
+    {
+        get
+        {
+            if (_filePart == null)
+            {
+                return 0;
+            }
+            return _filePart.Header.Crc16;
+        }
+    }
+
+    public override string? Key => _filePart?.Header.Name;
+
+    public override string? LinkTarget => null;
+
+    public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
+
+    public override CompressionType CompressionType =>
+        _filePart?.Header.CompressionMethod ?? CompressionType.Unknown;
+
+    public override long Size => throw new NotImplementedException();
+
+    public override DateTime? LastModifiedTime => null;
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => false;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
 }

src/SharpCompress/Common/Arc/ArcEntryHeader.cs

@@ -3,74 +3,73 @@ using System.IO;
 using System.Linq;
 using System.Text;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public class ArcEntryHeader
 {
-    public class ArcEntryHeader
+    public ArchiveEncoding ArchiveEncoding { get; }
+    public CompressionType CompressionMethod { get; private set; }
+    public string? Name { get; private set; }
+    public long CompressedSize { get; private set; }
+    public DateTime DateTime { get; private set; }
+    public int Crc16 { get; private set; }
+    public long OriginalSize { get; private set; }
+    public long DataStartPosition { get; private set; }
+
+    public ArcEntryHeader(ArchiveEncoding archiveEncoding)
     {
-        public ArchiveEncoding ArchiveEncoding { get; }
-        public CompressionType CompressionMethod { get; private set; }
-        public string? Name { get; private set; }
-        public long CompressedSize { get; private set; }
-        public DateTime DateTime { get; private set; }
-        public int Crc16 { get; private set; }
-        public long OriginalSize { get; private set; }
-        public long DataStartPosition { get; private set; }
+        this.ArchiveEncoding = archiveEncoding;
+    }
 
-        public ArcEntryHeader(ArchiveEncoding archiveEncoding)
+    public ArcEntryHeader? ReadHeader(Stream stream)
+    {
+        byte[] headerBytes = new byte[29];
+        if (stream.Read(headerBytes, 0, headerBytes.Length) != headerBytes.Length)
         {
-            this.ArchiveEncoding = archiveEncoding;
+            return null;
         }
+        DataStartPosition = stream.Position;
+        return LoadFrom(headerBytes);
+    }
 
-        public ArcEntryHeader? ReadHeader(Stream stream)
+    public ArcEntryHeader LoadFrom(byte[] headerBytes)
+    {
+        CompressionMethod = GetCompressionType(headerBytes[1]);
+
+        // Read name
+        int nameEnd = Array.IndexOf(headerBytes, (byte)0, 1); // Find null terminator
+        Name = Encoding.UTF8.GetString(headerBytes, 2, nameEnd > 0 ? nameEnd - 2 : 12);
+
+        int offset = 15;
+        CompressedSize = BitConverter.ToUInt32(headerBytes, offset);
+        offset += 4;
+        uint rawDateTime = BitConverter.ToUInt32(headerBytes, offset);
+        DateTime = ConvertToDateTime(rawDateTime);
+        offset += 4;
+        Crc16 = BitConverter.ToUInt16(headerBytes, offset);
+        offset += 2;
+        OriginalSize = BitConverter.ToUInt32(headerBytes, offset);
+        return this;
+    }
+
+    private CompressionType GetCompressionType(byte value)
+    {
+        return value switch
         {
-            byte[] headerBytes = new byte[29];
-            if (stream.Read(headerBytes, 0, headerBytes.Length) != headerBytes.Length)
-            {
-                return null;
-            }
-            DataStartPosition = stream.Position;
-            return LoadFrom(headerBytes);
-        }
+            1 or 2 => CompressionType.None,
+            3 => CompressionType.RLE90,
+            4 => CompressionType.Squeezed,
+            5 or 6 or 7 or 8 => CompressionType.Crunched,
+            9 => CompressionType.Squashed,
+            10 => CompressionType.Crushed,
+            11 => CompressionType.Distilled,
+            _ => CompressionType.Unknown,
+        };
+    }
 
-        public ArcEntryHeader LoadFrom(byte[] headerBytes)
-        {
-            CompressionMethod = GetCompressionType(headerBytes[1]);
-
-            // Read name
-            int nameEnd = Array.IndexOf(headerBytes, (byte)0, 1); // Find null terminator
-            Name = Encoding.UTF8.GetString(headerBytes, 2, nameEnd > 0 ? nameEnd - 2 : 12);
-
-            int offset = 15;
-            CompressedSize = BitConverter.ToUInt32(headerBytes, offset);
-            offset += 4;
-            uint rawDateTime = BitConverter.ToUInt32(headerBytes, offset);
-            DateTime = ConvertToDateTime(rawDateTime);
-            offset += 4;
-            Crc16 = BitConverter.ToUInt16(headerBytes, offset);
-            offset += 2;
-            OriginalSize = BitConverter.ToUInt32(headerBytes, offset);
-            return this;
-        }
-
-        private CompressionType GetCompressionType(byte value)
-        {
-            return value switch
-            {
-                1 or 2 => CompressionType.None,
-                3 => CompressionType.Packed,
-                4 => CompressionType.Squeezed,
-                5 or 6 or 7 or 8 => CompressionType.Crunched,
-                9 => CompressionType.Squashed,
-                10 => CompressionType.Crushed,
-                11 => CompressionType.Distilled,
-                _ => CompressionType.Unknown,
-            };
-        }
-
-        public static DateTime ConvertToDateTime(long rawDateTime)
-        {
-            // Convert Unix timestamp to DateTime (UTC)
-            return DateTimeOffset.FromUnixTimeSeconds(rawDateTime).UtcDateTime;
-        }
+    public static DateTime ConvertToDateTime(long rawDateTime)
+    {
+        // Convert Unix timestamp to DateTime (UTC)
+        return DateTimeOffset.FromUnixTimeSeconds(rawDateTime).UtcDateTime;
     }
 }

src/SharpCompress/Common/Arc/ArcFilePart.cs

@@ -13,71 +13,55 @@ using SharpCompress.Compressors.RLE90;
 using SharpCompress.Compressors.Squeezed;
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public class ArcFilePart : FilePart
 {
-    public class ArcFilePart : FilePart
+    private readonly Stream? _stream;
+
+    internal ArcFilePart(ArcEntryHeader localArcHeader, Stream? seekableStream)
+        : base(localArcHeader.ArchiveEncoding)
     {
-        private readonly Stream? _stream;
-
-        internal ArcFilePart(ArcEntryHeader localArcHeader, Stream? seekableStream)
-            : base(localArcHeader.ArchiveEncoding)
-        {
-            _stream = seekableStream;
-            Header = localArcHeader;
-        }
-
-        internal ArcEntryHeader Header { get; set; }
-
-        internal override string? FilePartName => Header.Name;
-
-        internal override Stream GetCompressedStream()
-        {
-            if (_stream != null)
-            {
-                Stream compressedStream;
-                switch (Header.CompressionMethod)
-                {
-                    case CompressionType.None:
-                        compressedStream = new ReadOnlySubStream(
-                            _stream,
-                            Header.DataStartPosition,
-                            Header.CompressedSize
-                        );
-                        break;
-                    case CompressionType.Packed:
-                        compressedStream = new RunLength90Stream(
-                            _stream,
-                            (int)Header.CompressedSize
-                        );
-                        break;
-                    case CompressionType.Squeezed:
-                        compressedStream = new SqueezeStream(_stream, (int)Header.CompressedSize);
-                        break;
-                    case CompressionType.Crunched:
-                        if (Header.OriginalSize > 128 * 1024)
-                        {
-                            throw new NotSupportedException(
-                                "CompressionMethod: "
-                                    + Header.CompressionMethod
-                                    + " with size > 128KB"
-                            );
-                        }
-                        compressedStream = new ArcLzwStream(
-                            _stream,
-                            (int)Header.CompressedSize,
-                            true
-                        );
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            "CompressionMethod: " + Header.CompressionMethod
-                        );
-                }
-                return compressedStream;
-            }
-            return _stream.NotNull();
-        }
-
-        internal override Stream? GetRawStream() => _stream;
+        _stream = seekableStream;
+        Header = localArcHeader;
     }
+
+    internal ArcEntryHeader Header { get; set; }
+
+    internal override string? FilePartName => Header.Name;
+
+    internal override Stream GetCompressedStream()
+    {
+        if (_stream != null)
+        {
+            Stream compressedStream;
+            switch (Header.CompressionMethod)
+            {
+                case CompressionType.None:
+                    compressedStream = new ReadOnlySubStream(
+                        _stream,
+                        Header.DataStartPosition,
+                        Header.CompressedSize
+                    );
+                    break;
+                case CompressionType.RLE90:
+                    compressedStream = new RunLength90Stream(_stream, (int)Header.CompressedSize);
+                    break;
+                case CompressionType.Squeezed:
+                    compressedStream = new SqueezeStream(_stream, (int)Header.CompressedSize);
+                    break;
+                case CompressionType.Crunched:
+                    compressedStream = new ArcLzwStream(_stream, (int)Header.CompressedSize, true);
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        "CompressionMethod: " + Header.CompressionMethod
+                    );
+            }
+            return compressedStream;
+        }
+        return _stream.NotNull();
+    }
+
+    internal override Stream? GetRawStream() => _stream;
 }

src/SharpCompress/Common/Arc/ArcVolume.cs

@@ -6,11 +6,10 @@ using System.Text;
 using System.Threading.Tasks;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public class ArcVolume : Volume
 {
-    public class ArcVolume : Volume
-    {
-        public ArcVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-            : base(stream, readerOptions, index) { }
-    }
+    public ArcVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+        : base(stream, readerOptions, index) { }
 }

src/SharpCompress/Common/ArchiveType.cs

@@ -8,5 +8,4 @@ public enum ArchiveType
     SevenZip,
     GZip,
     Arc,
-    Arj,
 }

src/SharpCompress/Common/Arj/ArjEntry.cs

@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Arc;
-using SharpCompress.Common.Arj.Headers;
-
-namespace SharpCompress.Common.Arj
-{
-    public class ArjEntry : Entry
-    {
-        private readonly ArjFilePart _filePart;
-
-        internal ArjEntry(ArjFilePart filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override long Crc => _filePart.Header.OriginalCrc32;
-
-        public override string? Key => _filePart?.Header.Name;
-
-        public override string? LinkTarget => null;
-
-        public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
-
-        public override CompressionType CompressionType
-        {
-            get
-            {
-                if (_filePart.Header.CompressionMethod == CompressionMethod.Stored)
-                {
-                    return CompressionType.None;
-                }
-                return CompressionType.ArjLZ77;
-            }
-        }
-
-        public override long Size => _filePart?.Header.OriginalSize ?? 0;
-
-        public override DateTime? LastModifiedTime => _filePart.Header.DateTimeModified.DateTime;
-
-        public override DateTime? CreatedTime => _filePart.Header.DateTimeCreated.DateTime;
-
-        public override DateTime? LastAccessedTime => _filePart.Header.DateTimeAccessed.DateTime;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => _filePart.Header.FileType == FileType.Directory;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
-    }
-}

src/SharpCompress/Common/Arj/ArjFilePart.cs

@@ -1,72 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Arj.Headers;
-using SharpCompress.Compressors.Arj;
-using SharpCompress.IO;
-
-namespace SharpCompress.Common.Arj
-{
-    public class ArjFilePart : FilePart
-    {
-        private readonly Stream _stream;
-        internal ArjLocalHeader Header { get; set; }
-
-        internal ArjFilePart(ArjLocalHeader localArjHeader, Stream seekableStream)
-            : base(localArjHeader.ArchiveEncoding)
-        {
-            _stream = seekableStream;
-            Header = localArjHeader;
-        }
-
-        internal override string? FilePartName => Header.Name;
-
-        internal override Stream GetCompressedStream()
-        {
-            if (_stream != null)
-            {
-                Stream compressedStream;
-                switch (Header.CompressionMethod)
-                {
-                    case CompressionMethod.Stored:
-                        compressedStream = new ReadOnlySubStream(
-                            _stream,
-                            Header.DataStartPosition,
-                            Header.CompressedSize
-                        );
-                        break;
-                    case CompressionMethod.CompressedMost:
-                    case CompressionMethod.Compressed:
-                    case CompressionMethod.CompressedFaster:
-                        if (Header.OriginalSize > 128 * 1024)
-                        {
-                            throw new NotSupportedException(
-                                "CompressionMethod: "
-                                    + Header.CompressionMethod
-                                    + " with size > 128KB"
-                            );
-                        }
-                        compressedStream = new LhaStream<Lh7DecoderCfg>(
-                            _stream,
-                            (int)Header.OriginalSize
-                        );
-                        break;
-                    case CompressionMethod.CompressedFastest:
-                        compressedStream = new LHDecoderStream(_stream, (int)Header.OriginalSize);
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            "CompressionMethod: " + Header.CompressionMethod
-                        );
-                }
-                return compressedStream;
-            }
-            return _stream.NotNull();
-        }
-
-        internal override Stream GetRawStream() => _stream;
-    }
-}

src/SharpCompress/Common/Arj/ArjVolume.cs

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

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

@@ -1,142 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Zip.Headers;
-using SharpCompress.Crypto;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public enum ArjHeaderType
-    {
-        MainHeader,
-        LocalHeader,
-    }
-
-    public abstract class ArjHeader
-    {
-        private const int FIRST_HDR_SIZE = 34;
-        private const ushort ARJ_MAGIC = 0xEA60;
-
-        public ArjHeader(ArjHeaderType type)
-        {
-            ArjHeaderType = type;
-        }
-
-        public ArjHeaderType ArjHeaderType { get; }
-        public byte Flags { get; set; }
-        public FileType FileType { get; set; }
-
-        public abstract ArjHeader? Read(Stream reader);
-
-        public byte[] ReadHeader(Stream stream)
-        {
-            // check for magic bytes
-            Span<byte> magic = stackalloc byte[2];
-            if (stream.Read(magic) != 2)
-            {
-                return Array.Empty<byte>();
-            }
-
-            var magicValue = (ushort)(magic[0] | magic[1] << 8);
-            if (magicValue != ARJ_MAGIC)
-            {
-                throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
-            }
-
-            // read header_size
-            byte[] headerBytes = new byte[2];
-            stream.Read(headerBytes, 0, 2);
-            var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
-            if (headerSize < 1)
-            {
-                return Array.Empty<byte>();
-            }
-
-            var body = new byte[headerSize];
-            var read = stream.Read(body, 0, headerSize);
-            if (read < headerSize)
-            {
-                return Array.Empty<byte>();
-            }
-
-            byte[] crc = new byte[4];
-            read = stream.Read(crc, 0, 4);
-            var checksum = Crc32Stream.Compute(body);
-            // Compute the hash value
-            if (checksum != BitConverter.ToUInt32(crc, 0))
-            {
-                throw new InvalidDataException("Header checksum is invalid");
-            }
-            return body;
-        }
-
-        protected List<byte[]> ReadExtendedHeaders(Stream reader)
-        {
-            List<byte[]> extendedHeader = new List<byte[]>();
-            byte[] buffer = new byte[2];
-
-            while (true)
-            {
-                int bytesRead = reader.Read(buffer, 0, 2);
-                if (bytesRead < 2)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header size."
-                    );
-                }
-
-                var extHeaderSize = (ushort)(buffer[0] | (buffer[1] << 8));
-                if (extHeaderSize == 0)
-                {
-                    return extendedHeader;
-                }
-
-                byte[] header = new byte[extHeaderSize];
-                bytesRead = reader.Read(header, 0, extHeaderSize);
-                if (bytesRead < extHeaderSize)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header data."
-                    );
-                }
-
-                byte[] crc = new byte[4];
-                bytesRead = reader.Read(crc, 0, 4);
-                if (bytesRead < 4)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header CRC."
-                    );
-                }
-
-                var checksum = Crc32Stream.Compute(header);
-                if (checksum != BitConverter.ToUInt32(crc, 0))
-                {
-                    throw new InvalidDataException("Extended header checksum is invalid");
-                }
-
-                extendedHeader.Add(header);
-            }
-        }
-
-        // Flag helpers
-        public bool IsGabled => (Flags & 0x01) != 0;
-        public bool IsAnsiPage => (Flags & 0x02) != 0;
-        public bool IsVolume => (Flags & 0x04) != 0;
-        public bool IsArjProtected => (Flags & 0x08) != 0;
-        public bool IsPathSym => (Flags & 0x10) != 0;
-        public bool IsBackup => (Flags & 0x20) != 0;
-        public bool IsSecured => (Flags & 0x40) != 0;
-        public bool IsAltName => (Flags & 0x80) != 0;
-
-        public static FileType FileTypeFromByte(byte value)
-        {
-            return Enum.IsDefined(typeof(FileType), value)
-                ? (FileType)value
-                : Headers.FileType.Unknown;
-        }
-    }
-}

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

@@ -1,161 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public class ArjLocalHeader : ArjHeader
-    {
-        public ArchiveEncoding ArchiveEncoding { get; }
-        public long DataStartPosition { get; protected set; }
-
-        public byte ArchiverVersionNumber { get; set; }
-        public byte MinVersionToExtract { get; set; }
-        public HostOS HostOS { get; set; }
-        public CompressionMethod CompressionMethod { get; set; }
-        public DosDateTime DateTimeModified { get; set; } = new DosDateTime(0);
-        public long CompressedSize { get; set; }
-        public long OriginalSize { get; set; }
-        public long OriginalCrc32 { get; set; }
-        public int FileSpecPosition { get; set; }
-        public int FileAccessMode { get; set; }
-        public byte FirstChapter { get; set; }
-        public byte LastChapter { get; set; }
-        public long ExtendedFilePosition { get; set; }
-        public DosDateTime DateTimeAccessed { get; set; } = new DosDateTime(0);
-        public DosDateTime DateTimeCreated { get; set; } = new DosDateTime(0);
-        public long OriginalSizeEvenForVolumes { get; set; }
-        public string Name { get; set; } = string.Empty;
-        public string Comment { get; set; } = string.Empty;
-
-        private const byte StdHdrSize = 30;
-        private const byte R9HdrSize = 46;
-
-        public ArjLocalHeader(ArchiveEncoding archiveEncoding)
-            : base(ArjHeaderType.LocalHeader)
-        {
-            ArchiveEncoding =
-                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
-        }
-
-        public override ArjHeader? Read(Stream stream)
-        {
-            var body = ReadHeader(stream);
-            if (body.Length > 0)
-            {
-                ReadExtendedHeaders(stream);
-                var header = LoadFrom(body);
-                header.DataStartPosition = stream.Position;
-                return header;
-            }
-            return null;
-        }
-
-        public ArjLocalHeader LoadFrom(byte[] headerBytes)
-        {
-            int offset = 0;
-
-            int ReadInt16()
-            {
-                if (offset + 1 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
-                offset += 2;
-                return v;
-            }
-            long ReadInt32()
-            {
-                if (offset + 3 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                long v =
-                    headerBytes[offset] & 0xFF
-                    | (headerBytes[offset + 1] & 0xFF) << 8
-                    | (headerBytes[offset + 2] & 0xFF) << 16
-                    | (headerBytes[offset + 3] & 0xFF) << 24;
-                offset += 4;
-                return v;
-            }
-
-            byte headerSize = headerBytes[offset++];
-            ArchiverVersionNumber = headerBytes[offset++];
-            MinVersionToExtract = headerBytes[offset++];
-            HostOS hostOS = (HostOS)headerBytes[offset++];
-            Flags = headerBytes[offset++];
-            CompressionMethod = CompressionMethodFromByte(headerBytes[offset++]);
-            FileType = FileTypeFromByte(headerBytes[offset++]);
-
-            offset++; // Skip 1 byte
-
-            var rawTimestamp = ReadInt32();
-            DateTimeModified =
-                rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
-
-            CompressedSize = ReadInt32();
-            OriginalSize = ReadInt32();
-            OriginalCrc32 = ReadInt32();
-            FileSpecPosition = ReadInt16();
-            FileAccessMode = ReadInt16();
-
-            FirstChapter = headerBytes[offset++];
-            LastChapter = headerBytes[offset++];
-
-            ExtendedFilePosition = 0;
-            OriginalSizeEvenForVolumes = 0;
-
-            if (headerSize > StdHdrSize)
-            {
-                ExtendedFilePosition = ReadInt32();
-
-                if (headerSize >= R9HdrSize)
-                {
-                    rawTimestamp = ReadInt32();
-                    DateTimeAccessed =
-                        rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
-                    rawTimestamp = ReadInt32();
-                    DateTimeCreated =
-                        rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
-                    OriginalSizeEvenForVolumes = ReadInt32();
-                }
-            }
-
-            Name = Encoding.ASCII.GetString(
-                headerBytes,
-                offset,
-                Array.IndexOf(headerBytes, (byte)0, offset) - offset
-            );
-            offset += Name.Length + 1;
-
-            Comment = Encoding.ASCII.GetString(
-                headerBytes,
-                offset,
-                Array.IndexOf(headerBytes, (byte)0, offset) - offset
-            );
-            offset += Comment.Length + 1;
-
-            return this;
-        }
-
-        public static CompressionMethod CompressionMethodFromByte(byte value)
-        {
-            return value switch
-            {
-                0 => CompressionMethod.Stored,
-                1 => CompressionMethod.CompressedMost,
-                2 => CompressionMethod.Compressed,
-                3 => CompressionMethod.CompressedFaster,
-                4 => CompressionMethod.CompressedFastest,
-                8 => CompressionMethod.NoDataNoCrc,
-                9 => CompressionMethod.NoData,
-                _ => CompressionMethod.Unknown,
-            };
-        }
-    }
-}

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

@@ -1,138 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-using SharpCompress.Compressors.Deflate;
-using SharpCompress.Crypto;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public class ArjMainHeader : ArjHeader
-    {
-        private const int FIRST_HDR_SIZE = 34;
-        private const ushort ARJ_MAGIC = 0xEA60;
-
-        public ArchiveEncoding ArchiveEncoding { get; }
-
-        public int ArchiverVersionNumber { get; private set; }
-        public int MinVersionToExtract { get; private set; }
-        public HostOS HostOs { get; private set; }
-        public int SecurityVersion { get; private set; }
-        public DosDateTime CreationDateTime { get; private set; } = new DosDateTime(0);
-        public long CompressedSize { get; private set; }
-        public long ArchiveSize { get; private set; }
-        public long SecurityEnvelope { get; private set; }
-        public int FileSpecPosition { get; private set; }
-        public int SecurityEnvelopeLength { get; private set; }
-        public int EncryptionVersion { get; private set; }
-        public int LastChapter { get; private set; }
-
-        public int ArjProtectionFactor { get; private set; }
-        public int Flags2 { get; private set; }
-        public string Name { get; private set; } = string.Empty;
-        public string Comment { get; private set; } = string.Empty;
-
-        public ArjMainHeader(ArchiveEncoding archiveEncoding)
-            : base(ArjHeaderType.MainHeader)
-        {
-            ArchiveEncoding =
-                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
-        }
-
-        public override ArjHeader? Read(Stream stream)
-        {
-            var body = ReadHeader(stream);
-            ReadExtendedHeaders(stream);
-            return LoadFrom(body);
-        }
-
-        public ArjMainHeader LoadFrom(byte[] headerBytes)
-        {
-            var offset = 1;
-
-            byte ReadByte()
-            {
-                if (offset >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                return (byte)(headerBytes[offset++] & 0xFF);
-            }
-
-            int ReadInt16()
-            {
-                if (offset + 1 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
-                offset += 2;
-                return v;
-            }
-
-            long ReadInt32()
-            {
-                if (offset + 3 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                long v =
-                    headerBytes[offset] & 0xFF
-                    | (headerBytes[offset + 1] & 0xFF) << 8
-                    | (headerBytes[offset + 2] & 0xFF) << 16
-                    | (headerBytes[offset + 3] & 0xFF) << 24;
-                offset += 4;
-                return v;
-            }
-            string ReadNullTerminatedString(byte[] x, int startIndex)
-            {
-                var result = new StringBuilder();
-                int i = startIndex;
-
-                while (i < x.Length && x[i] != 0)
-                {
-                    result.Append((char)x[i]);
-                    i++;
-                }
-
-                // Skip the null terminator
-                i++;
-                if (i < x.Length)
-                {
-                    byte[] remainder = new byte[x.Length - i];
-                    Array.Copy(x, i, remainder, 0, remainder.Length);
-                    x = remainder;
-                }
-
-                return result.ToString();
-            }
-
-            ArchiverVersionNumber = ReadByte();
-            MinVersionToExtract = ReadByte();
-
-            var hostOsByte = ReadByte();
-            HostOs = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
-
-            Flags = ReadByte();
-            SecurityVersion = ReadByte();
-            FileType = FileTypeFromByte(ReadByte());
-
-            offset++; // skip reserved
-
-            CreationDateTime = new DosDateTime((int)ReadInt32());
-            CompressedSize = ReadInt32();
-            ArchiveSize = ReadInt32();
-
-            SecurityEnvelope = ReadInt32();
-            FileSpecPosition = ReadInt16();
-            SecurityEnvelopeLength = ReadInt16();
-
-            EncryptionVersion = ReadByte();
-            LastChapter = ReadByte();
-
-            Name = ReadNullTerminatedString(headerBytes, offset);
-            Comment = ReadNullTerminatedString(headerBytes, offset + 1 + Name.Length);
-
-            return this;
-        }
-    }
-}

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

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public enum CompressionMethod
-    {
-        Stored = 0,
-        CompressedMost = 1,
-        Compressed = 2,
-        CompressedFaster = 3,
-        CompressedFastest = 4,
-        NoDataNoCrc = 8,
-        NoData = 9,
-        Unknown,
-    }
-}

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

@@ -1,37 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public class DosDateTime
-    {
-        public DateTime DateTime { get; }
-
-        public DosDateTime(long dosValue)
-        {
-            // Ensure only the lower 32 bits are used
-            int value = unchecked((int)(dosValue & 0xFFFFFFFF));
-
-            var date = (value >> 16) & 0xFFFF;
-            var time = value & 0xFFFF;
-
-            var day = date & 0x1F;
-            var month = (date >> 5) & 0x0F;
-            var year = ((date >> 9) & 0x7F) + 1980;
-
-            var second = (time & 0x1F) * 2;
-            var minute = (time >> 5) & 0x3F;
-            var hour = (time >> 11) & 0x1F;
-
-            try
-            {
-                DateTime = new DateTime(year, month, day, hour, minute, second);
-            }
-            catch
-            {
-                DateTime = DateTime.MinValue;
-            }
-        }
-
-        public override string ToString() => DateTime.ToString("yyyy-MM-dd HH:mm:ss");
-    }
-}

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

@@ -1,13 +0,0 @@
-namespace SharpCompress.Common.Arj.Headers
-{
-    public enum FileType : byte
-    {
-        Binary = 0,
-        Text7Bit = 1,
-        CommentHeader = 2,
-        Directory = 3,
-        VolumeLabel = 4,
-        ChapterLabel = 5,
-        Unknown = 255,
-    }
-}

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

@@ -1,19 +0,0 @@
-namespace SharpCompress.Common.Arj.Headers
-{
-    public enum HostOS
-    {
-        MsDos = 0,
-        PrimOS = 1,
-        Unix = 2,
-        Amiga = 3,
-        MacOs = 4,
-        OS2 = 5,
-        AppleGS = 6,
-        AtariST = 7,
-        NeXT = 8,
-        VaxVMS = 9,
-        Win95 = 10,
-        Win32 = 11,
-        Unknown = 255,
-    }
-}

src/SharpCompress/Common/CompressionType.cs

@@ -23,11 +23,10 @@ public enum CompressionType
     Reduce4,
     Explode,
     Squeezed,
-    Packed,
+    RLE90,
     Crunched,
     Squashed,
     Crushed,
     Distilled,
     ZStandard,
-    ArjLZ77,
 }

src/SharpCompress/Common/Entry.cs

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

src/SharpCompress/Common/EntryStream.cs

@@ -1,8 +1,6 @@
 using System;
 using System.IO;
 using System.IO.Compression;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -53,22 +51,8 @@ public class EntryStream : Stream, IStreamStack
         _completed = true;
     }
 
-    /// <summary>
-    /// Asynchronously skip the rest of the entry stream.
-    /// </summary>
-    public async Task SkipEntryAsync(CancellationToken cancellationToken = default)
-    {
-        await this.SkipAsync(cancellationToken).ConfigureAwait(false);
-        _completed = true;
-    }
-
     protected override void Dispose(bool disposing)
     {
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
         if (!(_completed || _reader.Cancelled))
         {
             SkipEntry();
@@ -86,6 +70,12 @@ public class EntryStream : Stream, IStreamStack
                 lzmaStream.Flush(); //Lzma over reads. Knock it back
             }
         }
+
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
 #if DEBUG_STREAMS
         this.DebugDispose(typeof(EntryStream));
 #endif
@@ -93,39 +83,6 @@ public class EntryStream : Stream, IStreamStack
         _stream.Dispose();
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask DisposeAsync()
-    {
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
-        if (!(_completed || _reader.Cancelled))
-        {
-            await SkipEntryAsync().ConfigureAwait(false);
-        }
-
-        //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
-        if (_stream is IStreamStack ss)
-        {
-            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
-            {
-                await deflateStream.FlushAsync().ConfigureAwait(false);
-            }
-            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
-            {
-                await lzmaStream.FlushAsync().ConfigureAwait(false);
-            }
-        }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(EntryStream));
-#endif
-        await base.DisposeAsync().ConfigureAwait(false);
-        await _stream.DisposeAsync().ConfigureAwait(false);
-    }
-#endif
-
     public override bool CanRead => true;
 
     public override bool CanSeek => false;
@@ -134,8 +91,6 @@ public class EntryStream : Stream, IStreamStack
 
     public override void Flush() { }
 
-    public override Task FlushAsync(CancellationToken cancellationToken) => Task.CompletedTask;
-
     public override long Length => _stream.Length;
 
     public override long Position
@@ -154,38 +109,6 @@ public class EntryStream : Stream, IStreamStack
         return read;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        var read = await _stream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (read <= 0)
-        {
-            _completed = true;
-        }
-        return read;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var read = await _stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-        if (read <= 0)
-        {
-            _completed = true;
-        }
-        return read;
-    }
-#endif
-
     public override int ReadByte()
     {
         var value = _stream.ReadByte();
@@ -202,11 +125,4 @@ public class EntryStream : Stream, IStreamStack
 
     public override void Write(byte[] buffer, int offset, int count) =>
         throw new NotSupportedException();
-
-    public override Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    ) => throw new NotSupportedException();
 }

src/SharpCompress/Common/ExtractionMethods.cs

@@ -1,22 +1,10 @@
 using System;
 using System.IO;
-using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common;
 
 internal static class ExtractionMethods
 {
-    /// <summary>
-    /// Gets the appropriate StringComparison for path checks based on the file system.
-    /// Windows uses case-insensitive file systems, while Unix-like systems use case-sensitive file systems.
-    /// </summary>
-    private static StringComparison PathComparison =>
-        RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-            ? StringComparison.OrdinalIgnoreCase
-            : StringComparison.Ordinal;
-
     /// <summary>
     /// Extract to specific directory, retaining filename
     /// </summary>
@@ -58,7 +46,7 @@ internal static class ExtractionMethods
 
             if (!Directory.Exists(destdir))
             {
-                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
+                if (!destdir.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
                 {
                     throw new ExtractionException(
                         "Entry is trying to create a directory outside of the destination directory."
@@ -78,7 +66,12 @@ internal static class ExtractionMethods
         {
             destinationFileName = Path.GetFullPath(destinationFileName);
 
-            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
+            if (
+                !destinationFileName.StartsWith(
+                    fullDestinationDirectoryPath,
+                    StringComparison.Ordinal
+                )
+            )
             {
                 throw new ExtractionException(
                     "Entry is trying to write a file outside of the destination directory."
@@ -123,111 +116,4 @@ internal static class ExtractionMethods
             entry.PreserveExtractionOptions(destinationFileName, options);
         }
     }
-
-    public static async Task WriteEntryToDirectoryAsync(
-        IEntry entry,
-        string destinationDirectory,
-        ExtractionOptions? options,
-        Func<string, ExtractionOptions?, CancellationToken, Task> writeAsync,
-        CancellationToken cancellationToken = default
-    )
-    {
-        string destinationFileName;
-        var fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
-
-        //check for trailing slash.
-        if (
-            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
-            != Path.DirectorySeparatorChar
-        )
-        {
-            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
-        }
-
-        if (!Directory.Exists(fullDestinationDirectoryPath))
-        {
-            throw new ExtractionException(
-                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
-            );
-        }
-
-        options ??= new ExtractionOptions() { Overwrite = true };
-
-        var file = Path.GetFileName(entry.Key.NotNull("Entry Key is null")).NotNull("File is null");
-        file = Utility.ReplaceInvalidFileNameChars(file);
-        if (options.ExtractFullPath)
-        {
-            var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
-                .NotNull("Directory is null");
-            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
-
-            if (!Directory.Exists(destdir))
-            {
-                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
-                {
-                    throw new ExtractionException(
-                        "Entry is trying to create a directory outside of the destination directory."
-                    );
-                }
-
-                Directory.CreateDirectory(destdir);
-            }
-            destinationFileName = Path.Combine(destdir, file);
-        }
-        else
-        {
-            destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
-        }
-
-        if (!entry.IsDirectory)
-        {
-            destinationFileName = Path.GetFullPath(destinationFileName);
-
-            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
-            {
-                throw new ExtractionException(
-                    "Entry is trying to write a file outside of the destination directory."
-                );
-            }
-            await writeAsync(destinationFileName, options, cancellationToken).ConfigureAwait(false);
-        }
-        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
-        {
-            Directory.CreateDirectory(destinationFileName);
-        }
-    }
-
-    public static async Task WriteEntryToFileAsync(
-        IEntry entry,
-        string destinationFileName,
-        ExtractionOptions? options,
-        Func<string, FileMode, CancellationToken, Task> openAndWriteAsync,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (entry.LinkTarget != null)
-        {
-            if (options?.WriteSymbolicLink is null)
-            {
-                throw new ExtractionException(
-                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
-                );
-            }
-            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
-        }
-        else
-        {
-            var fm = FileMode.Create;
-            options ??= new ExtractionOptions() { Overwrite = true };
-
-            if (!options.Overwrite)
-            {
-                fm = FileMode.CreateNew;
-            }
-
-            await openAndWriteAsync(destinationFileName, fm, cancellationToken)
-                .ConfigureAwait(false);
-            entry.PreserveExtractionOptions(destinationFileName, options);
-        }
-    }
 }

src/SharpCompress/Common/FilePart.cs

@@ -14,6 +14,4 @@ public abstract class FilePart
     internal abstract Stream? GetCompressedStream();
     internal abstract Stream? GetRawStream();
     internal bool Skipped { get; set; }
-
-    public virtual bool SupportsMultiThreading => false;
 }

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -24,14 +24,8 @@ internal sealed class GZipFilePart : FilePart
             stream.Position = stream.Length - 8;
             ReadTrailer();
             stream.Position = position;
-            EntryStartPosition = position;
-        }
-        else
-        {
-            // For non-seekable streams, we can't read the trailer or track position.
-            // Set to 0 since the stream will be read sequentially from its current position.
-            EntryStartPosition = 0;
         }
+        EntryStartPosition = stream.Position;
     }
 
     internal long EntryStartPosition { get; }

src/SharpCompress/Common/IEntry.cs

@@ -21,5 +21,4 @@ public interface IEntry
     DateTime? LastModifiedTime { get; }
     long Size { get; }
     int? Attrib { get; }
-    bool SupportsMultiThreading { get; }
 }

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -67,7 +67,6 @@ internal class SevenZipFilePart : FilePart
         }
     }
 
-    private const uint K_COPY = 0x0;
     private const uint K_LZMA2 = 0x21;
     private const uint K_LZMA = 0x030101;
     private const uint K_PPMD = 0x030401;
@@ -83,7 +82,6 @@ internal class SevenZipFilePart : FilePart
         var coder = Folder.NotNull()._coders.First();
         return coder._methodId._id switch
         {
-            K_COPY => CompressionType.None,
             K_LZMA or K_LZMA2 => CompressionType.LZMA,
             K_PPMD => CompressionType.PPMd,
             K_B_ZIP2 => CompressionType.BZip2,

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

@@ -25,10 +25,6 @@ internal sealed class TarHeader
 
     internal const int BLOCK_SIZE = 512;
 
-    // Maximum size for long name/link headers to prevent memory exhaustion attacks
-    // This is generous enough for most real-world scenarios (32KB)
-    private const int MAX_LONG_NAME_SIZE = 32768;
-
     internal void Write(Stream output)
     {
         var buffer = new byte[BLOCK_SIZE];
@@ -190,15 +186,6 @@ internal sealed class TarHeader
     private string ReadLongName(BinaryReader reader, byte[] buffer)
     {
         var size = ReadSize(buffer);
-
-        // Validate size to prevent memory exhaustion from malformed headers
-        if (size < 0 || size > MAX_LONG_NAME_SIZE)
-        {
-            throw new InvalidFormatException(
-                $"Long name size {size} is invalid or exceeds maximum allowed size of {MAX_LONG_NAME_SIZE} bytes"
-            );
-        }
-
         var nameLength = (int)size;
         var nameBytes = reader.ReadBytes(nameLength);
         var remainingBytesToRead = BLOCK_SIZE - (nameLength % BLOCK_SIZE);

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -66,36 +66,6 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
         base.Dispose(disposing);
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async System.Threading.Tasks.ValueTask DisposeAsync()
-    {
-        if (_isDisposed)
-        {
-            return;
-        }
-
-        _isDisposed = true;
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(TarReadOnlySubStream));
-#endif
-        // Ensure we read all remaining blocks for this entry.
-        await Stream.SkipAsync(BytesLeftToRead).ConfigureAwait(false);
-        _amountRead += BytesLeftToRead;
-
-        // If the last block wasn't a full 512 bytes, skip the remaining padding bytes.
-        var bytesInLastBlock = _amountRead % 512;
-
-        if (bytesInLastBlock != 0)
-        {
-            await Stream.SkipAsync(512 - bytesInLastBlock).ConfigureAwait(false);
-        }
-
-        // Call base Dispose instead of base DisposeAsync to avoid double disposal
-        base.Dispose(true);
-        GC.SuppressFinalize(this);
-    }
-#endif
-
     private long BytesLeftToRead { get; set; }
 
     public override bool CanRead => true;
@@ -106,10 +76,6 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
 
     public override void Flush() { }
 
-    public override System.Threading.Tasks.Task FlushAsync(
-        System.Threading.CancellationToken cancellationToken
-    ) => System.Threading.Tasks.Task.CompletedTask;
-
     public override long Length => throw new NotSupportedException();
 
     public override long Position
@@ -148,48 +114,6 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
         return value;
     }
 
-    public override async System.Threading.Tasks.Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken
-    )
-    {
-        if (BytesLeftToRead < count)
-        {
-            count = (int)BytesLeftToRead;
-        }
-        var read = await Stream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (read > 0)
-        {
-            BytesLeftToRead -= read;
-            _amountRead += read;
-        }
-        return read;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
-        System.Memory<byte> buffer,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (BytesLeftToRead < buffer.Length)
-        {
-            buffer = buffer.Slice(0, (int)BytesLeftToRead);
-        }
-        var read = await Stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-        if (read > 0)
-        {
-            BytesLeftToRead -= read;
-            _amountRead += read;
-        }
-        return read;
-    }
-#endif
-
     public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
 
     public override void SetLength(long value) => throw new NotSupportedException();

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

@@ -91,15 +91,8 @@ internal abstract class ZipFileEntry : ZipHeader
 
     protected void LoadExtra(byte[] extra)
     {
-        for (var i = 0; i < extra.Length; )
+        for (var i = 0; i < extra.Length - 4; )
         {
-            // Ensure we have at least a header (2-byte ID + 2-byte length)
-            if (i + 4 > extra.Length)
-            {
-                // Incomplete header — stop parsing extras
-                break;
-            }
-
             var type = (ExtraDataType)BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i));
             if (!Enum.IsDefined(typeof(ExtraDataType), type))
             {
@@ -113,17 +106,7 @@ internal abstract class ZipFileEntry : ZipHeader
             if (length > extra.Length)
             {
                 // bad extras block
-                break; // allow processing optional other blocks
-            }
-            // Some ZIP files contain vendor-specific or malformed extra fields where the declared
-            // data length extends beyond the remaining buffer. This adjustment ensures that
-            // we only read data within bounds (i + 4 + length <= extra.Length)
-            // The example here is: 41 43 18 00 41 52 43 30 46 EB FF FF 51 29 03 C6 03 00 00 00 00 00 00 00 00
-            // No existing zip utility uses 0x4341 ('AC')
-            if (i + 4 + length > extra.Length)
-            {
-                // incomplete or corrupt field
-                break; // allow processing optional other blocks
+                return;
             }
 
             var data = new byte[length];

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -1,6 +1,5 @@
 using System.IO;
 using SharpCompress.Common.Zip.Headers;
-using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
@@ -8,19 +7,13 @@ internal class SeekableZipFilePart : ZipFilePart
 {
     private bool _isLocalHeaderLoaded;
     private readonly SeekableZipHeaderFactory _headerFactory;
-    private readonly bool _isMultiVolume;
 
     internal SeekableZipFilePart(
         SeekableZipHeaderFactory headerFactory,
         DirectoryEntryHeader header,
-        Stream stream,
-        bool isMultiVolume
+        Stream stream
     )
-        : base(header, stream)
-    {
-        _headerFactory = headerFactory;
-        _isMultiVolume = isMultiVolume;
-    }
+        : base(header, stream) => _headerFactory = headerFactory;
 
     internal override Stream GetCompressedStream()
     {
@@ -37,20 +30,8 @@ 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/StreamingZipHeaderFactory.cs

@@ -36,10 +36,11 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 throw new ArgumentException("Stream must be a SharpCompressStream", nameof(stream));
             }
         }
-        var rewindableStream = (SharpCompressStream)stream;
+        SharpCompressStream rewindableStream = (SharpCompressStream)stream;
 
         while (true)
         {
+            ZipHeader? header;
             var reader = new BinaryReader(rewindableStream);
             uint headerBytes = 0;
             if (
@@ -154,7 +155,7 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
             }
 
             _lastEntryHeader = null;
-            var header = ReadHeader(headerBytes, reader);
+            header = ReadHeader(headerBytes, reader);
             if (header is null)
             {
                 yield break;

src/SharpCompress/Common/Zip/ZipFilePart.cs

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

src/SharpCompress/Compressors/ADC/ADCBase.cs

@@ -24,29 +24,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 using System;
-using System.Buffers;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Compressors.ADC;
 
-/// <summary>
-/// Result of an ADC decompression operation
-/// </summary>
-public class AdcDecompressResult
-{
-    /// <summary>
-    /// Number of bytes read from input
-    /// </summary>
-    public int BytesRead { get; set; }
-
-    /// <summary>
-    /// Decompressed output buffer
-    /// </summary>
-    public byte[]? Output { get; set; }
-}
-
 /// <summary>
 /// Provides static methods for decompressing Apple Data Compression data
 /// </summary>
@@ -97,173 +78,6 @@ public static class ADCBase
     public static int Decompress(byte[] input, out byte[]? output, int bufferSize = 262144) =>
         Decompress(new MemoryStream(input), out output, bufferSize);
 
-    /// <summary>
-    /// Decompresses a byte buffer asynchronously that's compressed with ADC
-    /// </summary>
-    /// <param name="input">Compressed buffer</param>
-    /// <param name="bufferSize">Max size for decompressed data</param>
-    /// <param name="cancellationToken">Cancellation token</param>
-    /// <returns>Result containing bytes read and decompressed data</returns>
-    public static async Task<AdcDecompressResult> DecompressAsync(
-        byte[] input,
-        int bufferSize = 262144,
-        CancellationToken cancellationToken = default
-    ) => await DecompressAsync(new MemoryStream(input), bufferSize, cancellationToken);
-
-    /// <summary>
-    /// Decompresses a stream asynchronously that's compressed with ADC
-    /// </summary>
-    /// <param name="input">Stream containing compressed data</param>
-    /// <param name="bufferSize">Max size for decompressed data</param>
-    /// <param name="cancellationToken">Cancellation token</param>
-    /// <returns>Result containing bytes read and decompressed data</returns>
-    public static async Task<AdcDecompressResult> DecompressAsync(
-        Stream input,
-        int bufferSize = 262144,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var result = new AdcDecompressResult();
-
-        if (input is null || input.Length == 0)
-        {
-            result.BytesRead = 0;
-            result.Output = null;
-            return result;
-        }
-
-        var start = (int)input.Position;
-        var position = (int)input.Position;
-        int chunkSize;
-        int offset;
-        int chunkType;
-        var buffer = ArrayPool<byte>.Shared.Rent(bufferSize);
-        var outPosition = 0;
-        var full = false;
-        byte[] temp = ArrayPool<byte>.Shared.Rent(3);
-
-        try
-        {
-            while (position < input.Length)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-                var readByte = input.ReadByte();
-                if (readByte == -1)
-                {
-                    break;
-                }
-
-                chunkType = GetChunkType((byte)readByte);
-
-                switch (chunkType)
-                {
-                    case PLAIN:
-                        chunkSize = GetChunkSize((byte)readByte);
-                        if (outPosition + chunkSize > bufferSize)
-                        {
-                            full = true;
-                            break;
-                        }
-
-                        var readCount = await input.ReadAsync(
-                            buffer,
-                            outPosition,
-                            chunkSize,
-                            cancellationToken
-                        );
-                        outPosition += readCount;
-                        position += readCount + 1;
-                        break;
-                    case TWO_BYTE:
-                        chunkSize = GetChunkSize((byte)readByte);
-                        temp[0] = (byte)readByte;
-                        temp[1] = (byte)input.ReadByte();
-                        offset = GetOffset(temp.AsSpan(0, 2));
-                        if (outPosition + chunkSize > bufferSize)
-                        {
-                            full = true;
-                            break;
-                        }
-
-                        if (offset == 0)
-                        {
-                            var lastByte = buffer[outPosition - 1];
-                            for (var i = 0; i < chunkSize; i++)
-                            {
-                                buffer[outPosition] = lastByte;
-                                outPosition++;
-                            }
-
-                            position += 2;
-                        }
-                        else
-                        {
-                            for (var i = 0; i < chunkSize; i++)
-                            {
-                                buffer[outPosition] = buffer[outPosition - offset - 1];
-                                outPosition++;
-                            }
-
-                            position += 2;
-                        }
-
-                        break;
-                    case THREE_BYTE:
-                        chunkSize = GetChunkSize((byte)readByte);
-                        temp[0] = (byte)readByte;
-                        temp[1] = (byte)input.ReadByte();
-                        temp[2] = (byte)input.ReadByte();
-                        offset = GetOffset(temp.AsSpan(0, 3));
-                        if (outPosition + chunkSize > bufferSize)
-                        {
-                            full = true;
-                            break;
-                        }
-
-                        if (offset == 0)
-                        {
-                            var lastByte = buffer[outPosition - 1];
-                            for (var i = 0; i < chunkSize; i++)
-                            {
-                                buffer[outPosition] = lastByte;
-                                outPosition++;
-                            }
-
-                            position += 3;
-                        }
-                        else
-                        {
-                            for (var i = 0; i < chunkSize; i++)
-                            {
-                                buffer[outPosition] = buffer[outPosition - offset - 1];
-                                outPosition++;
-                            }
-
-                            position += 3;
-                        }
-
-                        break;
-                }
-
-                if (full)
-                {
-                    break;
-                }
-            }
-
-            var output = new byte[outPosition];
-            Array.Copy(buffer, output, outPosition);
-            result.BytesRead = position - start;
-            result.Output = output;
-            return result;
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(buffer);
-            ArrayPool<byte>.Shared.Return(temp);
-        }
-    }
-
     /// <summary>
     /// Decompresses a stream that's compressed with ADC
     /// </summary>

src/SharpCompress/Compressors/ADC/ADCStream.cs

@@ -28,8 +28,6 @@
 
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.ADC;
@@ -189,76 +187,6 @@ public sealed class ADCStream : Stream, IStreamStack
         return copied;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (count == 0)
-        {
-            return 0;
-        }
-        if (buffer is null)
-        {
-            throw new ArgumentNullException(nameof(buffer));
-        }
-        if (count < 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(count));
-        }
-        if (offset < buffer.GetLowerBound(0))
-        {
-            throw new ArgumentOutOfRangeException(nameof(offset));
-        }
-        if ((offset + count) > buffer.GetLength(0))
-        {
-            throw new ArgumentOutOfRangeException(nameof(count));
-        }
-
-        if (_outBuffer is null)
-        {
-            var result = await ADCBase.DecompressAsync(
-                _stream,
-                cancellationToken: cancellationToken
-            );
-            _outBuffer = result.Output;
-            _outPosition = 0;
-        }
-
-        var inPosition = offset;
-        var toCopy = count;
-        var copied = 0;
-
-        while (_outPosition + toCopy >= _outBuffer.Length)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            var piece = _outBuffer.Length - _outPosition;
-            Array.Copy(_outBuffer, _outPosition, buffer, inPosition, piece);
-            inPosition += piece;
-            copied += piece;
-            _position += piece;
-            toCopy -= piece;
-            var result = await ADCBase.DecompressAsync(
-                _stream,
-                cancellationToken: cancellationToken
-            );
-            _outBuffer = result.Output;
-            _outPosition = 0;
-            if (result.BytesRead == 0 || _outBuffer is null || _outBuffer.Length == 0)
-            {
-                return copied;
-            }
-        }
-
-        Array.Copy(_outBuffer, _outPosition, buffer, inPosition, toCopy);
-        _outPosition += toCopy;
-        _position += toCopy;
-        copied += toCopy;
-        return copied;
-    }
-
     public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
 
     public override void SetLength(long value) => throw new NotSupportedException();

src/SharpCompress/Compressors/Arj/BitReader.cs

@@ -1,72 +0,0 @@
-using System;
-using System.IO;
-
-namespace SharpCompress.Compressors.Arj
-{
-    [CLSCompliant(true)]
-    public class BitReader
-    {
-        private readonly Stream _input;
-        private int _bitBuffer; // currently buffered bits
-        private int _bitCount; // number of bits in buffer
-
-        public BitReader(Stream input)
-        {
-            _input = input ?? throw new ArgumentNullException(nameof(input));
-            _bitBuffer = 0;
-            _bitCount = 0;
-        }
-
-        /// <summary>
-        /// Reads a single bit from the stream. Returns 0 or 1.
-        /// </summary>
-        public int ReadBit()
-        {
-            if (_bitCount == 0)
-            {
-                int nextByte = _input.ReadByte();
-                if (nextByte < 0)
-                {
-                    throw new EndOfStreamException("No more data available in BitReader.");
-                }
-
-                _bitBuffer = nextByte;
-                _bitCount = 8;
-            }
-
-            int bit = (_bitBuffer >> (_bitCount - 1)) & 1;
-            _bitCount--;
-            return bit;
-        }
-
-        /// <summary>
-        /// Reads n bits (up to 32) from the stream.
-        /// </summary>
-        public int ReadBits(int count)
-        {
-            if (count < 0 || count > 32)
-            {
-                throw new ArgumentOutOfRangeException(
-                    nameof(count),
-                    "Count must be between 0 and 32."
-                );
-            }
-
-            int result = 0;
-            for (int i = 0; i < count; i++)
-            {
-                result = (result << 1) | ReadBit();
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Resets any buffered bits.
-        /// </summary>
-        public void AlignToByte()
-        {
-            _bitCount = 0;
-            _bitBuffer = 0;
-        }
-    }
-}

src/SharpCompress/Compressors/Arj/HistoryIterator.cs

@@ -1,43 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace SharpCompress.Compressors.Arj
-{
-    /// <summary>
-    /// Iterator that reads & pushes values back into the ring buffer.
-    /// </summary>
-    public class HistoryIterator : IEnumerator<byte>
-    {
-        private int _index;
-        private readonly IRingBuffer _ring;
-
-        public HistoryIterator(IRingBuffer ring, int startIndex)
-        {
-            _ring = ring;
-            _index = startIndex;
-        }
-
-        public bool MoveNext()
-        {
-            Current = _ring[_index];
-            _index = unchecked(_index + 1);
-
-            // Push value back into the ring buffer
-            _ring.Push(Current);
-
-            return true; // iterator is infinite
-        }
-
-        public void Reset()
-        {
-            throw new NotSupportedException();
-        }
-
-        public byte Current { get; private set; }
-
-        object IEnumerator.Current => Current;
-
-        public void Dispose() { }
-    }
-}

src/SharpCompress/Compressors/Arj/HuffmanTree.cs

@@ -1,218 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-
-namespace SharpCompress.Compressors.Arj
-{
-    [CLSCompliant(true)]
-    public enum NodeType
-    {
-        Leaf,
-        Branch,
-    }
-
-    [CLSCompliant(true)]
-    public sealed class TreeEntry
-    {
-        public readonly NodeType Type;
-        public readonly int LeafValue;
-        public readonly int BranchIndex;
-
-        public const int MAX_INDEX = 4096;
-
-        private TreeEntry(NodeType type, int leafValue, int branchIndex)
-        {
-            Type = type;
-            LeafValue = leafValue;
-            BranchIndex = branchIndex;
-        }
-
-        public static TreeEntry Leaf(int value)
-        {
-            return new TreeEntry(NodeType.Leaf, value, -1);
-        }
-
-        public static TreeEntry Branch(int index)
-        {
-            if (index >= MAX_INDEX)
-            {
-                throw new ArgumentOutOfRangeException(
-                    nameof(index),
-                    "Branch index exceeds MAX_INDEX"
-                );
-            }
-            return new TreeEntry(NodeType.Branch, 0, index);
-        }
-    }
-
-    [CLSCompliant(true)]
-    public sealed class HuffTree
-    {
-        private readonly List<TreeEntry> _tree;
-
-        public HuffTree(int capacity = 0)
-        {
-            _tree = new List<TreeEntry>(capacity);
-        }
-
-        public void SetSingle(int value)
-        {
-            _tree.Clear();
-            _tree.Add(TreeEntry.Leaf(value));
-        }
-
-        public void BuildTree(byte[] lengths, int count)
-        {
-            if (lengths == null)
-            {
-                throw new ArgumentNullException(nameof(lengths));
-            }
-
-            if (count < 0 || count > lengths.Length)
-            {
-                throw new ArgumentOutOfRangeException(nameof(count));
-            }
-
-            if (count > TreeEntry.MAX_INDEX / 2)
-            {
-                throw new ArgumentException(
-                    $"Count exceeds maximum allowed: {TreeEntry.MAX_INDEX / 2}"
-                );
-            }
-            byte[] slice = new byte[count];
-            Array.Copy(lengths, slice, count);
-
-            BuildTree(slice);
-        }
-
-        public void BuildTree(byte[] valueLengths)
-        {
-            if (valueLengths == null)
-            {
-                throw new ArgumentNullException(nameof(valueLengths));
-            }
-
-            if (valueLengths.Length > TreeEntry.MAX_INDEX / 2)
-            {
-                throw new InvalidOperationException("Too many code lengths");
-            }
-
-            _tree.Clear();
-
-            int maxAllocated = 1; // start with a single (root) node
-
-            for (byte currentLen = 1; ; currentLen++)
-            {
-                // add missing branches up to current limit
-                int maxLimit = maxAllocated;
-
-                for (int i = _tree.Count; i < maxLimit; i++)
-                {
-                    // TreeEntry.Branch may throw if index too large
-                    try
-                    {
-                        _tree.Add(TreeEntry.Branch(maxAllocated));
-                    }
-                    catch (ArgumentOutOfRangeException e)
-                    {
-                        _tree.Clear();
-                        throw new InvalidOperationException("Branch index exceeds limit", e);
-                    }
-
-                    // each branch node allocates two children
-                    maxAllocated += 2;
-                }
-
-                // fill tree with leaves found in the lengths table at the current length
-                bool moreLeaves = false;
-
-                for (int value = 0; value < valueLengths.Length; value++)
-                {
-                    byte len = valueLengths[value];
-                    if (len == currentLen)
-                    {
-                        _tree.Add(TreeEntry.Leaf(value));
-                    }
-                    else if (len > currentLen)
-                    {
-                        moreLeaves = true; // there are more leaves to process
-                    }
-                }
-
-                // sanity check (too many leaves)
-                if (_tree.Count > maxAllocated)
-                {
-                    throw new InvalidOperationException("Too many leaves");
-                }
-
-                // stop when no longer finding longer codes
-                if (!moreLeaves)
-                {
-                    break;
-                }
-            }
-
-            // ensure tree is complete
-            if (_tree.Count != maxAllocated)
-            {
-                throw new InvalidOperationException(
-                    $"Missing some leaves: tree count = {_tree.Count}, expected = {maxAllocated}"
-                );
-            }
-        }
-
-        public int ReadEntry(BitReader reader)
-        {
-            if (_tree.Count == 0)
-            {
-                throw new InvalidOperationException("Tree not initialized");
-            }
-
-            TreeEntry node = _tree[0];
-            while (true)
-            {
-                if (node.Type == NodeType.Leaf)
-                {
-                    return node.LeafValue;
-                }
-
-                int bit = reader.ReadBit();
-                int index = node.BranchIndex + bit;
-
-                if (index >= _tree.Count)
-                {
-                    throw new InvalidOperationException("Invalid branch index during read");
-                }
-
-                node = _tree[index];
-            }
-        }
-
-        public override string ToString()
-        {
-            var result = new StringBuilder();
-
-            void FormatStep(int index, string prefix)
-            {
-                var node = _tree[index];
-                if (node.Type == NodeType.Leaf)
-                {
-                    result.AppendLine($"{prefix} -> {node.LeafValue}");
-                }
-                else
-                {
-                    FormatStep(node.BranchIndex, prefix + "0");
-                    FormatStep(node.BranchIndex + 1, prefix + "1");
-                }
-            }
-
-            if (_tree.Count > 0)
-            {
-                FormatStep(0, "");
-            }
-
-            return result.ToString();
-        }
-    }
-}

src/SharpCompress/Compressors/Arj/ILhaDecoderConfig.cs

@@ -1,9 +0,0 @@
-namespace SharpCompress.Compressors.Arj
-{
-    public interface ILhaDecoderConfig
-    {
-        int HistoryBits { get; }
-        int OffsetBits { get; }
-        RingBuffer RingBuffer { get; }
-    }
-}

src/SharpCompress/Compressors/Arj/IRingBuffer.cs

@@ -1,17 +0,0 @@
-namespace SharpCompress.Compressors.Arj
-{
-    public interface IRingBuffer
-    {
-        int BufferSize { get; }
-
-        int Cursor { get; }
-        void SetCursor(int pos);
-
-        void Push(byte value);
-
-        HistoryIterator IterFromOffset(int offset);
-        HistoryIterator IterFromPos(int pos);
-
-        byte this[int index] { get; }
-    }
-}

src/SharpCompress/Compressors/Arj/LHDecoderStream.cs

@@ -1,191 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.IO;
-
-namespace SharpCompress.Compressors.Arj
-{
-    [CLSCompliant(true)]
-    public sealed class LHDecoderStream : Stream, IStreamStack
-    {
-#if DEBUG_STREAMS
-        long IStreamStack.InstanceId { get; set; }
-#endif
-        int IStreamStack.DefaultBufferSize { get; set; }
-
-        Stream IStreamStack.BaseStream() => _stream;
-
-        int IStreamStack.BufferSize
-        {
-            get => 0;
-            set { }
-        }
-        int IStreamStack.BufferPosition
-        {
-            get => 0;
-            set { }
-        }
-
-        void IStreamStack.SetPosition(long position) { }
-
-        private readonly BitReader _bitReader;
-        private readonly Stream _stream;
-
-        // Buffer containing *all* bytes decoded so far.
-        private readonly List<byte> _buffer = new();
-
-        private long _readPosition;
-        private readonly int _originalSize;
-        private bool _finishedDecoding;
-        private bool _disposed;
-
-        private const int THRESHOLD = 3;
-
-        public LHDecoderStream(Stream compressedStream, int originalSize)
-        {
-            _stream = compressedStream ?? throw new ArgumentNullException(nameof(compressedStream));
-            if (!compressedStream.CanRead)
-                throw new ArgumentException(
-                    "compressedStream must be readable.",
-                    nameof(compressedStream)
-                );
-
-            _bitReader = new BitReader(compressedStream);
-            _originalSize = originalSize;
-            _readPosition = 0;
-            _finishedDecoding = (originalSize == 0);
-        }
-
-        public Stream BaseStream => _stream;
-
-        public override bool CanRead => true;
-        public override bool CanSeek => false;
-        public override bool CanWrite => false;
-
-        public override long Length => _originalSize;
-
-        public override long Position
-        {
-            get => _readPosition;
-            set => throw new NotSupportedException();
-        }
-
-        /// <summary>
-        /// Decodes a single element (literal or back-reference) and appends it to _buffer.
-        /// Returns true if data was added, or false if all input has already been decoded.
-        /// </summary>
-        private bool DecodeNext()
-        {
-            if (_buffer.Count >= _originalSize)
-            {
-                _finishedDecoding = true;
-                return false;
-            }
-
-            int len = DecodeVal(0, 7);
-            if (len == 0)
-            {
-                byte nextChar = (byte)_bitReader.ReadBits(8);
-                _buffer.Add(nextChar);
-            }
-            else
-            {
-                int repCount = len + THRESHOLD - 1;
-                int backPtr = DecodeVal(9, 13);
-
-                if (backPtr >= _buffer.Count)
-                    throw new InvalidDataException("Invalid back_ptr in LH stream");
-
-                int srcIndex = _buffer.Count - 1 - backPtr;
-                for (int j = 0; j < repCount && _buffer.Count < _originalSize; j++)
-                {
-                    byte b = _buffer[srcIndex];
-                    _buffer.Add(b);
-                    srcIndex++;
-                    // srcIndex may grow; it's allowed (source region can overlap destination)
-                }
-            }
-
-            if (_buffer.Count >= _originalSize)
-            {
-                _finishedDecoding = true;
-            }
-
-            return true;
-        }
-
-        private int DecodeVal(int from, int to)
-        {
-            int add = 0;
-            int bit = from;
-
-            while (bit < to && _bitReader.ReadBits(1) == 1)
-            {
-                add |= 1 << bit;
-                bit++;
-            }
-
-            int res = bit > 0 ? _bitReader.ReadBits(bit) : 0;
-            return res + add;
-        }
-
-        /// <summary>
-        /// Reads decompressed bytes into buffer[offset..offset+count].
-        /// The method decodes additional data on demand when needed.
-        /// </summary>
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_disposed)
-                throw new ObjectDisposedException(nameof(LHDecoderStream));
-            if (buffer == null)
-                throw new ArgumentNullException(nameof(buffer));
-            if (offset < 0 || count < 0 || offset + count > buffer.Length)
-                throw new ArgumentOutOfRangeException("offset/count");
-
-            if (_readPosition >= _originalSize)
-                return 0; // EOF
-
-            int totalRead = 0;
-
-            while (totalRead < count && _readPosition < _originalSize)
-            {
-                if (_readPosition >= _buffer.Count)
-                {
-                    bool had = DecodeNext();
-                    if (!had)
-                    {
-                        break;
-                    }
-                }
-
-                int available = _buffer.Count - (int)_readPosition;
-                if (available <= 0)
-                {
-                    if (!_finishedDecoding)
-                    {
-                        continue;
-                    }
-                    break;
-                }
-
-                int toCopy = Math.Min(available, count - totalRead);
-                _buffer.CopyTo((int)_readPosition, buffer, offset + totalRead, toCopy);
-
-                _readPosition += toCopy;
-                totalRead += toCopy;
-            }
-
-            return totalRead;
-        }
-
-        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();
-    }
-}

src/SharpCompress/Compressors/Arj/Lh5DecoderCfg.cs

@@ -1,9 +0,0 @@
-namespace SharpCompress.Compressors.Arj
-{
-    public class Lh5DecoderCfg : ILhaDecoderConfig
-    {
-        public int HistoryBits => 14;
-        public int OffsetBits => 4;
-        public RingBuffer RingBuffer { get; } = new RingBuffer(1 << 14);
-    }
-}

src/SharpCompress/Compressors/Arj/Lh7DecoderCfg.cs

@@ -1,9 +0,0 @@
-namespace SharpCompress.Compressors.Arj
-{
-    public class Lh7DecoderCfg : ILhaDecoderConfig
-    {
-        public int HistoryBits => 17;
-        public int OffsetBits => 5;
-        public RingBuffer RingBuffer { get; } = new RingBuffer(1 << 17);
-    }
-}

src/SharpCompress/Compressors/Arj/LhaStream.cs

@@ -1,363 +0,0 @@
-using System;
-using System.Data;
-using System.IO;
-using System.Linq;
-using SharpCompress.IO;
-
-namespace SharpCompress.Compressors.Arj
-{
-    [CLSCompliant(true)]
-    public sealed class LhaStream<C> : Stream, IStreamStack
-        where C : ILhaDecoderConfig, new()
-    {
-        private readonly BitReader _bitReader;
-        private readonly Stream _stream;
-
-        private readonly HuffTree _commandTree;
-        private readonly HuffTree _offsetTree;
-        private int _remainingCommands;
-        private (int offset, int count)? _copyProgress;
-        private readonly RingBuffer _ringBuffer;
-        private readonly C _config = new C();
-
-        private const int NUM_COMMANDS = 510;
-        private const int NUM_TEMP_CODELEN = 20;
-
-        private readonly int _originalSize;
-        private int _producedBytes = 0;
-
-#if DEBUG_STREAMS
-        long IStreamStack.InstanceId { get; set; }
-#endif
-        int IStreamStack.DefaultBufferSize { get; set; }
-
-        Stream IStreamStack.BaseStream() => _stream;
-
-        int IStreamStack.BufferSize
-        {
-            get => 0;
-            set { }
-        }
-        int IStreamStack.BufferPosition
-        {
-            get => 0;
-            set { }
-        }
-
-        void IStreamStack.SetPosition(long position) { }
-
-        public LhaStream(Stream compressedStream, int originalSize)
-        {
-            _stream = compressedStream ?? throw new ArgumentNullException(nameof(compressedStream));
-            _bitReader = new BitReader(compressedStream);
-            _ringBuffer = _config.RingBuffer;
-            _commandTree = new HuffTree(NUM_COMMANDS * 2);
-            _offsetTree = new HuffTree(NUM_TEMP_CODELEN * 2);
-            _remainingCommands = 0;
-            _copyProgress = null;
-            _originalSize = originalSize;
-        }
-
-        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() { }
-
-        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();
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (buffer == null)
-            {
-                throw new ArgumentNullException(nameof(buffer));
-            }
-            if (offset < 0 || count < 0 || (offset + count) > buffer.Length)
-            {
-                throw new ArgumentOutOfRangeException();
-            }
-
-            if (_producedBytes >= _originalSize)
-            {
-                return 0; // EOF
-            }
-            if (count == 0)
-            {
-                return 0;
-            }
-
-            int bytesRead = FillBuffer(buffer);
-            return bytesRead;
-        }
-
-        private byte ReadCodeLength()
-        {
-            byte len = (byte)_bitReader.ReadBits(3);
-            if (len == 7)
-            {
-                while (_bitReader.ReadBit() != 0)
-                {
-                    len++;
-                    if (len > 255)
-                    {
-                        throw new InvalidOperationException("Code length overflow");
-                    }
-                }
-            }
-            return len;
-        }
-
-        private int ReadCodeSkip(int skipRange)
-        {
-            int bits;
-            int increment;
-
-            switch (skipRange)
-            {
-                case 0:
-                    return 1;
-                case 1:
-                    bits = 4;
-                    increment = 3; // 3..=18
-                    break;
-                default:
-                    bits = 9;
-                    increment = 20; // 20..=531
-                    break;
-            }
-
-            int skip = _bitReader.ReadBits(bits);
-            return skip + increment;
-        }
-
-        private void ReadTempTree()
-        {
-            byte[] codeLengths = new byte[NUM_TEMP_CODELEN];
-
-            // number of codes to read (5 bits)
-            int numCodes = _bitReader.ReadBits(5);
-
-            // single code only
-            if (numCodes == 0)
-            {
-                int code = _bitReader.ReadBits(5);
-                _offsetTree.SetSingle((byte)code);
-                return;
-            }
-
-            if (numCodes > NUM_TEMP_CODELEN)
-            {
-                throw new Exception("temporary codelen table has invalid size");
-            }
-
-            // read actual lengths
-            int count = Math.Min(3, numCodes);
-            for (int i = 0; i < count; i++)
-            {
-                codeLengths[i] = (byte)ReadCodeLength();
-            }
-
-            // 2-bit skip value follows
-            int skip = _bitReader.ReadBits(2);
-
-            if (3 + skip > numCodes)
-            {
-                throw new Exception("temporary codelen table has invalid size");
-            }
-
-            for (int i = 3 + skip; i < numCodes; i++)
-            {
-                codeLengths[i] = (byte)ReadCodeLength();
-            }
-
-            _offsetTree.BuildTree(codeLengths, numCodes);
-        }
-
-        private void ReadCommandTree()
-        {
-            byte[] codeLengths = new byte[NUM_COMMANDS];
-
-            // number of codes to read (9 bits)
-            int numCodes = _bitReader.ReadBits(9);
-
-            // single code only
-            if (numCodes == 0)
-            {
-                int code = _bitReader.ReadBits(9);
-                _commandTree.SetSingle((ushort)code);
-                return;
-            }
-
-            if (numCodes > NUM_COMMANDS)
-            {
-                throw new Exception("commands codelen table has invalid size");
-            }
-
-            int index = 0;
-            while (index < numCodes)
-            {
-                for (int n = 0; n < numCodes - index; n++)
-                {
-                    int code = _offsetTree.ReadEntry(_bitReader);
-
-                    if (code >= 0 && code <= 2) // skip range
-                    {
-                        int skipCount = ReadCodeSkip(code);
-                        index += n + skipCount;
-                        goto outerLoop;
-                    }
-                    else
-                    {
-                        codeLengths[index + n] = (byte)(code - 2);
-                    }
-                }
-                break;
-
-                outerLoop:
-                ;
-            }
-
-            _commandTree.BuildTree(codeLengths, numCodes);
-        }
-
-        private void ReadOffsetTree()
-        {
-            int numCodes = _bitReader.ReadBits(_config.OffsetBits);
-            if (numCodes == 0)
-            {
-                int code = _bitReader.ReadBits(_config.OffsetBits);
-                _offsetTree.SetSingle(code);
-                return;
-            }
-
-            if (numCodes > _config.HistoryBits)
-            {
-                throw new InvalidDataException("Offset code table too large");
-            }
-
-            byte[] codeLengths = new byte[NUM_TEMP_CODELEN];
-            for (int i = 0; i < numCodes; i++)
-            {
-                codeLengths[i] = (byte)ReadCodeLength();
-            }
-
-            _offsetTree.BuildTree(codeLengths, numCodes);
-        }
-
-        private void BeginNewBlock()
-        {
-            ReadTempTree();
-            ReadCommandTree();
-            ReadOffsetTree();
-        }
-
-        private int ReadCommand() => _commandTree.ReadEntry(_bitReader);
-
-        private int ReadOffset()
-        {
-            int bits = _offsetTree.ReadEntry(_bitReader);
-            if (bits <= 1)
-            {
-                return bits;
-            }
-
-            int res = _bitReader.ReadBits(bits - 1);
-            return res | (1 << (bits - 1));
-        }
-
-        private int CopyFromHistory(byte[] target, int targetIndex, int offset, int count)
-        {
-            var historyIter = _ringBuffer.IterFromOffset(offset);
-            int copied = 0;
-
-            while (
-                copied < count && historyIter.MoveNext() && (targetIndex + copied) < target.Length
-            )
-            {
-                target[targetIndex + copied] = historyIter.Current;
-                copied++;
-            }
-
-            if (copied < count)
-            {
-                _copyProgress = (offset, count - copied);
-            }
-
-            return copied;
-        }
-
-        public int FillBuffer(byte[] buffer)
-        {
-            int bufLen = buffer.Length;
-            int bufIndex = 0;
-
-            // stop when we reached original size
-            if (_producedBytes >= _originalSize)
-            {
-                return 0;
-            }
-
-            // calculate limit, so that we don't go over the original size
-            int remaining = (int)Math.Min(bufLen, _originalSize - _producedBytes);
-
-            while (bufIndex < remaining)
-            {
-                if (_copyProgress.HasValue)
-                {
-                    var (offset, count) = _copyProgress.Value;
-                    int copied = CopyFromHistory(
-                        buffer,
-                        bufIndex,
-                        offset,
-                        (int)Math.Min(count, remaining - bufIndex)
-                    );
-                    bufIndex += copied;
-                    _copyProgress = null;
-                }
-
-                if (_remainingCommands == 0)
-                {
-                    _remainingCommands = _bitReader.ReadBits(16);
-                    if (bufIndex + _remainingCommands > remaining)
-                    {
-                        break;
-                    }
-                    BeginNewBlock();
-                }
-
-                _remainingCommands--;
-
-                int command = ReadCommand();
-
-                if (command >= 0 && command <= 0xFF)
-                {
-                    byte value = (byte)command;
-                    buffer[bufIndex++] = value;
-                    _ringBuffer.Push(value);
-                }
-                else
-                {
-                    int count = command - 0x100 + 3;
-                    int offset = ReadOffset();
-                    int copyCount = (int)Math.Min(count, remaining - bufIndex);
-                    bufIndex += CopyFromHistory(buffer, bufIndex, offset, copyCount);
-                }
-            }
-
-            _producedBytes += bufIndex;
-            return bufIndex;
-        }
-    }
-}

src/SharpCompress/Compressors/Arj/RingBuffer.cs

@@ -1,67 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-
-namespace SharpCompress.Compressors.Arj
-{
-    /// <summary>
-    /// A fixed-size ring buffer where N must be a power of two.
-    /// </summary>
-    public class RingBuffer : IRingBuffer
-    {
-        private readonly byte[] _buffer;
-        private int _cursor;
-
-        public int BufferSize { get; }
-
-        public int Cursor => _cursor;
-
-        private readonly int _mask;
-
-        public RingBuffer(int size)
-        {
-            if ((size & (size - 1)) != 0)
-            {
-                throw new ArgumentException("RingArrayBuffer size must be a power of two");
-            }
-
-            BufferSize = size;
-            _buffer = new byte[size];
-            _cursor = 0;
-            _mask = size - 1;
-
-            // Fill with spaces
-            for (int i = 0; i < size; i++)
-            {
-                _buffer[i] = (byte)' ';
-            }
-        }
-
-        public void SetCursor(int pos)
-        {
-            _cursor = pos & _mask;
-        }
-
-        public void Push(byte value)
-        {
-            int index = _cursor;
-            _buffer[index & _mask] = value;
-            _cursor = (index + 1) & _mask;
-        }
-
-        public byte this[int index] => _buffer[index & _mask];
-
-        public HistoryIterator IterFromOffset(int offset)
-        {
-            int masked = (offset & _mask) + 1;
-            int startIndex = _cursor + BufferSize - masked;
-            return new HistoryIterator(this, startIndex);
-        }
-
-        public HistoryIterator IterFromPos(int pos)
-        {
-            int startIndex = pos & _mask;
-            return new HistoryIterator(this, startIndex);
-        }
-    }
-}

src/SharpCompress/Compressors/BZip2/BZip2Stream.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.BZip2;
@@ -98,37 +96,13 @@ public sealed class BZip2Stream : Stream, IStreamStack
 
     public override void SetLength(long value) => stream.SetLength(value);
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
+#if !NETFRAMEWORK&& !NETSTANDARD2_0
 
     public override int Read(Span<byte> buffer) => stream.Read(buffer);
 
     public override void Write(ReadOnlySpan<byte> buffer) => stream.Write(buffer);
-
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    ) => await stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-
-    public override async ValueTask WriteAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken = default
-    ) => await stream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
 #endif
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    ) => await stream.ReadAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
-
-    public override async Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    ) => await stream.WriteAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
-
     public override void Write(byte[] buffer, int offset, int count) =>
         stream.Write(buffer, offset, count);
 

src/SharpCompress/Compressors/BZip2/CBZip2InputStream.cs

@@ -2,8 +2,6 @@
 
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 /*
@@ -1129,28 +1127,6 @@ internal class CBZip2InputStream : Stream, IStreamStack
         return k;
     }
 
-    public override Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var c = -1;
-        int k;
-        for (k = 0; k < count; ++k)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            c = ReadByte();
-            if (c == -1)
-            {
-                break;
-            }
-            buffer[k + offset] = (byte)c;
-        }
-        return Task.FromResult(k);
-    }
-
     public override long Seek(long offset, SeekOrigin origin) => 0;
 
     public override void SetLength(long value) { }

src/SharpCompress/Compressors/BZip2/CBZip2OutputStream.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 /*
@@ -2024,21 +2022,6 @@ internal sealed class CBZip2OutputStream : Stream, IStreamStack
         }
     }
 
-    public override Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        for (var k = 0; k < count; ++k)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            WriteByte(buffer[k + offset]);
-        }
-        return Task.CompletedTask;
-    }
-
     public override bool CanRead => false;
 
     public override bool CanSeek => false;

src/SharpCompress/Compressors/Deflate/DeflateStream.cs

@@ -28,7 +28,6 @@ using System;
 using System.IO;
 using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
@@ -290,34 +289,6 @@ public class DeflateStream : Stream, IStreamStack
         _baseStream.Flush();
     }
 
-    public override async Task FlushAsync(CancellationToken cancellationToken)
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("DeflateStream");
-        }
-        await _baseStream.FlushAsync(cancellationToken).ConfigureAwait(false);
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask DisposeAsync()
-    {
-        if (_disposed)
-        {
-            return;
-        }
-        _disposed = true;
-        if (_baseStream != null)
-        {
-            await _baseStream.DisposeAsync().ConfigureAwait(false);
-        }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(DeflateStream));
-#endif
-        await base.DisposeAsync().ConfigureAwait(false);
-    }
-#endif
-
     /// <summary>
     /// Read data from the stream.
     /// </summary>
@@ -354,36 +325,6 @@ public class DeflateStream : Stream, IStreamStack
         return _baseStream.Read(buffer, offset, count);
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("DeflateStream");
-        }
-        return await _baseStream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("DeflateStream");
-        }
-        return await _baseStream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-    }
-#endif
-
     public override int ReadByte()
     {
         if (_disposed)
@@ -445,36 +386,6 @@ public class DeflateStream : Stream, IStreamStack
         _baseStream.Write(buffer, offset, count);
     }
 
-    public override async Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("DeflateStream");
-        }
-        await _baseStream
-            .WriteAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask WriteAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("DeflateStream");
-        }
-        await _baseStream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
-    }
-#endif
-
     public override void WriteByte(byte value)
     {
         if (_disposed)

src/SharpCompress/Compressors/Deflate/GZipStream.cs

@@ -30,8 +30,6 @@ using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
@@ -259,15 +257,6 @@ public class GZipStream : Stream, IStreamStack
         BaseStream.Flush();
     }
 
-    public override async Task FlushAsync(CancellationToken cancellationToken)
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("GZipStream");
-        }
-        await BaseStream.FlushAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     /// <summary>
     ///   Read and decompress data from the source stream.
     /// </summary>
@@ -320,54 +309,6 @@ public class GZipStream : Stream, IStreamStack
         return n;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("GZipStream");
-        }
-        var n = await BaseStream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-
-        if (!_firstReadDone)
-        {
-            _firstReadDone = true;
-            FileName = BaseStream._GzipFileName;
-            Comment = BaseStream._GzipComment;
-            LastModified = BaseStream._GzipMtime;
-        }
-        return n;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("GZipStream");
-        }
-        var n = await BaseStream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-
-        if (!_firstReadDone)
-        {
-            _firstReadDone = true;
-            FileName = BaseStream._GzipFileName;
-            Comment = BaseStream._GzipComment;
-            LastModified = BaseStream._GzipMtime;
-        }
-        return n;
-    }
-#endif
-
     /// <summary>
     ///   Calling this method always throws a <see cref="NotImplementedException"/>.
     /// </summary>
@@ -427,77 +368,6 @@ public class GZipStream : Stream, IStreamStack
         BaseStream.Write(buffer, offset, count);
     }
 
-    public override async Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("GZipStream");
-        }
-        if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Undefined)
-        {
-            if (BaseStream._wantCompress)
-            {
-                // first write in compression, therefore, emit the GZIP header
-                _headerByteCount = EmitHeader();
-            }
-            else
-            {
-                throw new InvalidOperationException();
-            }
-        }
-
-        await BaseStream.WriteAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask WriteAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("GZipStream");
-        }
-        if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Undefined)
-        {
-            if (BaseStream._wantCompress)
-            {
-                // first write in compression, therefore, emit the GZIP header
-                _headerByteCount = EmitHeader();
-            }
-            else
-            {
-                throw new InvalidOperationException();
-            }
-        }
-
-        await BaseStream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
-    }
-
-    public override async ValueTask DisposeAsync()
-    {
-        if (_disposed)
-        {
-            return;
-        }
-        _disposed = true;
-        if (BaseStream != null)
-        {
-            await BaseStream.DisposeAsync().ConfigureAwait(false);
-        }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(GZipStream));
-#endif
-        await base.DisposeAsync().ConfigureAwait(false);
-    }
-#endif
-
     #endregion Stream methods
 
     public string? Comment

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -31,8 +31,6 @@ using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
 
@@ -199,69 +197,6 @@ internal class ZlibBaseStream : Stream, IStreamStack
         } while (!done);
     }
 
-    public override async Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        // workitem 7159
-        // calculate the CRC on the unccompressed data  (before writing)
-        if (crc != null)
-        {
-            crc.SlurpBlock(buffer, offset, count);
-        }
-
-        if (_streamMode == StreamMode.Undefined)
-        {
-            _streamMode = StreamMode.Writer;
-        }
-        else if (_streamMode != StreamMode.Writer)
-        {
-            throw new ZlibException("Cannot Write after Reading.");
-        }
-
-        if (count == 0)
-        {
-            return;
-        }
-
-        // first reference of z property will initialize the private var _z
-        z.InputBuffer = buffer;
-        _z.NextIn = offset;
-        _z.AvailableBytesIn = count;
-        var done = false;
-        do
-        {
-            _z.OutputBuffer = workingBuffer;
-            _z.NextOut = 0;
-            _z.AvailableBytesOut = _workingBuffer.Length;
-            var rc = (_wantCompress) ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode);
-            if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
-            {
-                throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message);
-            }
-
-            await _stream
-                .WriteAsync(
-                    _workingBuffer,
-                    0,
-                    _workingBuffer.Length - _z.AvailableBytesOut,
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
-
-            done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
-
-            // If GZIP and de-compress, we're done when 8 bytes remain.
-            if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
-            {
-                done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
-            }
-        } while (!done);
-    }
-
     private void finish()
     {
         if (_z is null)
@@ -400,111 +335,6 @@ internal class ZlibBaseStream : Stream, IStreamStack
         }
     }
 
-    private async Task finishAsync(CancellationToken cancellationToken = default)
-    {
-        if (_z is null)
-        {
-            return;
-        }
-
-        if (_streamMode == StreamMode.Writer)
-        {
-            var done = false;
-            do
-            {
-                _z.OutputBuffer = workingBuffer;
-                _z.NextOut = 0;
-                _z.AvailableBytesOut = _workingBuffer.Length;
-                var rc =
-                    (_wantCompress) ? _z.Deflate(FlushType.Finish) : _z.Inflate(FlushType.Finish);
-
-                if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
-                {
-                    var verb = (_wantCompress ? "de" : "in") + "flating";
-                    if (_z.Message is null)
-                    {
-                        throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
-                    }
-                    throw new ZlibException(verb + ": " + _z.Message);
-                }
-
-                if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
-                {
-                    await _stream
-                        .WriteAsync(
-                            _workingBuffer,
-                            0,
-                            _workingBuffer.Length - _z.AvailableBytesOut,
-                            cancellationToken
-                        )
-                        .ConfigureAwait(false);
-                }
-
-                done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
-
-                // If GZIP and de-compress, we're done when 8 bytes remain.
-                if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
-                {
-                    done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
-                }
-            } while (!done);
-
-            await FlushAsync(cancellationToken).ConfigureAwait(false);
-
-            // workitem 7159
-            if (_flavor == ZlibStreamFlavor.GZIP)
-            {
-                if (_wantCompress)
-                {
-                    // Emit the GZIP trailer: CRC32 and  size mod 2^32
-                    byte[] intBuf = new byte[4];
-                    BinaryPrimitives.WriteInt32LittleEndian(intBuf, crc.Crc32Result);
-                    await _stream.WriteAsync(intBuf, 0, 4, cancellationToken).ConfigureAwait(false);
-                    var c2 = (int)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
-                    BinaryPrimitives.WriteInt32LittleEndian(intBuf, c2);
-                    await _stream.WriteAsync(intBuf, 0, 4, cancellationToken).ConfigureAwait(false);
-                }
-                else
-                {
-                    throw new ZlibException("Writing with decompression is not supported.");
-                }
-            }
-        }
-        // workitem 7159
-        else if (_streamMode == StreamMode.Reader)
-        {
-            if (_flavor == ZlibStreamFlavor.GZIP)
-            {
-                if (!_wantCompress)
-                {
-                    // workitem 8501: handle edge case (decompress empty stream)
-                    if (_z.TotalBytesOut == 0L)
-                    {
-                        return;
-                    }
-
-                    // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-                    byte[] trailer = new byte[8];
-
-                    // workitem 8679
-                    if (_z.AvailableBytesIn != 8)
-                    {
-                        // Make sure we have read to the end of the stream
-                        _z.InputBuffer.AsSpan(_z.NextIn, _z.AvailableBytesIn).CopyTo(trailer);
-                        var bytesNeeded = 8 - _z.AvailableBytesIn;
-                        var bytesRead = await _stream
-                            .ReadAsync(trailer, _z.AvailableBytesIn, bytesNeeded, cancellationToken)
-                            .ConfigureAwait(false);
-                    }
-                }
-                else
-                {
-                    throw new ZlibException("Reading with compression is not supported.");
-                }
-            }
-        }
-    }
-
     private void end()
     {
         if (z is null)
@@ -552,38 +382,6 @@ internal class ZlibBaseStream : Stream, IStreamStack
         }
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask DisposeAsync()
-    {
-        if (isDisposed)
-        {
-            return;
-        }
-        isDisposed = true;
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(ZlibBaseStream));
-#endif
-        await base.DisposeAsync().ConfigureAwait(false);
-        if (_stream is null)
-        {
-            return;
-        }
-        try
-        {
-            await finishAsync().ConfigureAwait(false);
-        }
-        finally
-        {
-            end();
-            if (_stream != null)
-            {
-                await _stream.DisposeAsync().ConfigureAwait(false);
-                _stream = null;
-            }
-        }
-    }
-#endif
-
     public override void Flush()
     {
         _stream.Flush();
@@ -592,14 +390,6 @@ internal class ZlibBaseStream : Stream, IStreamStack
         z.AvailableBytesIn = 0;
     }
 
-    public override async Task FlushAsync(CancellationToken cancellationToken)
-    {
-        await _stream.FlushAsync(cancellationToken).ConfigureAwait(false);
-        //rewind the buffer
-        ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
-        z.AvailableBytesIn = 0;
-    }
-
     public override Int64 Seek(Int64 offset, SeekOrigin origin) =>
         throw new NotSupportedException();
 
@@ -646,31 +436,6 @@ internal class ZlibBaseStream : Stream, IStreamStack
         return _encoding.GetString(buffer, 0, buffer.Length);
     }
 
-    private async Task<string> ReadZeroTerminatedStringAsync(CancellationToken cancellationToken)
-    {
-        var list = new List<byte>();
-        var done = false;
-        do
-        {
-            // workitem 7740
-            var n = await _stream.ReadAsync(_buf1, 0, 1, cancellationToken).ConfigureAwait(false);
-            if (n != 1)
-            {
-                throw new ZlibException("Unexpected EOF reading GZIP header.");
-            }
-            if (_buf1[0] == 0)
-            {
-                done = true;
-            }
-            else
-            {
-                list.Add(_buf1[0]);
-            }
-        } while (!done);
-        var buffer = list.ToArray();
-        return _encoding.GetString(buffer, 0, buffer.Length);
-    }
-
     private int _ReadAndValidateGzipHeader()
     {
         var totalBytesRead = 0;
@@ -729,68 +494,6 @@ internal class ZlibBaseStream : Stream, IStreamStack
         return totalBytesRead;
     }
 
-    private async Task<int> _ReadAndValidateGzipHeaderAsync(CancellationToken cancellationToken)
-    {
-        var totalBytesRead = 0;
-
-        // read the header on the first read
-        byte[] header = new byte[10];
-        var n = await _stream.ReadAsync(header, 0, 10, cancellationToken).ConfigureAwait(false);
-
-        // workitem 8501: handle edge case (decompress empty stream)
-        if (n == 0)
-        {
-            return 0;
-        }
-
-        if (n != 10)
-        {
-            throw new ZlibException("Not a valid GZIP stream.");
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            throw new ZlibException("Bad GZIP header.");
-        }
-
-        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
-        _GzipMtime = TarHeader.EPOCH.AddSeconds(timet);
-        totalBytesRead += n;
-        if ((header[3] & 0x04) == 0x04)
-        {
-            // read and discard extra field
-            n = await _stream.ReadAsync(header, 0, 2, cancellationToken).ConfigureAwait(false); // 2-byte length field
-            totalBytesRead += n;
-
-            var extraLength = (short)(header[0] + header[1] * 256);
-            var extra = new byte[extraLength];
-            n = await _stream
-                .ReadAsync(extra, 0, extra.Length, cancellationToken)
-                .ConfigureAwait(false);
-            if (n != extraLength)
-            {
-                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
-            }
-            totalBytesRead += n;
-        }
-        if ((header[3] & 0x08) == 0x08)
-        {
-            _GzipFileName = await ReadZeroTerminatedStringAsync(cancellationToken)
-                .ConfigureAwait(false);
-        }
-        if ((header[3] & 0x10) == 0x010)
-        {
-            _GzipComment = await ReadZeroTerminatedStringAsync(cancellationToken)
-                .ConfigureAwait(false);
-        }
-        if ((header[3] & 0x02) == 0x02)
-        {
-            await _stream.ReadAsync(_buf1, 0, 1, cancellationToken).ConfigureAwait(false); // CRC16, ignore
-        }
-
-        return totalBytesRead;
-    }
-
     public override Int32 Read(Byte[] buffer, Int32 offset, Int32 count)
     {
         // According to MS documentation, any implementation of the IO.Stream.Read function must:
@@ -975,220 +678,6 @@ internal class ZlibBaseStream : Stream, IStreamStack
         return rc;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        // According to MS documentation, any implementation of the IO.Stream.Read function must:
-        // (a) throw an exception if offset & count reference an invalid part of the buffer,
-        //     or if count < 0, or if buffer is null
-        // (b) return 0 only upon EOF, or if count = 0
-        // (c) if not EOF, then return at least 1 byte, up to <count> bytes
-
-        if (_streamMode == StreamMode.Undefined)
-        {
-            if (!_stream.CanRead)
-            {
-                throw new ZlibException("The stream is not readable.");
-            }
-
-            // for the first read, set up some controls.
-            _streamMode = StreamMode.Reader;
-
-            // (The first reference to _z goes through the private accessor which
-            // may initialize it.)
-            z.AvailableBytesIn = 0;
-            if (_flavor == ZlibStreamFlavor.GZIP)
-            {
-                _gzipHeaderByteCount = await _ReadAndValidateGzipHeaderAsync(cancellationToken)
-                    .ConfigureAwait(false);
-
-                // workitem 8501: handle edge case (decompress empty stream)
-                if (_gzipHeaderByteCount == 0)
-                {
-                    return 0;
-                }
-            }
-        }
-
-        if (_streamMode != StreamMode.Reader)
-        {
-            throw new ZlibException("Cannot Read after Writing.");
-        }
-
-        var rc = 0;
-
-        // set up the output of the deflate/inflate codec:
-        _z.OutputBuffer = buffer;
-        _z.NextOut = offset;
-        _z.AvailableBytesOut = count;
-
-        if (count == 0)
-        {
-            return 0;
-        }
-        if (nomoreinput && _wantCompress)
-        {
-            // no more input data available; therefore we flush to
-            // try to complete the read
-            rc = _z.Deflate(FlushType.Finish);
-
-            if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
-            {
-                throw new ZlibException(
-                    String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message)
-                );
-            }
-
-            rc = (count - _z.AvailableBytesOut);
-
-            // calculate CRC after reading
-            if (crc != null)
-            {
-                crc.SlurpBlock(buffer, offset, rc);
-            }
-
-            return rc;
-        }
-        if (buffer is null)
-        {
-            throw new ArgumentNullException(nameof(buffer));
-        }
-        if (count < 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(count));
-        }
-        if (offset < buffer.GetLowerBound(0))
-        {
-            throw new ArgumentOutOfRangeException(nameof(offset));
-        }
-        if ((offset + count) > buffer.GetLength(0))
-        {
-            throw new ArgumentOutOfRangeException(nameof(count));
-        }
-
-        // This is necessary in case _workingBuffer has been resized. (new byte[])
-        // (The first reference to _workingBuffer goes through the private accessor which
-        // may initialize it.)
-        _z.InputBuffer = workingBuffer;
-
-        do
-        {
-            // need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
-            if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
-            {
-                // No data available, so try to Read data from the captive stream.
-                _z.NextIn = 0;
-                _z.AvailableBytesIn = await _stream
-                    .ReadAsync(_workingBuffer, 0, _workingBuffer.Length, cancellationToken)
-                    .ConfigureAwait(false);
-                if (_z.AvailableBytesIn == 0)
-                {
-                    nomoreinput = true;
-                }
-            }
-
-            // we have data in InputBuffer; now compress or decompress as appropriate
-            rc = (_wantCompress) ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode);
-
-            if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
-            {
-                return 0;
-            }
-
-            if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
-            {
-                throw new ZlibException(
-                    String.Format(
-                        "{0}flating:  rc={1}  msg={2}",
-                        (_wantCompress ? "de" : "in"),
-                        rc,
-                        _z.Message
-                    )
-                );
-            }
-
-            if (
-                (nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count)
-            )
-            {
-                break; // nothing more to read
-            }
-        } //while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
-        while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);
-
-        // workitem 8557
-        // is there more room in output?
-        if (_z.AvailableBytesOut > 0)
-        {
-            if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
-            {
-                // deferred
-            }
-
-            // are we completely done reading?
-            if (nomoreinput)
-            {
-                // and in compression?
-                if (_wantCompress)
-                {
-                    // no more input data available; therefore we flush to
-                    // try to complete the read
-                    rc = _z.Deflate(FlushType.Finish);
-
-                    if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
-                    {
-                        throw new ZlibException(
-                            String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message)
-                        );
-                    }
-                }
-            }
-        }
-
-        rc = (count - _z.AvailableBytesOut);
-
-        // calculate CRC after reading
-        if (crc != null)
-        {
-            crc.SlurpBlock(buffer, offset, rc);
-        }
-
-        if (rc == ZlibConstants.Z_STREAM_END && z.AvailableBytesIn != 0 && !_wantCompress)
-        {
-            //rewind the buffer
-            ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
-            z.AvailableBytesIn = 0;
-        }
-
-        return rc;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        // Use ArrayPool to rent a buffer and delegate to byte[] ReadAsync
-        byte[] array = System.Buffers.ArrayPool<byte>.Shared.Rent(buffer.Length);
-        try
-        {
-            int read = await ReadAsync(array, 0, buffer.Length, cancellationToken)
-                .ConfigureAwait(false);
-            array.AsSpan(0, read).CopyTo(buffer.Span);
-            return read;
-        }
-        finally
-        {
-            System.Buffers.ArrayPool<byte>.Shared.Return(array);
-        }
-    }
-#endif
-
     public override Boolean CanRead => _stream.CanRead;
 
     public override Boolean CanSeek => _stream.CanSeek;

src/SharpCompress/Compressors/Deflate/ZlibStream.cs

@@ -28,8 +28,6 @@
 using System;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
@@ -268,34 +266,6 @@ public class ZlibStream : Stream, IStreamStack
         _baseStream.Flush();
     }
 
-    public override async Task FlushAsync(CancellationToken cancellationToken)
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("ZlibStream");
-        }
-        await _baseStream.FlushAsync(cancellationToken).ConfigureAwait(false);
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask DisposeAsync()
-    {
-        if (_disposed)
-        {
-            return;
-        }
-        _disposed = true;
-        if (_baseStream != null)
-        {
-            await _baseStream.DisposeAsync().ConfigureAwait(false);
-        }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(ZlibStream));
-#endif
-        await base.DisposeAsync().ConfigureAwait(false);
-    }
-#endif
-
     /// <summary>
     /// Read data from the stream.
     /// </summary>
@@ -331,36 +301,6 @@ public class ZlibStream : Stream, IStreamStack
         return _baseStream.Read(buffer, offset, count);
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("ZlibStream");
-        }
-        return await _baseStream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("ZlibStream");
-        }
-        return await _baseStream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-    }
-#endif
-
     public override int ReadByte()
     {
         if (_disposed)
@@ -415,36 +355,6 @@ public class ZlibStream : Stream, IStreamStack
         _baseStream.Write(buffer, offset, count);
     }
 
-    public override async Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("ZlibStream");
-        }
-        await _baseStream
-            .WriteAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask WriteAsync(
-        ReadOnlyMemory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_disposed)
-        {
-            throw new ObjectDisposedException("ZlibStream");
-        }
-        await _baseStream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
-    }
-#endif
-
     public override void WriteByte(byte value)
     {
         if (_disposed)

src/SharpCompress/Compressors/Deflate64/Deflate64Stream.cs

@@ -2,12 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+#nullable disable
+
 using System;
 using System.Diagnostics;
 using System.IO;
 using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.IO;
@@ -39,6 +39,7 @@ public sealed class Deflate64Stream : Stream, IStreamStack
     private const int DEFAULT_BUFFER_SIZE = 8192;
 
     private Stream _stream;
+    private CompressionMode _mode;
     private InflaterManaged _inflater;
     private byte[] _buffer;
 
@@ -61,23 +62,61 @@ public sealed class Deflate64Stream : Stream, IStreamStack
             throw new ArgumentException("Deflate64: input stream is not readable", nameof(stream));
         }
 
-        if (!stream.CanRead)
-        {
-            throw new ArgumentException("Deflate64: input stream is not readable", nameof(stream));
-        }
-
-        _inflater = new InflaterManaged(true);
-
-        _stream = stream;
-        _buffer = new byte[DEFAULT_BUFFER_SIZE];
+        InitializeInflater(stream, ZipCompressionMethod.Deflate64);
 #if DEBUG_STREAMS
         this.DebugConstruct(typeof(Deflate64Stream));
 #endif
     }
 
-    public override bool CanRead => _stream.CanRead;
+    /// <summary>
+    /// Sets up this DeflateManagedStream to be used for Inflation/Decompression
+    /// </summary>
+    private void InitializeInflater(
+        Stream stream,
+        ZipCompressionMethod method = ZipCompressionMethod.Deflate
+    )
+    {
+        Debug.Assert(stream != null);
+        Debug.Assert(
+            method == ZipCompressionMethod.Deflate || method == ZipCompressionMethod.Deflate64
+        );
+        if (!stream.CanRead)
+        {
+            throw new ArgumentException("Deflate64: input stream is not readable", nameof(stream));
+        }
 
-    public override bool CanWrite => false;
+        _inflater = new InflaterManaged(method == ZipCompressionMethod.Deflate64);
+
+        _stream = stream;
+        _mode = CompressionMode.Decompress;
+        _buffer = new byte[DEFAULT_BUFFER_SIZE];
+    }
+
+    public override bool CanRead
+    {
+        get
+        {
+            if (_stream is null)
+            {
+                return false;
+            }
+
+            return (_mode == CompressionMode.Decompress && _stream.CanRead);
+        }
+    }
+
+    public override bool CanWrite
+    {
+        get
+        {
+            if (_stream is null)
+            {
+                return false;
+            }
+
+            return (_mode == CompressionMode.Compress && _stream.CanWrite);
+        }
+    }
 
     public override bool CanSeek => false;
 
@@ -99,6 +138,7 @@ public sealed class Deflate64Stream : Stream, IStreamStack
 
     public override int Read(byte[] array, int offset, int count)
     {
+        EnsureDecompressionMode();
         ValidateParameters(array, offset, count);
         EnsureNotDisposed();
 
@@ -145,106 +185,6 @@ public sealed class Deflate64Stream : Stream, IStreamStack
         return count - remainingCount;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] array,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        ValidateParameters(array, offset, count);
-        EnsureNotDisposed();
-
-        int bytesRead;
-        var currentOffset = offset;
-        var remainingCount = count;
-
-        while (true)
-        {
-            bytesRead = _inflater.Inflate(array, currentOffset, remainingCount);
-            currentOffset += bytesRead;
-            remainingCount -= bytesRead;
-
-            if (remainingCount == 0)
-            {
-                break;
-            }
-
-            if (_inflater.Finished())
-            {
-                // if we finished decompressing, we can't have anything left in the outputwindow.
-                Debug.Assert(
-                    _inflater.AvailableOutput == 0,
-                    "We should have copied all stuff out!"
-                );
-                break;
-            }
-
-            var bytes = await _stream
-                .ReadAsync(_buffer, 0, _buffer.Length, cancellationToken)
-                .ConfigureAwait(false);
-            if (bytes <= 0)
-            {
-                break;
-            }
-            else if (bytes > _buffer.Length)
-            {
-                // The stream is either malicious or poorly implemented and returned a number of
-                // bytes larger than the buffer supplied to it.
-                throw new InvalidFormatException("Deflate64: invalid data");
-            }
-
-            _inflater.SetInput(_buffer, 0, bytes);
-        }
-
-        return count - remainingCount;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        EnsureNotDisposed();
-
-        // InflaterManaged doesn't have a Span-based Inflate method, so we need to work with arrays
-        // For large buffers, we could rent from ArrayPool, but for simplicity we'll use the buffer's array if available
-        if (
-            System.Runtime.InteropServices.MemoryMarshal.TryGetArray<byte>(
-                buffer,
-                out var arraySegment
-            )
-        )
-        {
-            // Fast path: the Memory<byte> is backed by an array
-            return await ReadAsync(
-                    arraySegment.Array!,
-                    arraySegment.Offset,
-                    arraySegment.Count,
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
-        }
-        else
-        {
-            // Slow path: rent a temporary array
-            var tempBuffer = System.Buffers.ArrayPool<byte>.Shared.Rent(buffer.Length);
-            try
-            {
-                var bytesRead = await ReadAsync(tempBuffer, 0, buffer.Length, cancellationToken)
-                    .ConfigureAwait(false);
-                tempBuffer.AsMemory(0, bytesRead).CopyTo(buffer);
-                return bytesRead;
-            }
-            finally
-            {
-                System.Buffers.ArrayPool<byte>.Shared.Return(tempBuffer);
-            }
-        }
-    }
-#endif
-
     private void ValidateParameters(byte[] array, int offset, int count)
     {
         if (array is null)
@@ -280,6 +220,26 @@ public sealed class Deflate64Stream : Stream, IStreamStack
     private static void ThrowStreamClosedException() =>
         throw new ObjectDisposedException(null, "Deflate64: stream has been disposed");
 
+    private void EnsureDecompressionMode()
+    {
+        if (_mode != CompressionMode.Decompress)
+        {
+            ThrowCannotReadFromDeflateManagedStreamException();
+        }
+    }
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static void ThrowCannotReadFromDeflateManagedStreamException() =>
+        throw new InvalidOperationException("Deflate64: cannot read from this stream");
+
+    private void EnsureCompressionMode()
+    {
+        if (_mode != CompressionMode.Compress)
+        {
+            ThrowCannotWriteToDeflateManagedStreamException();
+        }
+    }
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     private static void ThrowCannotWriteToDeflateManagedStreamException() =>
         throw new InvalidOperationException("Deflate64: cannot write to this stream");
@@ -321,17 +281,20 @@ public sealed class Deflate64Stream : Stream, IStreamStack
 #endif
                 if (disposing)
                 {
-                    _stream.Dispose();
+                    _stream?.Dispose();
                 }
             }
             finally
             {
+                _stream = null;
+
                 try
                 {
-                    _inflater.Dispose();
+                    _inflater?.Dispose();
                 }
                 finally
                 {
+                    _inflater = null;
                     base.Dispose(disposing);
                 }
             }

src/SharpCompress/Compressors/Filters/DeltaFilter.cs

@@ -1,36 +1,35 @@
 using System.IO;
 
-namespace SharpCompress.Compressors.Filters
+namespace SharpCompress.Compressors.Filters;
+
+internal class DeltaFilter : Filter
 {
-    internal class DeltaFilter : Filter
+    private const int DISTANCE_MIN = 1;
+    private const int DISTANCE_MAX = 256;
+    private const int DISTANCE_MASK = DISTANCE_MAX - 1;
+
+    private int _distance;
+    private byte[] _history;
+    private int _position;
+
+    public DeltaFilter(bool isEncoder, Stream baseStream, byte[] info)
+        : base(isEncoder, baseStream, 1)
     {
-        private const int DISTANCE_MIN = 1;
-        private const int DISTANCE_MAX = 256;
-        private const int DISTANCE_MASK = DISTANCE_MAX - 1;
+        _distance = info[0];
+        _history = new byte[DISTANCE_MAX];
+        _position = 0;
+    }
 
-        private int _distance;
-        private byte[] _history;
-        private int _position;
+    protected override int Transform(byte[] buffer, int offset, int count)
+    {
+        var end = offset + count;
 
-        public DeltaFilter(bool isEncoder, Stream baseStream, byte[] info)
-            : base(isEncoder, baseStream, 1)
+        for (var i = offset; i < end; i++)
         {
-            _distance = info[0];
-            _history = new byte[DISTANCE_MAX];
-            _position = 0;
+            buffer[i] += _history[(_distance + _position--) & DISTANCE_MASK];
+            _history[_position & DISTANCE_MASK] = buffer[i];
         }
 
-        protected override int Transform(byte[] buffer, int offset, int count)
-        {
-            var end = offset + count;
-
-            for (var i = offset; i < end; i++)
-            {
-                buffer[i] += _history[(_distance + _position--) & DISTANCE_MASK];
-                _history[_position & DISTANCE_MASK] = buffer[i];
-            }
-
-            return count;
-        }
+        return count;
     }
 }

src/SharpCompress/Compressors/LZMA/AesDecoderStream.cs

@@ -2,8 +2,6 @@ using System;
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
 
@@ -285,70 +283,5 @@ internal sealed class AesDecoderStream : DecoderStream2, IStreamStack
         return count;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (count == 0 || mWritten == mLimit)
-        {
-            return 0;
-        }
-
-        if (mUnderflow > 0)
-        {
-            return HandleUnderflow(buffer, offset, count);
-        }
-
-        // Need at least 16 bytes to proceed.
-        if (mEnding - mOffset < 16)
-        {
-            Buffer.BlockCopy(mBuffer, mOffset, mBuffer, 0, mEnding - mOffset);
-            mEnding -= mOffset;
-            mOffset = 0;
-
-            do
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-                var read = await mStream
-                    .ReadAsync(mBuffer, mEnding, mBuffer.Length - mEnding, cancellationToken)
-                    .ConfigureAwait(false);
-                if (read == 0)
-                {
-                    // We are not done decoding and have less than 16 bytes.
-                    throw new EndOfStreamException();
-                }
-
-                mEnding += read;
-            } while (mEnding - mOffset < 16);
-        }
-
-        // We shouldn't return more data than we are limited to.
-        if (count > mLimit - mWritten)
-        {
-            count = (int)(mLimit - mWritten);
-        }
-
-        // We cannot transform less than 16 bytes into the target buffer,
-        // but we also cannot return zero, so we need to handle this.
-        if (count < 16)
-        {
-            return HandleUnderflow(buffer, offset, count);
-        }
-
-        if (count > mEnding - mOffset)
-        {
-            count = mEnding - mOffset;
-        }
-
-        // Otherwise we transform directly into the target buffer.
-        var processed = mDecoder.TransformBlock(mBuffer, mOffset, count & ~15, buffer, offset);
-        mOffset += processed;
-        mWritten += processed;
-        return processed;
-    }
-
     #endregion
 }

src/SharpCompress/Compressors/LZMA/Bcj2DecoderStream.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.LZMA;
@@ -193,18 +191,6 @@ internal class Bcj2DecoderStream : DecoderStream2, IStreamStack
         return count;
     }
 
-    public override Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        // Bcj2DecoderStream uses complex state machine with multiple streams
-        return Task.FromResult(Read(buffer, offset, count));
-    }
-
     public override int ReadByte()
     {
         if (_mFinished)

src/SharpCompress/Compressors/LZMA/ICoder.cs

@@ -1,13 +1,12 @@
 using System;
 using System.IO;
-using SharpCompress.Common;
 
 namespace SharpCompress.Compressors.LZMA;
 
 /// <summary>
 /// The exception that is thrown when an error in input stream occurs during decoding.
 /// </summary>
-internal class DataErrorException : SharpCompressException
+internal class DataErrorException : Exception
 {
     public DataErrorException()
         : base("Data Error") { }
@@ -16,7 +15,7 @@ internal class DataErrorException : SharpCompressException
 /// <summary>
 /// The exception that is thrown when the value of an argument is outside the allowable range.
 /// </summary>
-internal class InvalidParamException : SharpCompressException
+internal class InvalidParamException : Exception
 {
     public InvalidParamException()
         : base("Invalid Parameter") { }

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

@@ -1,14 +1,11 @@
 #nullable disable
 
 using System;
-using System.Buffers;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Compressors.LZMA.LZ;
 
-internal class OutWindow : IDisposable
+internal class OutWindow
 {
     private byte[] _buffer;
     private int _windowSize;
@@ -18,22 +15,19 @@ internal class OutWindow : IDisposable
     private int _pendingDist;
     private Stream _stream;
 
-    private long _total;
-    private long _limit;
-
-    public long Total => _total;
+    public long _total;
+    public long _limit;
 
     public void Create(int windowSize)
     {
         if (_windowSize != windowSize)
         {
-            if (_buffer is not null)
-            {
-                ArrayPool<byte>.Shared.Return(_buffer);
-            }
-            _buffer = ArrayPool<byte>.Shared.Rent(windowSize);
+            _buffer = new byte[windowSize];
+        }
+        else
+        {
+            _buffer[windowSize - 1] = 0;
         }
-        _buffer[windowSize - 1] = 0;
         _windowSize = windowSize;
         _pos = 0;
         _streamPos = 0;
@@ -42,22 +36,7 @@ internal class OutWindow : IDisposable
         _limit = 0;
     }
 
-    public void Dispose()
-    {
-        ReleaseStream();
-        if (_buffer is null)
-        {
-            return;
-        }
-        ArrayPool<byte>.Shared.Return(_buffer);
-        _buffer = null;
-    }
-
-    public void Reset()
-    {
-        ReleaseStream();
-        Create(_windowSize);
-    }
+    public void Reset() => Create(_windowSize);
 
     public void Init(Stream stream)
     {
@@ -87,13 +66,7 @@ internal class OutWindow : IDisposable
         _stream = null;
     }
 
-    public async Task ReleaseStreamAsync(CancellationToken cancellationToken = default)
-    {
-        await FlushAsync(cancellationToken).ConfigureAwait(false);
-        _stream = null;
-    }
-
-    private void Flush()
+    public void Flush()
     {
         if (_stream is null)
         {
@@ -112,27 +85,6 @@ internal class OutWindow : IDisposable
         _streamPos = _pos;
     }
 
-    private async Task FlushAsync(CancellationToken cancellationToken = default)
-    {
-        if (_stream is null)
-        {
-            return;
-        }
-        var size = _pos - _streamPos;
-        if (size == 0)
-        {
-            return;
-        }
-        await _stream
-            .WriteAsync(_buffer, _streamPos, size, cancellationToken)
-            .ConfigureAwait(false);
-        if (_pos >= _windowSize)
-        {
-            _pos = 0;
-        }
-        _streamPos = _pos;
-    }
-
     public void CopyPending()
     {
         if (_pendingLen < 1)
@@ -153,26 +105,6 @@ internal class OutWindow : IDisposable
         _pendingLen = rem;
     }
 
-    public async Task CopyPendingAsync(CancellationToken cancellationToken = default)
-    {
-        if (_pendingLen < 1)
-        {
-            return;
-        }
-        var rem = _pendingLen;
-        var pos = (_pendingDist < _pos ? _pos : _pos + _windowSize) - _pendingDist - 1;
-        while (rem > 0 && HasSpace)
-        {
-            if (pos >= _windowSize)
-            {
-                pos = 0;
-            }
-            await PutByteAsync(_buffer[pos++], cancellationToken).ConfigureAwait(false);
-            rem--;
-        }
-        _pendingLen = rem;
-    }
-
     public void CopyBlock(int distance, int len)
     {
         var rem = len;
@@ -206,43 +138,6 @@ internal class OutWindow : IDisposable
         _pendingDist = distance;
     }
 
-    public async Task CopyBlockAsync(
-        int distance,
-        int len,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var rem = len;
-        var pos = (distance < _pos ? _pos : _pos + _windowSize) - distance - 1;
-        var targetSize = HasSpace ? (int)Math.Min(rem, _limit - _total) : 0;
-        var sizeUntilWindowEnd = Math.Min(_windowSize - _pos, _windowSize - pos);
-        var sizeUntilOverlap = Math.Abs(pos - _pos);
-        var fastSize = Math.Min(Math.Min(sizeUntilWindowEnd, sizeUntilOverlap), targetSize);
-        if (fastSize >= 2)
-        {
-            _buffer.AsSpan(pos, fastSize).CopyTo(_buffer.AsSpan(_pos, fastSize));
-            _pos += fastSize;
-            pos += fastSize;
-            _total += fastSize;
-            if (_pos >= _windowSize)
-            {
-                await FlushAsync(cancellationToken).ConfigureAwait(false);
-            }
-            rem -= fastSize;
-        }
-        while (rem > 0 && HasSpace)
-        {
-            if (pos >= _windowSize)
-            {
-                pos = 0;
-            }
-            await PutByteAsync(_buffer[pos++], cancellationToken).ConfigureAwait(false);
-            rem--;
-        }
-        _pendingLen = rem;
-        _pendingDist = distance;
-    }
-
     public void PutByte(byte b)
     {
         _buffer[_pos++] = b;
@@ -253,16 +148,6 @@ internal class OutWindow : IDisposable
         }
     }
 
-    public async Task PutByteAsync(byte b, CancellationToken cancellationToken = default)
-    {
-        _buffer[_pos++] = b;
-        _total++;
-        if (_pos >= _windowSize)
-        {
-            await FlushAsync(cancellationToken).ConfigureAwait(false);
-        }
-    }
-
     public byte GetByte(int distance)
     {
         var pos = _pos - distance - 1;
@@ -303,44 +188,6 @@ internal class OutWindow : IDisposable
         return len - size;
     }
 
-    public async Task<int> CopyStreamAsync(
-        Stream stream,
-        int len,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var size = len;
-        while (size > 0 && _pos < _windowSize && _total < _limit)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            var curSize = _windowSize - _pos;
-            if (curSize > _limit - _total)
-            {
-                curSize = (int)(_limit - _total);
-            }
-            if (curSize > size)
-            {
-                curSize = size;
-            }
-            var numReadBytes = await stream
-                .ReadAsync(_buffer, _pos, curSize, cancellationToken)
-                .ConfigureAwait(false);
-            if (numReadBytes == 0)
-            {
-                throw new DataErrorException();
-            }
-            size -= numReadBytes;
-            _pos += numReadBytes;
-            _total += numReadBytes;
-            if (_pos >= _windowSize)
-            {
-                await FlushAsync(cancellationToken).ConfigureAwait(false);
-            }
-        }
-        return len - size;
-    }
-
     public void SetLimit(long size) => _limit = _total + size;
 
     public bool HasSpace => _pos < _windowSize && _total < _limit;

src/SharpCompress/Compressors/LZMA/LZipStream.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Buffers.Binary;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Crypto;
 using SharpCompress.IO;
@@ -159,11 +157,6 @@ public sealed class LZipStream : Stream, IStreamStack
 
 #if !NETFRAMEWORK && !NETSTANDARD2_0
 
-    public override ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    ) => _stream.ReadAsync(buffer, cancellationToken);
-
     public override int Read(Span<byte> buffer) => _stream.Read(buffer);
 
     public override void Write(ReadOnlySpan<byte> buffer)
@@ -186,25 +179,6 @@ public sealed class LZipStream : Stream, IStreamStack
         ++_writeCount;
     }
 
-    public override Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    ) => _stream.ReadAsync(buffer, offset, count, cancellationToken);
-
-    public override async Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        await _stream.WriteAsync(buffer, offset, count, cancellationToken);
-        _writeCount += count;
-    }
-
     #endregion
 
     /// <summary>

src/SharpCompress/Compressors/LZMA/LzmaDecoder.cs

@@ -1,7 +1,6 @@
 #nullable disable
 
 using System;
-using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using SharpCompress.Compressors.LZMA.LZ;
 using SharpCompress.Compressors.LZMA.RangeCoder;
@@ -200,9 +199,6 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
         }
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    [MemberNotNull(nameof(_outWindow))]
-#endif
     private void CreateDictionary()
     {
         if (_dictionarySize < 0)
@@ -298,7 +294,7 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
         }
         else
         {
-            _outWindow.SetLimit(long.MaxValue - _outWindow.Total);
+            _outWindow.SetLimit(long.MaxValue - _outWindow._total);
         }
 
         var rangeDecoder = new RangeCoder.Decoder();
@@ -309,43 +305,6 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
         _outWindow.ReleaseStream();
         rangeDecoder.ReleaseStream();
 
-        _outWindow.Dispose();
-        _outWindow = null;
-    }
-
-    public async System.Threading.Tasks.Task CodeAsync(
-        Stream inStream,
-        Stream outStream,
-        long inSize,
-        long outSize,
-        ICodeProgress progress,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (_outWindow is null)
-        {
-            CreateDictionary();
-        }
-        _outWindow.Init(outStream);
-        if (outSize > 0)
-        {
-            _outWindow.SetLimit(outSize);
-        }
-        else
-        {
-            _outWindow.SetLimit(long.MaxValue - _outWindow.Total);
-        }
-
-        var rangeDecoder = new RangeCoder.Decoder();
-        rangeDecoder.Init(inStream);
-
-        await CodeAsync(_dictionarySize, _outWindow, rangeDecoder, cancellationToken)
-            .ConfigureAwait(false);
-
-        await _outWindow.ReleaseStreamAsync(cancellationToken).ConfigureAwait(false);
-        rangeDecoder.ReleaseStream();
-
-        _outWindow.Dispose();
         _outWindow = null;
     }
 
@@ -357,7 +316,7 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
 
         while (outWindow.HasSpace)
         {
-            var posState = (uint)outWindow.Total & _posStateMask;
+            var posState = (uint)outWindow._total & _posStateMask;
             if (
                 _isMatchDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState]
                     .Decode(rangeDecoder) == 0
@@ -369,14 +328,18 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
                 {
                     b = _literalDecoder.DecodeWithMatchByte(
                         rangeDecoder,
-                        (uint)outWindow.Total,
+                        (uint)outWindow._total,
                         prevByte,
                         outWindow.GetByte((int)_rep0)
                     );
                 }
                 else
                 {
-                    b = _literalDecoder.DecodeNormal(rangeDecoder, (uint)outWindow.Total, prevByte);
+                    b = _literalDecoder.DecodeNormal(
+                        rangeDecoder,
+                        (uint)outWindow._total,
+                        prevByte
+                    );
                 }
                 outWindow.PutByte(b);
                 _state.UpdateChar();
@@ -461,7 +424,7 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
                         _rep0 = posSlot;
                     }
                 }
-                if (_rep0 >= outWindow.Total || _rep0 >= dictionarySizeCheck)
+                if (_rep0 >= outWindow._total || _rep0 >= dictionarySizeCheck)
                 {
                     if (_rep0 == 0xFFFFFFFF)
                     {
@@ -475,143 +438,6 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
         return false;
     }
 
-    internal async System.Threading.Tasks.Task<bool> CodeAsync(
-        int dictionarySize,
-        OutWindow outWindow,
-        RangeCoder.Decoder rangeDecoder,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var dictionarySizeCheck = Math.Max(dictionarySize, 1);
-
-        await outWindow.CopyPendingAsync(cancellationToken).ConfigureAwait(false);
-
-        while (outWindow.HasSpace)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            var posState = (uint)outWindow.Total & _posStateMask;
-            if (
-                _isMatchDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState]
-                    .Decode(rangeDecoder) == 0
-            )
-            {
-                byte b;
-                var prevByte = outWindow.GetByte(0);
-                if (!_state.IsCharState())
-                {
-                    b = _literalDecoder.DecodeWithMatchByte(
-                        rangeDecoder,
-                        (uint)outWindow.Total,
-                        prevByte,
-                        outWindow.GetByte((int)_rep0)
-                    );
-                }
-                else
-                {
-                    b = _literalDecoder.DecodeNormal(rangeDecoder, (uint)outWindow.Total, prevByte);
-                }
-                await outWindow.PutByteAsync(b, cancellationToken).ConfigureAwait(false);
-                _state.UpdateChar();
-            }
-            else
-            {
-                uint len;
-                if (_isRepDecoders[_state._index].Decode(rangeDecoder) == 1)
-                {
-                    if (_isRepG0Decoders[_state._index].Decode(rangeDecoder) == 0)
-                    {
-                        if (
-                            _isRep0LongDecoders[
-                                (_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState
-                            ]
-                                .Decode(rangeDecoder) == 0
-                        )
-                        {
-                            _state.UpdateShortRep();
-                            await outWindow
-                                .PutByteAsync(outWindow.GetByte((int)_rep0), cancellationToken)
-                                .ConfigureAwait(false);
-                            continue;
-                        }
-                    }
-                    else
-                    {
-                        uint distance;
-                        if (_isRepG1Decoders[_state._index].Decode(rangeDecoder) == 0)
-                        {
-                            distance = _rep1;
-                        }
-                        else
-                        {
-                            if (_isRepG2Decoders[_state._index].Decode(rangeDecoder) == 0)
-                            {
-                                distance = _rep2;
-                            }
-                            else
-                            {
-                                distance = _rep3;
-                                _rep3 = _rep2;
-                            }
-                            _rep2 = _rep1;
-                        }
-                        _rep1 = _rep0;
-                        _rep0 = distance;
-                    }
-                    len = _repLenDecoder.Decode(rangeDecoder, posState) + Base.K_MATCH_MIN_LEN;
-                    _state.UpdateRep();
-                }
-                else
-                {
-                    _rep3 = _rep2;
-                    _rep2 = _rep1;
-                    _rep1 = _rep0;
-                    len = Base.K_MATCH_MIN_LEN + _lenDecoder.Decode(rangeDecoder, posState);
-                    _state.UpdateMatch();
-                    var posSlot = _posSlotDecoder[Base.GetLenToPosState(len)].Decode(rangeDecoder);
-                    if (posSlot >= Base.K_START_POS_MODEL_INDEX)
-                    {
-                        var numDirectBits = (int)((posSlot >> 1) - 1);
-                        _rep0 = ((2 | (posSlot & 1)) << numDirectBits);
-                        if (posSlot < Base.K_END_POS_MODEL_INDEX)
-                        {
-                            _rep0 += BitTreeDecoder.ReverseDecode(
-                                _posDecoders,
-                                _rep0 - posSlot - 1,
-                                rangeDecoder,
-                                numDirectBits
-                            );
-                        }
-                        else
-                        {
-                            _rep0 += (
-                                rangeDecoder.DecodeDirectBits(numDirectBits - Base.K_NUM_ALIGN_BITS)
-                                << Base.K_NUM_ALIGN_BITS
-                            );
-                            _rep0 += _posAlignDecoder.ReverseDecode(rangeDecoder);
-                        }
-                    }
-                    else
-                    {
-                        _rep0 = posSlot;
-                    }
-                }
-                if (_rep0 >= outWindow.Total || _rep0 >= dictionarySizeCheck)
-                {
-                    if (_rep0 == 0xFFFFFFFF)
-                    {
-                        return true;
-                    }
-                    throw new DataErrorException();
-                }
-                await outWindow
-                    .CopyBlockAsync((int)_rep0, (int)len, cancellationToken)
-                    .ConfigureAwait(false);
-            }
-        }
-        return false;
-    }
-
     public void SetDecoderProperties(byte[] properties)
     {
         if (properties.Length < 1)
@@ -647,4 +473,29 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
         }
         _outWindow.Train(stream);
     }
+
+    /*
+    public override bool CanRead { get { return true; }}
+    public override bool CanWrite { get { return true; }}
+    public override bool CanSeek { get { return true; }}
+    public override long Length { get { return 0; }}
+    public override long Position
+    {
+        get { return 0;	}
+        set { }
+    }
+    public override void Flush() { }
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        return 0;
+    }
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+    }
+    public override long Seek(long offset, System.IO.SeekOrigin origin)
+    {
+        return 0;
+    }
+    public override void SetLength(long value) {}
+    */
 }

src/SharpCompress/Compressors/LZMA/LzmaStream.cs

@@ -3,8 +3,6 @@
 using System;
 using System.Buffers.Binary;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.LZ;
 using SharpCompress.IO;
 
@@ -180,7 +178,6 @@ public class LzmaStream : Stream, IStreamStack
                 _position = _encoder.Code(null, true);
             }
             _inputStream?.Dispose();
-            _outWindow.Dispose();
         }
         base.Dispose(disposing);
     }
@@ -425,82 +422,6 @@ public class LzmaStream : Stream, IStreamStack
         }
     }
 
-    private async Task DecodeChunkHeaderAsync(CancellationToken cancellationToken = default)
-    {
-        var controlBuffer = new byte[1];
-        await _inputStream.ReadAsync(controlBuffer, 0, 1, cancellationToken).ConfigureAwait(false);
-        var control = controlBuffer[0];
-        _inputPosition++;
-
-        if (control == 0x00)
-        {
-            _endReached = true;
-            return;
-        }
-
-        if (control >= 0xE0 || control == 0x01)
-        {
-            _needProps = true;
-            _needDictReset = false;
-            _outWindow.Reset();
-        }
-        else if (_needDictReset)
-        {
-            throw new DataErrorException();
-        }
-
-        if (control >= 0x80)
-        {
-            _uncompressedChunk = false;
-
-            _availableBytes = (control & 0x1F) << 16;
-            var buffer = new byte[2];
-            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
-            _availableBytes += (buffer[0] << 8) + buffer[1] + 1;
-            _inputPosition += 2;
-
-            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
-            _rangeDecoderLimit = (buffer[0] << 8) + buffer[1] + 1;
-            _inputPosition += 2;
-
-            if (control >= 0xC0)
-            {
-                _needProps = false;
-                await _inputStream
-                    .ReadAsync(controlBuffer, 0, 1, cancellationToken)
-                    .ConfigureAwait(false);
-                Properties[0] = controlBuffer[0];
-                _inputPosition++;
-
-                _decoder = new Decoder();
-                _decoder.SetDecoderProperties(Properties);
-            }
-            else if (_needProps)
-            {
-                throw new DataErrorException();
-            }
-            else if (control >= 0xA0)
-            {
-                _decoder = new Decoder();
-                _decoder.SetDecoderProperties(Properties);
-            }
-
-            _rangeDecoder.Init(_inputStream);
-        }
-        else if (control > 0x02)
-        {
-            throw new DataErrorException();
-        }
-        else
-        {
-            _uncompressedChunk = true;
-            var buffer = new byte[2];
-            await _inputStream.ReadAsync(buffer, 0, 2, cancellationToken).ConfigureAwait(false);
-            _availableBytes = (buffer[0] << 8) + buffer[1] + 1;
-            _inputPosition += 2;
-        }
-    }
-
     public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
 
     public override void SetLength(long value) => throw new NotSupportedException();
@@ -513,128 +434,5 @@ public class LzmaStream : Stream, IStreamStack
         }
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (_endReached)
-        {
-            return 0;
-        }
-
-        var total = 0;
-        while (total < count)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            if (_availableBytes == 0)
-            {
-                if (_isLzma2)
-                {
-                    await DecodeChunkHeaderAsync(cancellationToken).ConfigureAwait(false);
-                }
-                else
-                {
-                    _endReached = true;
-                }
-                if (_endReached)
-                {
-                    break;
-                }
-            }
-
-            var toProcess = count - total;
-            if (toProcess > _availableBytes)
-            {
-                toProcess = (int)_availableBytes;
-            }
-
-            _outWindow.SetLimit(toProcess);
-            if (_uncompressedChunk)
-            {
-                _inputPosition += await _outWindow
-                    .CopyStreamAsync(_inputStream, toProcess, cancellationToken)
-                    .ConfigureAwait(false);
-            }
-            else if (
-                await _decoder
-                    .CodeAsync(_dictionarySize, _outWindow, _rangeDecoder, cancellationToken)
-                    .ConfigureAwait(false)
-                && _outputSize < 0
-            )
-            {
-                _availableBytes = _outWindow.AvailableBytes;
-            }
-
-            var read = _outWindow.Read(buffer, offset, toProcess);
-            total += read;
-            offset += read;
-            _position += read;
-            _availableBytes -= read;
-
-            if (_availableBytes == 0 && !_uncompressedChunk)
-            {
-                if (
-                    !_rangeDecoder.IsFinished
-                    || (_rangeDecoderLimit >= 0 && _rangeDecoder._total != _rangeDecoderLimit)
-                )
-                {
-                    _outWindow.SetLimit(toProcess + 1);
-                    if (
-                        !await _decoder
-                            .CodeAsync(
-                                _dictionarySize,
-                                _outWindow,
-                                _rangeDecoder,
-                                cancellationToken
-                            )
-                            .ConfigureAwait(false)
-                    )
-                    {
-                        _rangeDecoder.ReleaseStream();
-                        throw new DataErrorException();
-                    }
-                }
-
-                _rangeDecoder.ReleaseStream();
-
-                _inputPosition += _rangeDecoder._total;
-                if (_outWindow.HasPending)
-                {
-                    throw new DataErrorException();
-                }
-            }
-        }
-
-        if (_endReached)
-        {
-            if (_inputSize >= 0 && _inputPosition != _inputSize)
-            {
-                throw new DataErrorException();
-            }
-            if (_outputSize >= 0 && _position != _outputSize)
-            {
-                throw new DataErrorException();
-            }
-        }
-
-        return total;
-    }
-
-    public override Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        Write(buffer, offset, count);
-        return Task.CompletedTask;
-    }
-
     public byte[] Properties { get; } = new byte[5];
 }

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 ZstdSharp;
+using SharpCompress.Compressors.ZStandard;
 
 namespace SharpCompress.Compressors.LZMA;
 

src/SharpCompress/Compressors/LZMA/Utilites/CrcBuilderStream.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.LZMA.Utilites;
@@ -103,22 +101,4 @@ internal class CrcBuilderStream : Stream, IStreamStack
         _mCrc = Crc.Update(_mCrc, buffer, offset, count);
         _mTarget.Write(buffer, offset, count);
     }
-
-    public override async Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        if (_mFinished)
-        {
-            throw new InvalidOperationException("CRC calculation has been finished.");
-        }
-
-        Processed += count;
-        _mCrc = Crc.Update(_mCrc, buffer, offset, count);
-        await _mTarget.WriteAsync(buffer, offset, count, cancellationToken);
-    }
 }

src/SharpCompress/Compressors/LZMA/Utilites/CrcCheckStream.cs

@@ -1,9 +1,6 @@
 using System;
-using System.Buffers;
 using System.Diagnostics;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Compressors.LZMA.Utilites;
 
@@ -14,7 +11,7 @@ public class CrcCheckStream : Stream
     private uint _mCurrentCrc;
     private bool _mClosed;
 
-    private readonly long[] _mBytes = ArrayPool<long>.Shared.Rent(256);
+    private readonly long[] _mBytes = new long[256];
     private long _mLength;
 
     public CrcCheckStream(uint crc)
@@ -68,7 +65,6 @@ public class CrcCheckStream : Stream
         finally
         {
             base.Dispose(disposing);
-            ArrayPool<long>.Shared.Return(_mBytes);
         }
     }
 
@@ -105,16 +101,4 @@ public class CrcCheckStream : Stream
 
         _mCurrentCrc = Crc.Update(_mCurrentCrc, buffer, offset, count);
     }
-
-    public override Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        Write(buffer, offset, count);
-        return Task.CompletedTask;
-    }
 }

src/SharpCompress/Compressors/Lzw/LzwConstants.cs

@@ -1,65 +1,64 @@
-namespace SharpCompress.Compressors.Lzw
+namespace SharpCompress.Compressors.Lzw;
+
+/// <summary>
+/// This class contains constants used for LZW
+/// </summary>
+[System.Diagnostics.CodeAnalysis.SuppressMessage(
+    "Naming",
+    "CA1707:Identifiers should not contain underscores",
+    Justification = "kept for backwards compatibility"
+)]
+public sealed class LzwConstants
 {
     /// <summary>
-    /// This class contains constants used for LZW
+    /// Magic number found at start of LZW header: 0x1f 0x9d
     /// </summary>
-    [System.Diagnostics.CodeAnalysis.SuppressMessage(
-        "Naming",
-        "CA1707:Identifiers should not contain underscores",
-        Justification = "kept for backwards compatibility"
-    )]
-    public sealed class LzwConstants
-    {
-        /// <summary>
-        /// Magic number found at start of LZW header: 0x1f 0x9d
-        /// </summary>
-        public const int MAGIC = 0x1f9d;
+    public const int MAGIC = 0x1f9d;
 
-        /// <summary>
-        /// Maximum number of bits per code
-        /// </summary>
-        public const int MAX_BITS = 16;
+    /// <summary>
+    /// Maximum number of bits per code
+    /// </summary>
+    public const int MAX_BITS = 16;
 
-        /* 3rd header byte:
-         * bit 0..4 Number of compression bits
-         * bit 5    Extended header
-         * bit 6    Free
-         * bit 7    Block mode
-         */
+    /* 3rd header byte:
+     * bit 0..4 Number of compression bits
+     * bit 5    Extended header
+     * bit 6    Free
+     * bit 7    Block mode
+     */
 
-        /// <summary>
-        /// Mask for 'number of compression bits'
-        /// </summary>
-        public const int BIT_MASK = 0x1f;
+    /// <summary>
+    /// Mask for 'number of compression bits'
+    /// </summary>
+    public const int BIT_MASK = 0x1f;
 
-        /// <summary>
-        /// Indicates the presence of a fourth header byte
-        /// </summary>
-        public const int EXTENDED_MASK = 0x20;
+    /// <summary>
+    /// Indicates the presence of a fourth header byte
+    /// </summary>
+    public const int EXTENDED_MASK = 0x20;
 
-        //public const int FREE_MASK      = 0x40;
+    //public const int FREE_MASK      = 0x40;
 
-        /// <summary>
-        /// Reserved bits
-        /// </summary>
-        public const int RESERVED_MASK = 0x60;
+    /// <summary>
+    /// Reserved bits
+    /// </summary>
+    public const int RESERVED_MASK = 0x60;
 
-        /// <summary>
-        /// Block compression: if table is full and compression rate is dropping,
-        /// clear the dictionary.
-        /// </summary>
-        public const int BLOCK_MODE_MASK = 0x80;
+    /// <summary>
+    /// Block compression: if table is full and compression rate is dropping,
+    /// clear the dictionary.
+    /// </summary>
+    public const int BLOCK_MODE_MASK = 0x80;
 
-        /// <summary>
-        /// LZW file header size (in bytes)
-        /// </summary>
-        public const int HDR_SIZE = 3;
+    /// <summary>
+    /// LZW file header size (in bytes)
+    /// </summary>
+    public const int HDR_SIZE = 3;
 
-        /// <summary>
-        /// Initial number of bits per code
-        /// </summary>
-        public const int INIT_BITS = 9;
+    /// <summary>
+    /// Initial number of bits per code
+    /// </summary>
+    public const int INIT_BITS = 9;
 
-        private LzwConstants() { }
-    }
+    private LzwConstants() { }
 }

src/SharpCompress/Compressors/RLE90/RLE.cs

@@ -1,52 +1,51 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace SharpCompress.Compressors.RLE90
+namespace SharpCompress.Compressors.RLE90;
+
+public static class RLE
 {
-    public static class RLE
+    private const byte DLE = 0x90;
+
+    /// <summary>
+    /// Unpacks an RLE compressed buffer.
+    /// Format: <char> DLE <count>, where count == 0 -> DLE
+    /// </summary>
+    /// <param name="compressedBuffer">The compressed buffer to unpack.</param>
+    /// <returns>A list of unpacked bytes.</returns>
+    public static List<byte> UnpackRLE(byte[] compressedBuffer)
     {
-        private const byte DLE = 0x90;
+        var result = new List<byte>(compressedBuffer.Length * 2); // Optimized initial capacity
+        var countMode = false;
+        byte last = 0;
 
-        /// <summary>
-        /// Unpacks an RLE compressed buffer.
-        /// Format: <char> DLE <count>, where count == 0 -> DLE
-        /// </summary>
-        /// <param name="compressedBuffer">The compressed buffer to unpack.</param>
-        /// <returns>A list of unpacked bytes.</returns>
-        public static List<byte> UnpackRLE(byte[] compressedBuffer)
+        foreach (var c in compressedBuffer)
         {
-            var result = new List<byte>(compressedBuffer.Length * 2); // Optimized initial capacity
-            var countMode = false;
-            byte last = 0;
-
-            foreach (var c in compressedBuffer)
+            if (!countMode)
             {
-                if (!countMode)
+                if (c == DLE)
                 {
-                    if (c == DLE)
-                    {
-                        countMode = true;
-                    }
-                    else
-                    {
-                        result.Add(c);
-                        last = c;
-                    }
+                    countMode = true;
                 }
                 else
                 {
-                    countMode = false;
-                    if (c == 0)
-                    {
-                        result.Add(DLE);
-                    }
-                    else
-                    {
-                        result.AddRange(Enumerable.Repeat(last, c - 1));
-                    }
+                    result.Add(c);
+                    last = c;
+                }
+            }
+            else
+            {
+                countMode = false;
+                if (c == 0)
+                {
+                    result.Add(DLE);
+                }
+                else
+                {
+                    result.AddRange(Enumerable.Repeat(last, c - 1));
                 }
             }
-            return result;
         }
+        return result;
     }
 }