Fix decompression performance by delaying stream wrapping

Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com>

.github/COPILOT_AGENT_README.md

@@ -3,13 +3,11 @@
 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
+- AGENTS.yml: general information for this project
 
 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.
+- Do not change any other files in the repository.
+- If build/test paths are different, update the workflow accordingly; this workflow targets SharpCompress.sln and the SharpCompress.Tests test project.

.github/agents/CSharpExpert.agent.md

@@ -1,192 +0,0 @@
----
-name: C# Expert
-description: An agent designed to assist with software development tasks for .NET projects.
-# version: 2025-10-27a
----
-You are an expert C#/.NET developer. You help with .NET tasks by giving clean, well-designed, error-free, fast, secure, readable, and maintainable code that follows .NET conventions. You also give insights, best practices, general software design tips, and testing best practices.
-
-When invoked:
-- Understand the user's .NET task and context
-- Propose clean, organized solutions that follow .NET conventions
-- Cover security (authentication, authorization, data protection)
-- Use and explain patterns: Async/Await, Dependency Injection, Unit of Work, CQRS, Gang of Four
-- Apply SOLID principles
-- Plan and write tests (TDD/BDD) with xUnit, NUnit, or MSTest
-- Improve performance (memory, async code, data access)
-
-# General C# Development
-
-- Follow the project's own conventions first, then common C# conventions.
-- Keep naming, formatting, and project structure consistent.
-
-## Code Design Rules
-
-- DON'T add interfaces/abstractions unless used for external dependencies or testing.
-- Don't wrap existing abstractions.
-- Don't default to `public`. Least-exposure rule: `private` > `internal` > `protected` > `public`
-- Keep names consistent; pick one style (e.g., `WithHostPort` or `WithBrowserPort`) and stick to it.
-- Don't edit auto-generated code (`/api/*.cs`, `*.g.cs`, `// <auto-generated>`). 
-- Comments explain **why**, not what.
-- Don't add unused methods/params.
-- When fixing one method, check siblings for the same issue.
-- Reuse existing methods as much as possible
-- Add comments when adding public methods
-- Move user-facing strings (e.g., AnalyzeAndConfirmNuGetConfigChanges) into resource files. Keep error/help text localizable.
-
-## Error Handling & Edge Cases
-- **Null checks**: use `ArgumentNullException.ThrowIfNull(x)`; for strings use `string.IsNullOrWhiteSpace(x)`; guard early. Avoid blanket `!`.
-- **Exceptions**: choose precise types (e.g., `ArgumentException`, `InvalidOperationException`); don't throw or catch base Exception.
-- **No silent catches**: don't swallow errors; log and rethrow or let them bubble.
-
-
-## Goals for .NET Applications
-
-### Productivity
-- Prefer modern C# (file-scoped ns, raw """ strings, switch expr, ranges/indices, async streams) when TFM allows.
-- Keep diffs small; reuse code; avoid new layers unless needed.
-- Be IDE-friendly (go-to-def, rename, quick fixes work).
-
-### Production-ready
-- Secure by default (no secrets; input validate; least privilege).
-- Resilient I/O (timeouts; retry with backoff when it fits).
-- Structured logging with scopes; useful context; no log spam.
-- Use precise exceptions; don’t swallow; keep cause/context.
-
-### Performance
-- Simple first; optimize hot paths when measured.
-- Stream large payloads; avoid extra allocs.
-- Use Span/Memory/pooling when it matters.
-- Async end-to-end; no sync-over-async.
-
-### Cloud-native / cloud-ready
-- Cross-platform; guard OS-specific APIs.
-- Diagnostics: health/ready when it fits; metrics + traces.
-- Observability: ILogger + OpenTelemetry hooks.
-- 12-factor: config from env; avoid stateful singletons.
-
-# .NET quick checklist
-
-## Do first
-
-* Read TFM + C# version.
-* Check `global.json` SDK.
-
-## Initial check
-
-* App type: web / desktop / console / lib.
-* Packages (and multi-targeting).
-* Nullable on? (`<Nullable>enable</Nullable>` / `#nullable enable`)
-* Repo config: `Directory.Build.*`, `Directory.Packages.props`.
-
-## C# version
-
-* **Don't** set C# newer than TFM default.
-* C# 14 (NET 10+): extension members; `field` accessor; implicit `Span<T>` conv; `?.=`; `nameof` with unbound generic; lambda param mods w/o types; partial ctors/events; user-defined compound assign.
-
-## Build
-
-* .NET 5+: `dotnet build`, `dotnet publish`.
-* .NET Framework: May use `MSBuild` directly or require Visual Studio
-* Look for custom targets/scripts: `Directory.Build.targets`, `build.cmd/.sh`, `Build.ps1`.
-
-## Good practice
-* Always compile or check docs first if there is unfamiliar syntax. Don't try to correct the syntax if code can compile.
-* Don't change TFM, SDK, or `<LangVersion>` unless asked.
-
-
-# Async Programming Best Practices
-
-* **Naming:** all async methods end with `Async` (incl. CLI handlers).
-* **Always await:** no fire-and-forget; if timing out, **cancel the work**.
-* **Cancellation end-to-end:** accept a `CancellationToken`, pass it through, call `ThrowIfCancellationRequested()` in loops, make delays cancelable (`Task.Delay(ms, ct)`).
-* **Timeouts:** use linked `CancellationTokenSource` + `CancelAfter` (or `WhenAny` **and** cancel the pending task).
-* **Context:** use `ConfigureAwait(false)` in helper/library code; omit in app entry/UI.
-* **Stream JSON:** `GetAsync(..., ResponseHeadersRead)` → `ReadAsStreamAsync` → `JsonDocument.ParseAsync`; avoid `ReadAsStringAsync` when large.
-* **Exit code on cancel:** return non-zero (e.g., `130`).
-* **`ValueTask`:** use only when measured to help; default to `Task`.
-* **Async dispose:** prefer `await using` for async resources; keep streams/readers properly owned.
-* **No pointless wrappers:** don’t add `async/await` if you just return the task.
-
-## Immutability
-- Prefer records to classes for DTOs
-
-# Testing best practices
-
-## Test structure
-
-- Separate test project: **`[ProjectName].Tests`**.
-- Mirror classes: `CatDoor` -> `CatDoorTests`.
-- Name tests by behavior: `WhenCatMeowsThenCatDoorOpens`.
-- Follow existing naming conventions.
-- Use **public instance** classes; avoid **static** fields.
-- No branching/conditionals inside tests.
-
-## Unit Tests
-
-- One behavior per test;
-- Avoid Unicode symbols.
-- Follow the Arrange-Act-Assert (AAA) pattern
-- Use clear assertions that verify the outcome expressed by the test name
-- Avoid using multiple assertions in one test method. In this case, prefer multiple tests.
-- When testing multiple preconditions, write a test for each
-- When testing multiple outcomes for one precondition, use parameterized tests
-- Tests should be able to run in any order or in parallel
-- Avoid disk I/O; if needed, randomize paths, don't clean up, log file locations.
-- Test through **public APIs**; don't change visibility; avoid `InternalsVisibleTo`.
-- Require tests for new/changed **public APIs**.
-- Assert specific values and edge cases, not vague outcomes.
-
-## Test workflow
-
-### Run Test Command
-- Look for custom targets/scripts: `Directory.Build.targets`, `test.ps1/.cmd/.sh`
-- .NET Framework: May use `vstest.console.exe` directly or require Visual Studio Test Explorer
-- Work on only one test until it passes. Then run other tests to ensure nothing has been broken.
-
-### Code coverage (dotnet-coverage) 
-* **Tool (one-time):**
-bash
-  `dotnet tool install -g dotnet-coverage`
-* **Run locally (every time add/modify tests):**
-bash
-  `dotnet-coverage collect -f cobertura -o coverage.cobertura.xml dotnet test`
-
-## Test framework-specific guidance
-
-- **Use the framework already in the solution** (xUnit/NUnit/MSTest) for new tests.
-
-### xUnit
-
-* Packages: `Microsoft.NET.Test.Sdk`, `xunit`, `xunit.runner.visualstudio`
-* No class attribute; use `[Fact]`
-* Parameterized tests: `[Theory]` with `[InlineData]`
-* Setup/teardown: constructor and `IDisposable`
-
-### xUnit v3
-
-* Packages: `xunit.v3`, `xunit.runner.visualstudio` 3.x, `Microsoft.NET.Test.Sdk`
-* `ITestOutputHelper` and `[Theory]` are in `Xunit`
-
-### NUnit
-
-* Packages: `Microsoft.NET.Test.Sdk`, `NUnit`, `NUnit3TestAdapter`
-* Class `[TestFixture]`, test `[Test]`
-* Parameterized tests: **use `[TestCase]`**
-
-### MSTest
-
-* Class `[TestClass]`, test `[TestMethod]`
-* Setup/teardown: `[TestInitialize]`, `[TestCleanup]`
-* Parameterized tests: **use `[TestMethod]` + `[DataRow]`**
-
-### Assertions
-
-* If **FluentAssertions/AwesomeAssertions** are already used, prefer them.
-* Otherwise, use the framework’s asserts.
-* Use `Throws/ThrowsAsync` (or MSTest `Assert.ThrowsException`) for exceptions.
-
-## Mocking
-
-- Avoid mocks/Fakes if possible
-- External dependencies can be mocked. Never mock code whose implementation is part of the solution under test.
-- Try to verify that the outputs (e.g. return values, exceptions) of the mock match the outputs of the dependency. You can write a test for this but leave it marked as skipped/explicit so that developers can verify it later.

.github/agents/copilot-agent.yml

@@ -0,0 +1,17 @@
+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/instructions/csharp.instructions.md

@@ -1,114 +0,0 @@
----
-description: 'Guidelines for building C# applications'
-applyTo: '**/*.cs'
----
-
-# C# Development
-
-## C# Instructions
-- Always use the latest version C#, currently C# 14 features.
-- Write clear and concise comments for each function.
-
-## 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.
-
-## Naming Conventions
-
-- Follow PascalCase for component names, method names, and public members.
-- Use camelCase for private fields and local variables.
-- Prefix interface names with "I" (e.g., IUserService).
-
-## Formatting
-
-- Apply code-formatting style defined in `.editorconfig`.
-- Prefer file-scoped namespace declarations and single-line using directives.
-- Insert a newline before the opening curly brace of any code block (e.g., after `if`, `for`, `while`, `foreach`, `using`, `try`, etc.).
-- Ensure that the final return statement of a method is on its own line.
-- Use pattern matching and switch expressions wherever possible.
-- Use `nameof` instead of string literals when referring to member names.
-- Ensure that XML doc comments are created for any public APIs. When applicable, include `<example>` and `<code>` documentation in the comments.
-
-## Project Setup and Structure
-
-- 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 10 including environment-specific settings.
-
-## Nullable Reference Types
-
-- Declare variables non-nullable, and check for `null` at entry points.
-- 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.
-
-## Data Access Patterns
-
-- Guide the implementation of a data access layer using Entity Framework Core.
-- Explain different options (SQL Server, SQLite, In-Memory) for development and production.
-- Demonstrate repository pattern implementation and when it's beneficial.
-- Show how to implement database migrations and data seeding.
-- Explain efficient query patterns to avoid common performance issues.
-
-## Authentication and Authorization
-
-- Guide users through implementing authentication using JWT Bearer tokens.
-- Explain OAuth 2.0 and OpenID Connect concepts as they relate to ASP.NET Core.
-- Show how to implement role-based and policy-based authorization.
-- Demonstrate integration with Microsoft Entra ID (formerly Azure AD).
-- Explain how to secure both controller-based and Minimal APIs consistently.
-
-## Validation and Error Handling
-
-- Guide the implementation of model validation using data annotations and FluentValidation.
-- Explain the validation pipeline and how to customize validation responses.
-- Demonstrate a global exception handling strategy using middleware.
-- Show how to create consistent error responses across the API.
-- Explain problem details (RFC 7807) implementation for standardized error responses.
-
-## API Versioning and Documentation
-
-- Guide users through implementing and explaining API versioning strategies.
-- Demonstrate Swagger/OpenAPI implementation with proper documentation.
-- Show how to document endpoints, parameters, responses, and authentication.
-- Explain versioning in both controller-based and Minimal APIs.
-- Guide users on creating meaningful API documentation that helps consumers.
-
-## Logging and Monitoring
-
-- Guide the implementation of structured logging using Serilog or other providers.
-- Explain the logging levels and when to use each.
-- Demonstrate integration with Application Insights for telemetry collection.
-- Show how to implement custom telemetry and correlation IDs for request tracking.
-- Explain how to monitor API performance, errors, and usage patterns.
-
-## Testing
-
-- Always include test cases for critical paths of the application.
-- 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.
-- 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.
-
-## Deployment and DevOps
-
-- Guide users through containerizing their API using .NET's built-in container support (`dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer`).
-- Explain the differences between manual Dockerfile creation and .NET's container publishing features.
-- Explain CI/CD pipelines for NET applications.
-- Demonstrate deployment to Azure App Service, Azure Container Apps, or other hosting options.
-- Show how to implement health checks and readiness probes.
-- Explain environment-specific configurations for different deployment stages.

.github/prompts/create-readme.prompt.md

@@ -1,21 +0,0 @@
----
-mode: 'agent'
-description: 'Create a README.md file for the project'
----
-
-## Role
-
-You're a senior expert software engineer with extensive experience in open source projects. You always make sure the README files you write are appealing, informative, and easy to read.
-
-## Task
-
-1. Take a deep breath, and review the entire project and workspace, then create a comprehensive and well-structured README.md file for the project.
-2. Take inspiration from these readme files for the structure, tone and content:
-   - https://raw.githubusercontent.com/Azure-Samples/serverless-chat-langchainjs/refs/heads/main/README.md
-   - https://raw.githubusercontent.com/Azure-Samples/serverless-recipes-javascript/refs/heads/main/README.md
-   - https://raw.githubusercontent.com/sinedied/run-on-output/refs/heads/main/README.md
-   - https://raw.githubusercontent.com/sinedied/smoke/refs/heads/main/README.md
-3. Do not overuse emojis, and keep the readme concise and to the point.
-4. Do not include sections like "LICENSE", "CONTRIBUTING", "CHANGELOG", etc. There are dedicated files for those sections.
-5. Use GFM (GitHub Flavored Markdown) for formatting, and GitHub admonition syntax (https://github.com/orgs/community/discussions/16925) where appropriate.
-6. If you find a logo or icon for the project, use it in the readme's header.

.github/prompts/create-specification.prompt.md

@@ -1,127 +0,0 @@
----
-mode: 'agent'
-description: 'Create a new specification file for the solution, optimized for Generative AI consumption.'
-tools: ['changes', 'search/codebase', 'edit/editFiles', 'extensions', 'fetch', 'githubRepo', 'openSimpleBrowser', 'problems', 'runTasks', 'search', 'search/searchResults', 'runCommands/terminalLastCommand', 'runCommands/terminalSelection', 'testFailure', 'usages', 'vscodeAPI']
----
-# Create Specification
-
-Your goal is to create a new specification file for `${input:SpecPurpose}`.
-
-The specification file must define the requirements, constraints, and interfaces for the solution components in a manner that is clear, unambiguous, and structured for effective use by Generative AIs. Follow established documentation standards and ensure the content is machine-readable and self-contained.
-
-## Best Practices for AI-Ready Specifications
-
-- Use precise, explicit, and unambiguous language.
-- Clearly distinguish between requirements, constraints, and recommendations.
-- Use structured formatting (headings, lists, tables) for easy parsing.
-- Avoid idioms, metaphors, or context-dependent references.
-- Define all acronyms and domain-specific terms.
-- Include examples and edge cases where applicable.
-- Ensure the document is self-contained and does not rely on external context.
-
-The specification should be saved in the [/spec/](/spec/) directory and named according to the following convention: `spec-[a-z0-9-]+.md`, where the name should be descriptive of the specification's content and starting with the highlevel purpose, which is one of [schema, tool, data, infrastructure, process, architecture, or design].
-
-The specification file must be formatted in well formed Markdown.
-
-Specification files must follow the template below, ensuring that all sections are filled out appropriately. The front matter for the markdown should be structured correctly as per the example following:
-
-```md
----
-title: [Concise Title Describing the Specification's Focus]
-version: [Optional: e.g., 1.0, Date]
-date_created: [YYYY-MM-DD]
-last_updated: [Optional: YYYY-MM-DD]
-owner: [Optional: Team/Individual responsible for this spec]
-tags: [Optional: List of relevant tags or categories, e.g., `infrastructure`, `process`, `design`, `app` etc]
----
-
-# Introduction
-
-[A short concise introduction to the specification and the goal it is intended to achieve.]
-
-## 1. Purpose & Scope
-
-[Provide a clear, concise description of the specification's purpose and the scope of its application. State the intended audience and any assumptions.]
-
-## 2. Definitions
-
-[List and define all acronyms, abbreviations, and domain-specific terms used in this specification.]
-
-## 3. Requirements, Constraints & Guidelines
-
-[Explicitly list all requirements, constraints, rules, and guidelines. Use bullet points or tables for clarity.]
-
-- **REQ-001**: Requirement 1
-- **SEC-001**: Security Requirement 1
-- **[3 LETTERS]-001**: Other Requirement 1
-- **CON-001**: Constraint 1
-- **GUD-001**: Guideline 1
-- **PAT-001**: Pattern to follow 1
-
-## 4. Interfaces & Data Contracts
-
-[Describe the interfaces, APIs, data contracts, or integration points. Use tables or code blocks for schemas and examples.]
-
-## 5. Acceptance Criteria
-
-[Define clear, testable acceptance criteria for each requirement using Given-When-Then format where appropriate.]
-
-- **AC-001**: Given [context], When [action], Then [expected outcome]
-- **AC-002**: The system shall [specific behavior] when [condition]
-- **AC-003**: [Additional acceptance criteria as needed]
-
-## 6. Test Automation Strategy
-
-[Define the testing approach, frameworks, and automation requirements.]
-
-- **Test Levels**: Unit, Integration, End-to-End
-- **Frameworks**: MSTest, FluentAssertions, Moq (for .NET applications)
-- **Test Data Management**: [approach for test data creation and cleanup]
-- **CI/CD Integration**: [automated testing in GitHub Actions pipelines]
-- **Coverage Requirements**: [minimum code coverage thresholds]
-- **Performance Testing**: [approach for load and performance testing]
-
-## 7. Rationale & Context
-
-[Explain the reasoning behind the requirements, constraints, and guidelines. Provide context for design decisions.]
-
-## 8. Dependencies & External Integrations
-
-[Define the external systems, services, and architectural dependencies required for this specification. Focus on **what** is needed rather than **how** it's implemented. Avoid specific package or library versions unless they represent architectural constraints.]
-
-### External Systems
-- **EXT-001**: [External system name] - [Purpose and integration type]
-
-### Third-Party Services
-- **SVC-001**: [Service name] - [Required capabilities and SLA requirements]
-
-### Infrastructure Dependencies
-- **INF-001**: [Infrastructure component] - [Requirements and constraints]
-
-### Data Dependencies
-- **DAT-001**: [External data source] - [Format, frequency, and access requirements]
-
-### Technology Platform Dependencies
-- **PLT-001**: [Platform/runtime requirement] - [Version constraints and rationale]
-
-### Compliance Dependencies
-- **COM-001**: [Regulatory or compliance requirement] - [Impact on implementation]
-
-**Note**: This section should focus on architectural and business dependencies, not specific package implementations. For example, specify "OAuth 2.0 authentication library" rather than "Microsoft.AspNetCore.Authentication.JwtBearer v6.0.1".
-
-## 9. Examples & Edge Cases
-
-    ```code
-    // Code snippet or data example demonstrating the correct application of the guidelines, including edge cases
-    ```
-
-## 10. Validation Criteria
-
-[List the criteria or tests that must be satisfied for compliance with this specification.]
-
-## 11. Related Specifications / Further Reading
-
-[Link to related spec 1]
-[Link to relevant external documentation]
-
-```

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

@@ -1,50 +0,0 @@
----
-mode: 'agent'
-tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems']
-description: 'Get best practices for C# async programming'
----
-
-# C# Async Programming Best Practices
-
-Your goal is to help me follow best practices for asynchronous programming in C#.
-
-## Naming Conventions
-
-- Use the 'Async' suffix for all async methods
-- Match method names with their synchronous counterparts when applicable (e.g., `GetDataAsync()` for `GetData()`)
-
-## Return Types
-
-- Return `Task<T>` when the method returns a value
-- Return `Task` when the method doesn't return a value
-- Consider `ValueTask<T>` for high-performance scenarios to reduce allocations
-- Avoid returning `void` for async methods except for event handlers
-
-## Exception Handling
-
-- Use try/catch blocks around await expressions
-- Avoid swallowing exceptions in async methods
-- Use `ConfigureAwait(false)` when appropriate to prevent deadlocks in library code
-- Propagate exceptions with `Task.FromException()` instead of throwing in async Task returning methods
-
-## Performance
-
-- Use `Task.WhenAll()` for parallel execution of multiple tasks
-- Use `Task.WhenAny()` for implementing timeouts or taking the first completed task
-- Avoid unnecessary async/await when simply passing through task results
-- Consider cancellation tokens for long-running operations
-
-## Common Pitfalls
-
-- Never use `.Wait()`, `.Result`, or `.GetAwaiter().GetResult()` in async code
-- Avoid mixing blocking and async code
-- Don't create async void methods (except for event handlers)
-- Always await Task-returning methods
-
-## Implementation Patterns
-
-- Implement the async command pattern for long-running operations
-- Use async streams (IAsyncEnumerable<T>) for processing sequences asynchronously
-- Consider the task-based asynchronous pattern (TAP) for public APIs
-
-When reviewing my C# code, identify these issues and suggest improvements that follow these best practices.

.github/prompts/csharp-xunit.prompt.md

@@ -1,69 +0,0 @@
----
-mode: 'agent'
-tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems', 'search']
-description: 'Get best practices for XUnit unit testing, including data-driven tests'
----
-
-# XUnit Best Practices
-
-Your goal is to help me write effective unit tests with XUnit, covering both standard and data-driven testing approaches.
-
-## Project Setup
-
-- Use a separate test project with naming convention `[ProjectName].Tests`
-- Reference Microsoft.NET.Test.Sdk, xunit, and xunit.runner.visualstudio packages
-- Create test classes that match the classes being tested (e.g., `CalculatorTests` for `Calculator`)
-- Use .NET SDK test commands: `dotnet test` for running tests
-
-## Test Structure
-
-- No test class attributes required (unlike MSTest/NUnit)
-- Use fact-based tests with `[Fact]` attribute for simple tests
-- Follow the Arrange-Act-Assert (AAA) pattern
-- Name tests using the pattern `MethodName_Scenario_ExpectedBehavior`
-- Use constructor for setup and `IDisposable.Dispose()` for teardown
-- Use `IClassFixture<T>` for shared context between tests in a class
-- Use `ICollectionFixture<T>` for shared context between multiple test classes
-
-## Standard Tests
-
-- Keep tests focused on a single behavior
-- Avoid testing multiple behaviors in one test method
-- Use clear assertions that express intent
-- Include only the assertions needed to verify the test case
-- Make tests independent and idempotent (can run in any order)
-- Avoid test interdependencies
-
-## Data-Driven Tests
-
-- Use `[Theory]` combined with data source attributes
-- Use `[InlineData]` for inline test data
-- Use `[MemberData]` for method-based test data
-- Use `[ClassData]` for class-based test data
-- Create custom data attributes by implementing `DataAttribute`
-- Use meaningful parameter names in data-driven tests
-
-## Assertions
-
-- Use `Assert.Equal` for value equality
-- Use `Assert.Same` for reference equality
-- Use `Assert.True`/`Assert.False` for boolean conditions
-- Use `Assert.Contains`/`Assert.DoesNotContain` for collections
-- Use `Assert.Matches`/`Assert.DoesNotMatch` for regex pattern matching
-- Use `Assert.Throws<T>` or `await Assert.ThrowsAsync<T>` to test exceptions
-- Use fluent assertions library for more readable assertions
-
-## Mocking and Isolation
-
-- Consider using Moq or NSubstitute alongside XUnit
-- Mock dependencies to isolate units under test
-- Use interfaces to facilitate mocking
-- Consider using a DI container for complex test setups
-
-## Test Organization
-
-- Group tests by feature or component
-- Use `[Trait("Category", "CategoryName")]` for categorization
-- Use collection fixtures to group tests with shared dependencies
-- Consider output helpers (`ITestOutputHelper`) for test diagnostics
-- Skip tests conditionally with `Skip = "reason"` in fact/theory attributes

.github/prompts/dotnet-best-practices.prompt.md

@@ -1,84 +0,0 @@
----
-mode: 'agent'
-description: 'Ensure .NET/C# code meets best practices for the solution/project.'
----
-# .NET/C# Best Practices
-
-Your task is to ensure .NET/C# code in ${selection} meets the best practices specific to this solution/project. This includes:
-
-## Documentation & Structure
-
-- Create comprehensive XML documentation comments for all public classes, interfaces, methods, and properties
-- Include parameter descriptions and return value descriptions in XML comments
-- Follow the established namespace structure: {Core|Console|App|Service}.{Feature}
-
-## Design Patterns & Architecture
-
-- Use primary constructor syntax for dependency injection (e.g., `public class MyClass(IDependency dependency)`)
-- Implement the Command Handler pattern with generic base classes (e.g., `CommandHandler<TOptions>`)
-- Use interface segregation with clear naming conventions (prefix interfaces with 'I')
-- Follow the Factory pattern for complex object creation.
-
-## Dependency Injection & Services
-
-- Use constructor dependency injection with null checks via ArgumentNullException
-- Register services with appropriate lifetimes (Singleton, Scoped, Transient)
-- Use Microsoft.Extensions.DependencyInjection patterns
-- Implement service interfaces for testability
-
-## Resource Management & Localization
-
-- Use ResourceManager for localized messages and error strings
-- Separate LogMessages and ErrorMessages resource files
-- Access resources via `_resourceManager.GetString("MessageKey")`
-
-## Async/Await Patterns
-
-- Use async/await for all I/O operations and long-running tasks
-- Return Task or Task<T> from async methods
-- Use ConfigureAwait(false) where appropriate
-- Handle async exceptions properly
-
-## Testing Standards
-
-- Use MSTest framework with FluentAssertions for assertions
-- Follow AAA pattern (Arrange, Act, Assert)
-- Use Moq for mocking dependencies
-- Test both success and failure scenarios
-- Include null parameter validation tests
-
-## Configuration & Settings
-
-- Use strongly-typed configuration classes with data annotations
-- Implement validation attributes (Required, NotEmptyOrWhitespace)
-- Use IConfiguration binding for settings
-- Support appsettings.json configuration files
-
-## Semantic Kernel & AI Integration
-
-- Use Microsoft.SemanticKernel for AI operations
-- Implement proper kernel configuration and service registration
-- Handle AI model settings (ChatCompletion, Embedding, etc.)
-- Use structured output patterns for reliable AI responses
-
-## Error Handling & Logging
-
-- Use structured logging with Microsoft.Extensions.Logging
-- Include scoped logging with meaningful context
-- Throw specific exceptions with descriptive messages
-- Use try-catch blocks for expected failure scenarios
-
-## Performance & Security
-
-- Use C# 12+ features and .NET 8 optimizations where applicable
-- Implement proper input validation and sanitization
-- Use parameterized queries for database operations
-- Follow secure coding practices for AI/ML operations
-
-## Code Quality
-
-- Ensure SOLID principles compliance
-- Avoid code duplication through base classes and utilities
-- Use meaningful names that reflect domain concepts
-- Keep methods focused and cohesive
-- Implement proper disposal patterns for resources

.github/prompts/dotnet-design-pattern-review.prompt.md

@@ -1,41 +0,0 @@
----
-mode: 'agent'
-description: 'Review the C#/.NET code for design pattern implementation and suggest improvements.'
----
-# .NET/C# Design Pattern Review
-
-Review the C#/.NET code in ${selection} for design pattern implementation and suggest improvements for the solution/project. Do not make any changes to the code, just provide a review.
-
-## Required Design Patterns
-
-- **Command Pattern**: Generic base classes (`CommandHandler<TOptions>`), `ICommandHandler<TOptions>` interface, `CommandHandlerOptions` inheritance, static `SetupCommand(IHost host)` methods
-- **Factory Pattern**: Complex object creation service provider integration
-- **Dependency Injection**: Primary constructor syntax, `ArgumentNullException` null checks, interface abstractions, proper service lifetimes
-- **Repository Pattern**: Async data access interfaces provider abstractions for connections
-- **Provider Pattern**: External service abstractions (database, AI), clear contracts, configuration handling
-- **Resource Pattern**: ResourceManager for localized messages, separate .resx files (LogMessages, ErrorMessages)
-
-## Review Checklist
-
-- **Design Patterns**: Identify patterns used. Are Command Handler, Factory, Provider, and Repository patterns correctly implemented? Missing beneficial patterns?
-- **Architecture**: Follow namespace conventions (`{Core|Console|App|Service}.{Feature}`)? Proper separation between Core/Console projects? Modular and readable?
-- **.NET Best Practices**: Primary constructors, async/await with Task returns, ResourceManager usage, structured logging, strongly-typed configuration?
-- **GoF Patterns**: Command, Factory, Template Method, Strategy patterns correctly implemented?
-- **SOLID Principles**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion violations?
-- **Performance**: Proper async/await, resource disposal, ConfigureAwait(false), parallel processing opportunities?
-- **Maintainability**: Clear separation of concerns, consistent error handling, proper configuration usage?
-- **Testability**: Dependencies abstracted via interfaces, mockable components, async testability, AAA pattern compatibility?
-- **Security**: Input validation, secure credential handling, parameterized queries, safe exception handling?
-- **Documentation**: XML docs for public APIs, parameter/return descriptions, resource file organization?
-- **Code Clarity**: Meaningful names reflecting domain concepts, clear intent through patterns, self-explanatory structure?
-- **Clean Code**: Consistent style, appropriate method/class size, minimal complexity, eliminated duplication?
-
-## Improvement Focus Areas
-
-- **Command Handlers**: Validation in base class, consistent error handling, proper resource management
-- **Factories**: Dependency configuration, service provider integration, disposal patterns
-- **Providers**: Connection management, async patterns, exception handling and logging
-- **Configuration**: Data annotations, validation attributes, secure sensitive value handling
-- **AI/ML Integration**: Semantic Kernel patterns, structured output handling, model configuration
-
-Provide specific, actionable recommendations for improvements aligned with the project's architecture and .NET best practices.

.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,21 @@ 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 .`
+- **ALWAYS run `dotnet csharpier format .` after making code changes before committing.**
+- 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 +45,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

@@ -14,7 +14,6 @@
     <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
     <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,6 +1,6 @@
 # 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).
 

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,8 +20,9 @@ public static class ArchiveFactory
     public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
-        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
+        var factory = FindFactory<IArchiveFactory>(stream);
+        stream = new SharpCompressStream(stream, bufferSize: readerOptions.BufferSize);
+        return factory.Open(stream, readerOptions);
     }
 
     public static IWritableArchive Create(ArchiveType type)

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;
@@ -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

@@ -15,10 +15,9 @@ 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();
     }

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;
 
@@ -32,34 +30,6 @@ public static class IArchiveEntryExtensions
         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);
-        }
-        streamListener.FireEntryExtractionEnd(archiveEntry);
-    }
-
     /// <summary>
     /// Extract to specific directory, retaining filename
     /// </summary>
@@ -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,
-            (x, opt) => entry.WriteToFileAsync(x, opt, cancellationToken),
-            cancellationToken
-        );
-
     /// <summary>
     /// Extract to specific file
     /// </summary>
@@ -110,24 +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) =>
-            {
-                using var fs = File.Open(destinationFileName, fm);
-                await entry.WriteToAsync(fs, cancellationToken).ConfigureAwait(false);
-            }
-        );
 }

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

@@ -70,51 +70,24 @@ 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;
+        return new RarStream(
+            archive.UnpackV2017.Value,
+            FileHeader,
+            new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+        );
     }
 
-    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;
-    }
+    public Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
+        Task.FromResult(OpenEntryStream());
 
     public bool IsComplete
     {

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;
@@ -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/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;
@@ -308,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
+            );
         }
     }
 
@@ -372,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()

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/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.CompressedSize > 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

@@ -29,5 +29,4 @@ public enum CompressionType
     Crushed,
     Distilled,
     ZStandard,
-    ArjLZ77,
 }

src/SharpCompress/Common/EntryStream.cs

@@ -64,11 +64,6 @@ public class EntryStream : Stream, IStreamStack
 
     protected override void Dispose(bool disposing)
     {
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
         if (!(_completed || _reader.Cancelled))
         {
             SkipEntry();
@@ -86,6 +81,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
@@ -96,11 +97,6 @@ public class EntryStream : Stream, IStreamStack
 #if !NETFRAMEWORK && !NETSTANDARD2_0
     public override async ValueTask DisposeAsync()
     {
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
         if (!(_completed || _reader.Cancelled))
         {
             await SkipEntryAsync().ConfigureAwait(false);
@@ -118,6 +114,12 @@ public class EntryStream : Stream, IStreamStack
                 await lzmaStream.FlushAsync().ConfigureAwait(false);
             }
         }
+
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
 #if DEBUG_STREAMS
         this.DebugDispose(typeof(EntryStream));
 #endif
@@ -202,11 +204,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,6 +1,5 @@
 using System;
 using System.IO;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -8,15 +7,6 @@ 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 +48,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 +68,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."
@@ -163,7 +158,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."
@@ -183,7 +178,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."

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/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/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/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/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/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

@@ -3,8 +3,6 @@
 using System;
 using System.Buffers;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Compressors.LZMA.LZ;
 
@@ -87,12 +85,6 @@ internal class OutWindow : IDisposable
         _stream = null;
     }
 
-    public async Task ReleaseStreamAsync(CancellationToken cancellationToken = default)
-    {
-        await FlushAsync(cancellationToken).ConfigureAwait(false);
-        _stream = null;
-    }
-
     private void Flush()
     {
         if (_stream is null)
@@ -112,27 +104,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 +124,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 +157,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 +167,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 +207,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)
@@ -313,42 +309,6 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
         _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;
-    }
-
     internal bool Code(int dictionarySize, OutWindow outWindow, RangeCoder.Decoder rangeDecoder)
     {
         var dictionarySizeCheck = Math.Max(dictionarySize, 1);
@@ -475,143 +435,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 +470,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;
 
@@ -425,82 +423,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 +435,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/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/RLE90/RunLength90Stream.cs

@@ -1,13 +1,13 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.RLE90
 {
-    /// <summary>
-    /// Real-time streaming RLE90 decompression stream.
-    /// Decompresses bytes on demand without buffering the entire file in memory.
-    /// </summary>
     public class RunLength90Stream : Stream, IStreamStack
     {
 #if DEBUG_STREAMS
@@ -31,19 +31,13 @@ namespace SharpCompress.Compressors.RLE90
         void IStreamStack.SetPosition(long position) { }
 
         private readonly Stream _stream;
-        private readonly int _compressedSize;
-        private int _bytesReadFromSource;
-
         private const byte DLE = 0x90;
-        private bool _inDleMode;
-        private byte _lastByte;
-        private int _repeatCount;
-
-        private bool _endOfCompressedData;
+        private int _compressedSize;
+        private bool _processed = false;
 
         public RunLength90Stream(Stream stream, int compressedSize)
         {
-            _stream = stream ?? throw new ArgumentNullException(nameof(stream));
+            _stream = stream;
             _compressedSize = compressedSize;
 #if DEBUG_STREAMS
             this.DebugConstruct(typeof(RunLength90Stream));
@@ -59,93 +53,44 @@ namespace SharpCompress.Compressors.RLE90
         }
 
         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 Length => throw new NotImplementedException();
+
         public override long Position
         {
-            get => throw new NotSupportedException();
-            set => throw new NotSupportedException();
+            get => _stream.Position;
+            set => throw new NotImplementedException();
         }
 
-        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();
+        public override void Flush() => throw new NotImplementedException();
 
         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();
-
-            int bytesWritten = 0;
-
-            while (bytesWritten < count && !_endOfCompressedData)
+            if (_processed)
             {
-                // Handle pending repeat bytes first
-                if (_repeatCount > 0)
-                {
-                    int toWrite = Math.Min(_repeatCount, count - bytesWritten);
-                    for (int i = 0; i < toWrite; i++)
-                    {
-                        buffer[offset + bytesWritten++] = _lastByte;
-                    }
-                    _repeatCount -= toWrite;
-                    continue;
-                }
-
-                // Try to read the next byte from compressed data
-                if (_bytesReadFromSource >= _compressedSize)
-                {
-                    _endOfCompressedData = true;
-                    break;
-                }
-
-                int next = _stream.ReadByte();
-                if (next == -1)
-                {
-                    _endOfCompressedData = true;
-                    break;
-                }
-
-                _bytesReadFromSource++;
-                byte c = (byte)next;
-
-                if (_inDleMode)
-                {
-                    _inDleMode = false;
-
-                    if (c == 0)
-                    {
-                        buffer[offset + bytesWritten++] = DLE;
-                        _lastByte = DLE;
-                    }
-                    else
-                    {
-                        _repeatCount = c - 1;
-                        // We’ll handle these repeats in next loop iteration.
-                    }
-                }
-                else if (c == DLE)
-                {
-                    _inDleMode = true;
-                }
-                else
-                {
-                    buffer[offset + bytesWritten++] = c;
-                    _lastByte = c;
-                }
+                return 0;
             }
+            _processed = true;
 
-            return bytesWritten;
+            using var binaryReader = new BinaryReader(_stream);
+            byte[] compressedBuffer = binaryReader.ReadBytes(_compressedSize);
+
+            var unpacked = RLE.UnpackRLE(compressedBuffer);
+            unpacked.CopyTo(buffer);
+
+            return unpacked.Count;
         }
+
+        public override long Seek(long offset, SeekOrigin origin) =>
+            throw new NotImplementedException();
+
+        public override void SetLength(long value) => throw new NotImplementedException();
+
+        public override void Write(byte[] buffer, int offset, int count) =>
+            throw new NotImplementedException();
     }
 }

src/SharpCompress/Compressors/Rar/IRarUnpack.cs

@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar.Headers;
 
 namespace SharpCompress.Compressors.Rar;
@@ -10,14 +8,6 @@ internal interface IRarUnpack
     void DoUnpack(FileHeader fileHeader, Stream readStream, Stream writeStream);
     void DoUnpack();
 
-    Task DoUnpackAsync(
-        FileHeader fileHeader,
-        Stream readStream,
-        Stream writeStream,
-        CancellationToken cancellationToken
-    );
-    Task DoUnpackAsync(CancellationToken cancellationToken);
-
     // eg u/i pause/resume button
     bool Suspended { get; set; }
 

src/SharpCompress/Compressors/Rar/MultiVolumeReadOnlyStream.cs

@@ -150,136 +150,6 @@ internal sealed class MultiVolumeReadOnlyStream : Stream, IStreamStack
         return totalRead;
     }
 
-    public override async System.Threading.Tasks.Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken
-    )
-    {
-        var totalRead = 0;
-        var currentOffset = offset;
-        var currentCount = count;
-        while (currentCount > 0)
-        {
-            var readSize = currentCount;
-            if (currentCount > maxPosition - currentPosition)
-            {
-                readSize = (int)(maxPosition - currentPosition);
-            }
-
-            var read = await currentStream
-                .ReadAsync(buffer, currentOffset, readSize, cancellationToken)
-                .ConfigureAwait(false);
-            if (read < 0)
-            {
-                throw new EndOfStreamException();
-            }
-
-            currentPosition += read;
-            currentOffset += read;
-            currentCount -= read;
-            totalRead += read;
-            if (
-                ((maxPosition - currentPosition) == 0)
-                && filePartEnumerator.Current.FileHeader.IsSplitAfter
-            )
-            {
-                if (filePartEnumerator.Current.FileHeader.R4Salt != null)
-                {
-                    throw new InvalidFormatException(
-                        "Sharpcompress currently does not support multi-volume decryption."
-                    );
-                }
-                var fileName = filePartEnumerator.Current.FileHeader.FileName;
-                if (!filePartEnumerator.MoveNext())
-                {
-                    throw new InvalidFormatException(
-                        "Multi-part rar file is incomplete.  Entry expects a new volume: "
-                            + fileName
-                    );
-                }
-                InitializeNextFilePart();
-            }
-            else
-            {
-                break;
-            }
-        }
-        currentPartTotalReadBytes += totalRead;
-        currentEntryTotalReadBytes += totalRead;
-        streamListener.FireCompressedBytesRead(
-            currentPartTotalReadBytes,
-            currentEntryTotalReadBytes
-        );
-        return totalRead;
-    }
-
-#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var totalRead = 0;
-        var currentOffset = 0;
-        var currentCount = buffer.Length;
-        while (currentCount > 0)
-        {
-            var readSize = currentCount;
-            if (currentCount > maxPosition - currentPosition)
-            {
-                readSize = (int)(maxPosition - currentPosition);
-            }
-
-            var read = await currentStream
-                .ReadAsync(buffer.Slice(currentOffset, readSize), cancellationToken)
-                .ConfigureAwait(false);
-            if (read < 0)
-            {
-                throw new EndOfStreamException();
-            }
-
-            currentPosition += read;
-            currentOffset += read;
-            currentCount -= read;
-            totalRead += read;
-            if (
-                ((maxPosition - currentPosition) == 0)
-                && filePartEnumerator.Current.FileHeader.IsSplitAfter
-            )
-            {
-                if (filePartEnumerator.Current.FileHeader.R4Salt != null)
-                {
-                    throw new InvalidFormatException(
-                        "Sharpcompress currently does not support multi-volume decryption."
-                    );
-                }
-                var fileName = filePartEnumerator.Current.FileHeader.FileName;
-                if (!filePartEnumerator.MoveNext())
-                {
-                    throw new InvalidFormatException(
-                        "Multi-part rar file is incomplete.  Entry expects a new volume: "
-                            + fileName
-                    );
-                }
-                InitializeNextFilePart();
-            }
-            else
-            {
-                break;
-            }
-        }
-        currentPartTotalReadBytes += totalRead;
-        currentEntryTotalReadBytes += totalRead;
-        streamListener.FireCompressedBytesRead(
-            currentPartTotalReadBytes,
-            currentEntryTotalReadBytes
-        );
-        return totalRead;
-    }
-#endif
-
     public override bool CanRead => true;
 
     public override bool CanSeek => false;

src/SharpCompress/Compressors/Rar/RarBLAKE2spStream.cs

@@ -1,8 +1,6 @@
 using System;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
@@ -105,7 +103,7 @@ internal class RarBLAKE2spStream : RarStream, IStreamStack
 
     byte[] _hash = { };
 
-    private RarBLAKE2spStream(
+    public RarBLAKE2spStream(
         IRarUnpack unpack,
         FileHeader fileHeader,
         MultiVolumeReadOnlyStream readStream
@@ -123,29 +121,6 @@ internal class RarBLAKE2spStream : RarStream, IStreamStack
         ResetCrc();
     }
 
-    public static RarBLAKE2spStream Create(
-        IRarUnpack unpack,
-        FileHeader fileHeader,
-        MultiVolumeReadOnlyStream readStream
-    )
-    {
-        var stream = new RarBLAKE2spStream(unpack, fileHeader, readStream);
-        stream.Initialize();
-        return stream;
-    }
-
-    public static async Task<RarBLAKE2spStream> CreateAsync(
-        IRarUnpack unpack,
-        FileHeader fileHeader,
-        MultiVolumeReadOnlyStream readStream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var stream = new RarBLAKE2spStream(unpack, fileHeader, readStream);
-        await stream.InitializeAsync(cancellationToken);
-        return stream;
-    }
-
     protected override void Dispose(bool disposing)
     {
 #if DEBUG_STREAMS
@@ -358,59 +333,4 @@ internal class RarBLAKE2spStream : RarStream, IStreamStack
 
         return result;
     }
-
-    public override async System.Threading.Tasks.Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken
-    )
-    {
-        var result = await base.ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (result != 0)
-        {
-            Update(_blake2sp, new ReadOnlySpan<byte>(buffer, offset, result), result);
-        }
-        else
-        {
-            _hash = Final(_blake2sp);
-            if (!disableCRCCheck && !(GetCrc().SequenceEqual(readStream.CurrentCrc)) && count != 0)
-            {
-                // NOTE: we use the last FileHeader in a multipart volume to check CRC
-                throw new InvalidFormatException("file crc mismatch");
-            }
-        }
-
-        return result;
-    }
-
-#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var result = await base.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-        if (result != 0)
-        {
-            Update(_blake2sp, buffer.Span.Slice(0, result), result);
-        }
-        else
-        {
-            _hash = Final(_blake2sp);
-            if (
-                !disableCRCCheck
-                && !(GetCrc().SequenceEqual(readStream.CurrentCrc))
-                && buffer.Length != 0
-            )
-            {
-                // NOTE: we use the last FileHeader in a multipart volume to check CRC
-                throw new InvalidFormatException("file crc mismatch");
-            }
-        }
-
-        return result;
-    }
-#endif
 }

src/SharpCompress/Compressors/Rar/RarCrcStream.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
@@ -33,7 +31,7 @@ internal class RarCrcStream : RarStream, IStreamStack
     private uint currentCrc;
     private readonly bool disableCRC;
 
-    private RarCrcStream(
+    public RarCrcStream(
         IRarUnpack unpack,
         FileHeader fileHeader,
         MultiVolumeReadOnlyStream readStream
@@ -48,29 +46,6 @@ internal class RarCrcStream : RarStream, IStreamStack
         ResetCrc();
     }
 
-    public static RarCrcStream Create(
-        IRarUnpack unpack,
-        FileHeader fileHeader,
-        MultiVolumeReadOnlyStream readStream
-    )
-    {
-        var stream = new RarCrcStream(unpack, fileHeader, readStream);
-        stream.Initialize();
-        return stream;
-    }
-
-    public static async Task<RarCrcStream> CreateAsync(
-        IRarUnpack unpack,
-        FileHeader fileHeader,
-        MultiVolumeReadOnlyStream readStream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var stream = new RarCrcStream(unpack, fileHeader, readStream);
-        await stream.InitializeAsync(cancellationToken);
-        return stream;
-    }
-
     protected override void Dispose(bool disposing)
     {
 #if DEBUG_STREAMS
@@ -102,56 +77,4 @@ internal class RarCrcStream : RarStream, IStreamStack
 
         return result;
     }
-
-    public override async System.Threading.Tasks.Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken
-    )
-    {
-        var result = await base.ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (result != 0)
-        {
-            currentCrc = RarCRC.CheckCrc(currentCrc, buffer, offset, result);
-        }
-        else if (
-            !disableCRC
-            && GetCrc() != BitConverter.ToUInt32(readStream.CurrentCrc, 0)
-            && count != 0
-        )
-        {
-            // NOTE: we use the last FileHeader in a multipart volume to check CRC
-            throw new InvalidFormatException("file crc mismatch");
-        }
-
-        return result;
-    }
-
-#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var result = await base.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-        if (result != 0)
-        {
-            currentCrc = RarCRC.CheckCrc(currentCrc, buffer.Span, 0, result);
-        }
-        else if (
-            !disableCRC
-            && GetCrc() != BitConverter.ToUInt32(readStream.CurrentCrc, 0)
-            && buffer.Length != 0
-        )
-        {
-            // NOTE: we use the last FileHeader in a multipart volume to check CRC
-            throw new InvalidFormatException("file crc mismatch");
-        }
-
-        return result;
-    }
-#endif
 }

src/SharpCompress/Compressors/Rar/RarStream.cs

@@ -3,8 +3,6 @@
 using System;
 using System.Buffers;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 
@@ -58,24 +56,13 @@ internal class RarStream : Stream, IStreamStack
 #if DEBUG_STREAMS
         this.DebugConstruct(typeof(RarStream));
 #endif
-    }
 
-    public void Initialize()
-    {
         fetch = true;
         unpack.DoUnpack(fileHeader, readStream, this);
         fetch = false;
         _position = 0;
     }
 
-    public async Task InitializeAsync(CancellationToken cancellationToken = default)
-    {
-        fetch = true;
-        await unpack.DoUnpackAsync(fileHeader, readStream, this, cancellationToken);
-        fetch = false;
-        _position = 0;
-    }
-
     protected override void Dispose(bool disposing)
     {
         if (!isDisposed)
@@ -144,73 +131,6 @@ internal class RarStream : Stream, IStreamStack
         return outTotal;
     }
 
-    public override async System.Threading.Tasks.Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken
-    ) => await ReadImplAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
-
-    private async System.Threading.Tasks.Task<int> ReadImplAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken
-    )
-    {
-        outTotal = 0;
-        if (tmpCount > 0)
-        {
-            var toCopy = tmpCount < count ? tmpCount : count;
-            Buffer.BlockCopy(tmpBuffer, tmpOffset, buffer, offset, toCopy);
-            tmpOffset += toCopy;
-            tmpCount -= toCopy;
-            offset += toCopy;
-            count -= toCopy;
-            outTotal += toCopy;
-        }
-        if (count > 0 && unpack.DestSize > 0)
-        {
-            outBuffer = buffer;
-            outOffset = offset;
-            outCount = count;
-            fetch = true;
-            await unpack.DoUnpackAsync(cancellationToken).ConfigureAwait(false);
-            fetch = false;
-        }
-        _position += outTotal;
-        if (count > 0 && outTotal == 0 && _position != Length)
-        {
-            // sanity check, eg if we try to decompress a redir entry
-            throw new InvalidOperationException(
-                $"unpacked file size does not match header: expected {Length} found {_position}"
-            );
-        }
-        return outTotal;
-    }
-
-#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
-    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var array = System.Buffers.ArrayPool<byte>.Shared.Rent(buffer.Length);
-        try
-        {
-            var bytesRead = await ReadImplAsync(array, 0, buffer.Length, cancellationToken)
-                .ConfigureAwait(false);
-            new ReadOnlySpan<byte>(array, 0, bytesRead).CopyTo(buffer.Span);
-            return bytesRead;
-        }
-        finally
-        {
-            System.Buffers.ArrayPool<byte>.Shared.Return(array);
-        }
-    }
-#endif
-
     public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
 
     public override void SetLength(long value) => throw new NotSupportedException();
@@ -245,18 +165,6 @@ internal class RarStream : Stream, IStreamStack
         }
     }
 
-    public override System.Threading.Tasks.Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        Write(buffer, offset, count);
-        return System.Threading.Tasks.Task.CompletedTask;
-    }
-
     private void EnsureBufferCapacity(int count)
     {
         if (this.tmpBuffer.Length < this.tmpCount + count)

src/SharpCompress/Compressors/Rar/UnpackV1/Unpack.cs

@@ -27,7 +27,7 @@ internal sealed partial class Unpack : BitInput, IRarUnpack
         if (!disposed)
         {
             base.Dispose();
-            if (!externalWindow && window is not null)
+            if (!externalWindow)
             {
                 ArrayPool<byte>.Shared.Return(window);
                 window = null;
@@ -155,25 +155,6 @@ internal sealed partial class Unpack : BitInput, IRarUnpack
         DoUnpack();
     }
 
-    public async System.Threading.Tasks.Task DoUnpackAsync(
-        FileHeader fileHeader,
-        Stream readStream,
-        Stream writeStream,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        destUnpSize = fileHeader.UncompressedSize;
-        this.fileHeader = fileHeader;
-        this.readStream = readStream;
-        this.writeStream = writeStream;
-        if (!fileHeader.IsSolid)
-        {
-            Init(null);
-        }
-        suspended = false;
-        await DoUnpackAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     public void DoUnpack()
     {
         if (fileHeader.CompressionMethod == 0)
@@ -208,42 +189,6 @@ internal sealed partial class Unpack : BitInput, IRarUnpack
         }
     }
 
-    public async System.Threading.Tasks.Task DoUnpackAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (fileHeader.CompressionMethod == 0)
-        {
-            await UnstoreFileAsync(cancellationToken).ConfigureAwait(false);
-            return;
-        }
-        switch (fileHeader.CompressionAlgorithm)
-        {
-            case 15: // rar 1.5 compression
-                await unpack15Async(fileHeader.IsSolid, cancellationToken).ConfigureAwait(false);
-                break;
-
-            case 20: // rar 2.x compression
-            case 26: // files larger than 2GB
-                await unpack20Async(fileHeader.IsSolid, cancellationToken).ConfigureAwait(false);
-                break;
-
-            case 29: // rar 3.x compression
-            case 36: // alternative hash
-                await Unpack29Async(fileHeader.IsSolid, cancellationToken).ConfigureAwait(false);
-                break;
-
-            case 50: // rar 5.x compression
-                await Unpack5Async(fileHeader.IsSolid, cancellationToken).ConfigureAwait(false);
-                break;
-
-            default:
-                throw new InvalidFormatException(
-                    "unknown rar compression version " + fileHeader.CompressionAlgorithm
-                );
-        }
-    }
-
     private void UnstoreFile()
     {
         Span<byte> buffer = stackalloc byte[(int)Math.Min(0x10000, destUnpSize)];
@@ -260,26 +205,6 @@ internal sealed partial class Unpack : BitInput, IRarUnpack
         } while (!suspended && destUnpSize > 0);
     }
 
-    private async System.Threading.Tasks.Task UnstoreFileAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var buffer = new byte[(int)Math.Min(0x10000, destUnpSize)];
-        do
-        {
-            var code = await readStream
-                .ReadAsync(buffer, 0, buffer.Length, cancellationToken)
-                .ConfigureAwait(false);
-            if (code == 0 || code == -1)
-            {
-                break;
-            }
-            code = code < destUnpSize ? code : (int)destUnpSize;
-            await writeStream.WriteAsync(buffer, 0, code, cancellationToken).ConfigureAwait(false);
-            destUnpSize -= code;
-        } while (!suspended && destUnpSize > 0);
-    }
-
     private void Unpack29(bool solid)
     {
         Span<int> DDecode = stackalloc int[PackDef.DC];
@@ -558,281 +483,6 @@ internal sealed partial class Unpack : BitInput, IRarUnpack
         UnpWriteBuf();
     }
 
-    private async System.Threading.Tasks.Task Unpack29Async(
-        bool solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        int[] DDecode = new int[PackDef.DC];
-        byte[] DBits = new byte[PackDef.DC];
-
-        int Bits;
-
-        if (DDecode[1] == 0)
-        {
-            int Dist = 0,
-                BitLength = 0,
-                Slot = 0;
-            for (var I = 0; I < DBitLengthCounts.Length; I++, BitLength++)
-            {
-                var count = DBitLengthCounts[I];
-                for (var J = 0; J < count; J++, Slot++, Dist += (1 << BitLength))
-                {
-                    DDecode[Slot] = Dist;
-                    DBits[Slot] = (byte)BitLength;
-                }
-            }
-        }
-
-        FileExtracted = true;
-
-        if (!suspended)
-        {
-            UnpInitData(solid);
-            if (!await unpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return;
-            }
-            if ((!solid || !tablesRead) && !ReadTables())
-            {
-                return;
-            }
-        }
-
-        if (ppmError)
-        {
-            return;
-        }
-
-        while (true)
-        {
-            unpPtr &= PackDef.MAXWINMASK;
-
-            if (inAddr > readBorder)
-            {
-                if (!await unpReadBufAsync(cancellationToken).ConfigureAwait(false))
-                {
-                    break;
-                }
-            }
-
-            if (((wrPtr - unpPtr) & PackDef.MAXWINMASK) < 260 && wrPtr != unpPtr)
-            {
-                await UnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-                if (destUnpSize < 0)
-                {
-                    return;
-                }
-                if (suspended)
-                {
-                    FileExtracted = false;
-                    return;
-                }
-            }
-            if (unpBlockType == BlockTypes.BLOCK_PPM)
-            {
-                var ch = ppm.DecodeChar();
-                if (ch == -1)
-                {
-                    ppmError = true;
-                    break;
-                }
-                if (ch == PpmEscChar)
-                {
-                    var nextCh = ppm.DecodeChar();
-                    if (nextCh == 0)
-                    {
-                        if (!ReadTables())
-                        {
-                            break;
-                        }
-                        continue;
-                    }
-                    if (nextCh == 2 || nextCh == -1)
-                    {
-                        break;
-                    }
-                    if (nextCh == 3)
-                    {
-                        if (!ReadVMCode())
-                        {
-                            break;
-                        }
-                        continue;
-                    }
-                    if (nextCh == 4)
-                    {
-                        uint Distance = 0,
-                            Length = 0;
-                        var failed = false;
-                        for (var I = 0; I < 4 && !failed; I++)
-                        {
-                            var ch2 = ppm.DecodeChar();
-                            if (ch2 == -1)
-                            {
-                                failed = true;
-                            }
-                            else if (I == 3)
-                            {
-                                Length = (uint)ch2;
-                            }
-                            else
-                            {
-                                Distance = (Distance << 8) + (uint)ch2;
-                            }
-                        }
-                        if (failed)
-                        {
-                            break;
-                        }
-
-                        CopyString(Length + 32, Distance + 2);
-                        continue;
-                    }
-                    if (nextCh == 5)
-                    {
-                        var length = ppm.DecodeChar();
-                        if (length == -1)
-                        {
-                            break;
-                        }
-                        CopyString((uint)(length + 4), 1);
-                        continue;
-                    }
-                }
-                window[unpPtr++] = (byte)ch;
-                continue;
-            }
-
-            var Number = this.decodeNumber(LD);
-            if (Number < 256)
-            {
-                window[unpPtr++] = (byte)Number;
-                continue;
-            }
-            if (Number >= 271)
-            {
-                var Length = LDecode[Number -= 271] + 3;
-                if ((Bits = LBits[Number]) > 0)
-                {
-                    Length += GetBits() >> (16 - Bits);
-                    AddBits(Bits);
-                }
-
-                var DistNumber = this.decodeNumber(DD);
-                var Distance = DDecode[DistNumber] + 1;
-                if ((Bits = DBits[DistNumber]) > 0)
-                {
-                    if (DistNumber > 9)
-                    {
-                        if (Bits > 4)
-                        {
-                            Distance += (GetBits() >> (20 - Bits)) << 4;
-                            AddBits(Bits - 4);
-                        }
-                        if (lowDistRepCount > 0)
-                        {
-                            lowDistRepCount--;
-                            Distance += prevLowDist;
-                        }
-                        else
-                        {
-                            var LowDist = this.decodeNumber(LDD);
-                            if (LowDist == 16)
-                            {
-                                lowDistRepCount = PackDef.LOW_DIST_REP_COUNT - 1;
-                                Distance += prevLowDist;
-                            }
-                            else
-                            {
-                                Distance += LowDist;
-                                prevLowDist = (int)LowDist;
-                            }
-                        }
-                    }
-                    else
-                    {
-                        Distance += GetBits() >> (16 - Bits);
-                        AddBits(Bits);
-                    }
-                }
-
-                if (Distance >= 0x2000)
-                {
-                    Length++;
-                    if (Distance >= 0x40000)
-                    {
-                        Length++;
-                    }
-                }
-
-                InsertOldDist(Distance);
-                lastLength = Length;
-                CopyString(Length, Distance);
-                continue;
-            }
-            if (Number == 256)
-            {
-                if (!ReadEndOfBlock())
-                {
-                    break;
-                }
-                continue;
-            }
-            if (Number == 257)
-            {
-                if (!ReadVMCode())
-                {
-                    break;
-                }
-                continue;
-            }
-            if (Number == 258)
-            {
-                if (lastLength != 0)
-                {
-                    CopyString(lastLength, oldDist[0]);
-                }
-
-                continue;
-            }
-            if (Number < 263)
-            {
-                var DistNum = Number - 259;
-                var Distance = (uint)oldDist[DistNum];
-                for (var I = DistNum; I > 0; I--)
-                {
-                    oldDist[I] = oldDist[I - 1];
-                }
-                oldDist[0] = (int)Distance;
-
-                var LengthNumber = this.decodeNumber(RD);
-                var Length = LDecode[LengthNumber] + 2;
-                if ((Bits = LBits[LengthNumber]) > 0)
-                {
-                    Length += GetBits() >> (16 - Bits);
-                    AddBits(Bits);
-                }
-                lastLength = Length;
-                CopyString((uint)Length, Distance);
-                continue;
-            }
-            if (Number < 272)
-            {
-                var Distance = SDDecode[Number -= 263] + 1;
-                if ((Bits = SDBits[Number]) > 0)
-                {
-                    Distance += GetBits() >> (16 - Bits);
-                    AddBits(Bits);
-                }
-                InsertOldDist((uint)Distance);
-                lastLength = 2;
-                CopyString(2, (uint)Distance);
-            }
-        }
-        await UnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     private void UnpWriteBuf()
     {
         var WrittenBorder = wrPtr;
@@ -1689,256 +1339,6 @@ internal sealed partial class Unpack : BitInput, IRarUnpack
         }
     }
 
-    private async System.Threading.Tasks.Task UnpWriteBufAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var WrittenBorder = wrPtr;
-        var WriteSize = (unpPtr - WrittenBorder) & PackDef.MAXWINMASK;
-        for (var I = 0; I < prgStack.Count; I++)
-        {
-            var flt = prgStack[I];
-            if (flt is null)
-            {
-                continue;
-            }
-            if (flt.NextWindow)
-            {
-                flt.NextWindow = false;
-                continue;
-            }
-            var BlockStart = flt.BlockStart;
-            var BlockLength = flt.BlockLength;
-            if (((BlockStart - WrittenBorder) & PackDef.MAXWINMASK) < WriteSize)
-            {
-                if (WrittenBorder != BlockStart)
-                {
-                    await UnpWriteAreaAsync(WrittenBorder, BlockStart, cancellationToken)
-                        .ConfigureAwait(false);
-                    WrittenBorder = BlockStart;
-                    WriteSize = (unpPtr - WrittenBorder) & PackDef.MAXWINMASK;
-                }
-                if (BlockLength <= WriteSize)
-                {
-                    var BlockEnd = (BlockStart + BlockLength) & PackDef.MAXWINMASK;
-                    if (BlockStart < BlockEnd || BlockEnd == 0)
-                    {
-                        rarVM.setMemory(0, window, BlockStart, BlockLength);
-                    }
-                    else
-                    {
-                        var FirstPartLength = PackDef.MAXWINSIZE - BlockStart;
-                        rarVM.setMemory(0, window, BlockStart, FirstPartLength);
-                        rarVM.setMemory(FirstPartLength, window, 0, BlockEnd);
-                    }
-
-                    var ParentPrg = filters[flt.ParentFilter].Program;
-                    var Prg = flt.Program;
-
-                    if (ParentPrg.GlobalData.Count > RarVM.VM_FIXEDGLOBALSIZE)
-                    {
-                        Prg.GlobalData.Clear();
-                        for (
-                            var i = 0;
-                            i < ParentPrg.GlobalData.Count - RarVM.VM_FIXEDGLOBALSIZE;
-                            i++
-                        )
-                        {
-                            Prg.GlobalData[RarVM.VM_FIXEDGLOBALSIZE + i] = ParentPrg.GlobalData[
-                                RarVM.VM_FIXEDGLOBALSIZE + i
-                            ];
-                        }
-                    }
-
-                    ExecuteCode(Prg);
-
-                    if (Prg.GlobalData.Count > RarVM.VM_FIXEDGLOBALSIZE)
-                    {
-                        if (ParentPrg.GlobalData.Count < Prg.GlobalData.Count)
-                        {
-                            ParentPrg.GlobalData.SetSize(Prg.GlobalData.Count);
-                        }
-
-                        for (var i = 0; i < Prg.GlobalData.Count - RarVM.VM_FIXEDGLOBALSIZE; i++)
-                        {
-                            ParentPrg.GlobalData[RarVM.VM_FIXEDGLOBALSIZE + i] = Prg.GlobalData[
-                                RarVM.VM_FIXEDGLOBALSIZE + i
-                            ];
-                        }
-                    }
-                    else
-                    {
-                        ParentPrg.GlobalData.Clear();
-                    }
-
-                    var FilteredDataOffset = Prg.FilteredDataOffset;
-                    var FilteredDataSize = Prg.FilteredDataSize;
-                    var FilteredData = ArrayPool<byte>.Shared.Rent(FilteredDataSize);
-                    try
-                    {
-                        Array.Copy(
-                            rarVM.Mem,
-                            FilteredDataOffset,
-                            FilteredData,
-                            0,
-                            FilteredDataSize
-                        );
-
-                        prgStack[I] = null;
-                        while (I + 1 < prgStack.Count)
-                        {
-                            var NextFilter = prgStack[I + 1];
-                            if (
-                                NextFilter is null
-                                || NextFilter.BlockStart != BlockStart
-                                || NextFilter.BlockLength != FilteredDataSize
-                                || NextFilter.NextWindow
-                            )
-                            {
-                                break;
-                            }
-
-                            rarVM.setMemory(0, FilteredData, 0, FilteredDataSize);
-
-                            var pPrg = filters[NextFilter.ParentFilter].Program;
-                            var NextPrg = NextFilter.Program;
-
-                            if (pPrg.GlobalData.Count > RarVM.VM_FIXEDGLOBALSIZE)
-                            {
-                                NextPrg.GlobalData.SetSize(pPrg.GlobalData.Count);
-
-                                for (
-                                    var i = 0;
-                                    i < pPrg.GlobalData.Count - RarVM.VM_FIXEDGLOBALSIZE;
-                                    i++
-                                )
-                                {
-                                    NextPrg.GlobalData[RarVM.VM_FIXEDGLOBALSIZE + i] =
-                                        pPrg.GlobalData[RarVM.VM_FIXEDGLOBALSIZE + i];
-                                }
-                            }
-
-                            ExecuteCode(NextPrg);
-
-                            if (NextPrg.GlobalData.Count > RarVM.VM_FIXEDGLOBALSIZE)
-                            {
-                                if (pPrg.GlobalData.Count < NextPrg.GlobalData.Count)
-                                {
-                                    pPrg.GlobalData.SetSize(NextPrg.GlobalData.Count);
-                                }
-
-                                for (
-                                    var i = 0;
-                                    i < NextPrg.GlobalData.Count - RarVM.VM_FIXEDGLOBALSIZE;
-                                    i++
-                                )
-                                {
-                                    pPrg.GlobalData[RarVM.VM_FIXEDGLOBALSIZE + i] =
-                                        NextPrg.GlobalData[RarVM.VM_FIXEDGLOBALSIZE + i];
-                                }
-                            }
-                            else
-                            {
-                                pPrg.GlobalData.Clear();
-                            }
-
-                            FilteredDataOffset = NextPrg.FilteredDataOffset;
-                            FilteredDataSize = NextPrg.FilteredDataSize;
-                            if (FilteredData.Length < FilteredDataSize)
-                            {
-                                ArrayPool<byte>.Shared.Return(FilteredData);
-                                FilteredData = ArrayPool<byte>.Shared.Rent(FilteredDataSize);
-                            }
-                            for (var i = 0; i < FilteredDataSize; i++)
-                            {
-                                FilteredData[i] = NextPrg.GlobalData[FilteredDataOffset + i];
-                            }
-
-                            I++;
-                            prgStack[I] = null;
-                        }
-
-                        await writeStream
-                            .WriteAsync(FilteredData, 0, FilteredDataSize, cancellationToken)
-                            .ConfigureAwait(false);
-                        writtenFileSize += FilteredDataSize;
-                        destUnpSize -= FilteredDataSize;
-                        WrittenBorder = BlockEnd;
-                        WriteSize = (unpPtr - WrittenBorder) & PackDef.MAXWINMASK;
-                    }
-                    finally
-                    {
-                        ArrayPool<byte>.Shared.Return(FilteredData);
-                    }
-                }
-                else
-                {
-                    for (var J = I; J < prgStack.Count; J++)
-                    {
-                        var filt = prgStack[J];
-                        if (filt != null && filt.NextWindow)
-                        {
-                            filt.NextWindow = false;
-                        }
-                    }
-                    wrPtr = WrittenBorder;
-                    return;
-                }
-            }
-        }
-
-        await UnpWriteAreaAsync(WrittenBorder, unpPtr, cancellationToken).ConfigureAwait(false);
-        wrPtr = unpPtr;
-    }
-
-    private async System.Threading.Tasks.Task UnpWriteAreaAsync(
-        int startPtr,
-        int endPtr,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (endPtr < startPtr)
-        {
-            await UnpWriteDataAsync(
-                    window,
-                    startPtr,
-                    -startPtr & PackDef.MAXWINMASK,
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
-            await UnpWriteDataAsync(window, 0, endPtr, cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            await UnpWriteDataAsync(window, startPtr, endPtr - startPtr, cancellationToken)
-                .ConfigureAwait(false);
-        }
-    }
-
-    private async System.Threading.Tasks.Task UnpWriteDataAsync(
-        byte[] data,
-        int offset,
-        int size,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (destUnpSize < 0)
-        {
-            return;
-        }
-        var writeSize = size;
-        if (writeSize > destUnpSize)
-        {
-            writeSize = (int)destUnpSize;
-        }
-        await writeStream
-            .WriteAsync(data, offset, writeSize, cancellationToken)
-            .ConfigureAwait(false);
-
-        writtenFileSize += size;
-        destUnpSize -= size;
-    }
-
     private void CleanUp()
     {
         if (ppm != null)

src/SharpCompress/Compressors/Rar/UnpackV1/Unpack15.cs

@@ -316,110 +316,6 @@ internal partial class Unpack
         oldUnpWriteBuf();
     }
 
-    private async System.Threading.Tasks.Task unpack15Async(
-        bool solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (suspended)
-        {
-            unpPtr = wrPtr;
-        }
-        else
-        {
-            UnpInitData(solid);
-            oldUnpInitData(solid);
-            await unpReadBufAsync(cancellationToken).ConfigureAwait(false);
-            if (!solid)
-            {
-                initHuff();
-                unpPtr = 0;
-            }
-            else
-            {
-                unpPtr = wrPtr;
-            }
-            --destUnpSize;
-        }
-        if (destUnpSize >= 0)
-        {
-            getFlagsBuf();
-            FlagsCnt = 8;
-        }
-
-        while (destUnpSize >= 0)
-        {
-            unpPtr &= PackDef.MAXWINMASK;
-
-            if (
-                inAddr > readTop - 30
-                && !await unpReadBufAsync(cancellationToken).ConfigureAwait(false)
-            )
-            {
-                break;
-            }
-            if (((wrPtr - unpPtr) & PackDef.MAXWINMASK) < 270 && wrPtr != unpPtr)
-            {
-                await oldUnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-                if (suspended)
-                {
-                    return;
-                }
-            }
-            if (StMode != 0)
-            {
-                huffDecode();
-                continue;
-            }
-
-            if (--FlagsCnt < 0)
-            {
-                getFlagsBuf();
-                FlagsCnt = 7;
-            }
-
-            if ((FlagBuf & 0x80) != 0)
-            {
-                FlagBuf <<= 1;
-                if (Nlzb > Nhfb)
-                {
-                    longLZ();
-                }
-                else
-                {
-                    huffDecode();
-                }
-            }
-            else
-            {
-                FlagBuf <<= 1;
-                if (--FlagsCnt < 0)
-                {
-                    getFlagsBuf();
-                    FlagsCnt = 7;
-                }
-                if ((FlagBuf & 0x80) != 0)
-                {
-                    FlagBuf <<= 1;
-                    if (Nlzb > Nhfb)
-                    {
-                        huffDecode();
-                    }
-                    else
-                    {
-                        longLZ();
-                    }
-                }
-                else
-                {
-                    FlagBuf <<= 1;
-                    shortLZ();
-                }
-            }
-        }
-        await oldUnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     private bool unpReadBuf()
     {
         var dataSize = readTop - inAddr;
@@ -455,40 +351,6 @@ internal partial class Unpack
         return (readCode != -1);
     }
 
-    private async System.Threading.Tasks.Task<bool> unpReadBufAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var dataSize = readTop - inAddr;
-        if (dataSize < 0)
-        {
-            return (false);
-        }
-        if (inAddr > MAX_SIZE / 2)
-        {
-            if (dataSize > 0)
-            {
-                Array.Copy(InBuf, inAddr, InBuf, 0, dataSize);
-            }
-            inAddr = 0;
-            readTop = dataSize;
-        }
-        else
-        {
-            dataSize = readTop;
-        }
-
-        var readCode = await readStream
-            .ReadAsync(InBuf, dataSize, (MAX_SIZE - dataSize) & ~0xf, cancellationToken)
-            .ConfigureAwait(false);
-        if (readCode > 0)
-        {
-            readTop += readCode;
-        }
-        readBorder = readTop - 30;
-        return (readCode != -1);
-    }
-
     private int getShortLen1(int pos) => pos == 1 ? Buf60 + 3 : ShortLen1[pos];
 
     private int getShortLen2(int pos) => pos == 3 ? Buf60 + 3 : ShortLen2[pos];
@@ -952,26 +814,4 @@ internal partial class Unpack
         }
         wrPtr = unpPtr;
     }
-
-    private async System.Threading.Tasks.Task oldUnpWriteBufAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (unpPtr < wrPtr)
-        {
-            await writeStream
-                .WriteAsync(window, wrPtr, -wrPtr & PackDef.MAXWINMASK, cancellationToken)
-                .ConfigureAwait(false);
-            await writeStream
-                .WriteAsync(window, 0, unpPtr, cancellationToken)
-                .ConfigureAwait(false);
-        }
-        else
-        {
-            await writeStream
-                .WriteAsync(window, wrPtr, unpPtr - wrPtr, cancellationToken)
-                .ConfigureAwait(false);
-        }
-        wrPtr = unpPtr;
-    }
 }

src/SharpCompress/Compressors/Rar/UnpackV1/Unpack20.cs

@@ -368,163 +368,6 @@ internal partial class Unpack
         oldUnpWriteBuf();
     }
 
-    private async System.Threading.Tasks.Task unpack20Async(
-        bool solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        int Bits;
-
-        if (suspended)
-        {
-            unpPtr = wrPtr;
-        }
-        else
-        {
-            UnpInitData(solid);
-            if (!await unpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return;
-            }
-            if (!solid)
-            {
-                if (!await ReadTables20Async(cancellationToken).ConfigureAwait(false))
-                {
-                    return;
-                }
-            }
-            --destUnpSize;
-        }
-
-        while (destUnpSize >= 0)
-        {
-            unpPtr &= PackDef.MAXWINMASK;
-
-            if (inAddr > readTop - 30)
-            {
-                if (!await unpReadBufAsync(cancellationToken).ConfigureAwait(false))
-                {
-                    break;
-                }
-            }
-            if (((wrPtr - unpPtr) & PackDef.MAXWINMASK) < 270 && wrPtr != unpPtr)
-            {
-                await oldUnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-                if (suspended)
-                {
-                    return;
-                }
-            }
-            if (UnpAudioBlock != 0)
-            {
-                var AudioNumber = this.decodeNumber(MD[UnpCurChannel]);
-
-                if (AudioNumber == 256)
-                {
-                    if (!await ReadTables20Async(cancellationToken).ConfigureAwait(false))
-                    {
-                        break;
-                    }
-                    continue;
-                }
-                window[unpPtr++] = DecodeAudio(AudioNumber);
-                if (++UnpCurChannel == UnpChannels)
-                {
-                    UnpCurChannel = 0;
-                }
-                --destUnpSize;
-                continue;
-            }
-
-            var Number = this.decodeNumber(LD);
-            if (Number < 256)
-            {
-                window[unpPtr++] = (byte)Number;
-                --destUnpSize;
-                continue;
-            }
-            if (Number > 269)
-            {
-                var Length = LDecode[Number -= 270] + 3;
-                if ((Bits = LBits[Number]) > 0)
-                {
-                    Length += Utility.URShift(GetBits(), (16 - Bits));
-                    AddBits(Bits);
-                }
-
-                var DistNumber = this.decodeNumber(DD);
-                var Distance = DDecode[DistNumber] + 1;
-                if ((Bits = DBits[DistNumber]) > 0)
-                {
-                    Distance += Utility.URShift(GetBits(), (16 - Bits));
-                    AddBits(Bits);
-                }
-
-                if (Distance >= 0x2000)
-                {
-                    Length++;
-                    if (Distance >= 0x40000L)
-                    {
-                        Length++;
-                    }
-                }
-
-                CopyString20(Length, Distance);
-                continue;
-            }
-            if (Number == 269)
-            {
-                if (!await ReadTables20Async(cancellationToken).ConfigureAwait(false))
-                {
-                    break;
-                }
-                continue;
-            }
-            if (Number == 256)
-            {
-                CopyString20(lastLength, lastDist);
-                continue;
-            }
-            if (Number < 261)
-            {
-                var Distance = oldDist[(oldDistPtr - (Number - 256)) & 3];
-                var LengthNumber = this.decodeNumber(RD);
-                var Length = LDecode[LengthNumber] + 2;
-                if ((Bits = LBits[LengthNumber]) > 0)
-                {
-                    Length += Utility.URShift(GetBits(), (16 - Bits));
-                    AddBits(Bits);
-                }
-                if (Distance >= 0x101)
-                {
-                    Length++;
-                    if (Distance >= 0x2000)
-                    {
-                        Length++;
-                        if (Distance >= 0x40000)
-                        {
-                            Length++;
-                        }
-                    }
-                }
-                CopyString20(Length, Distance);
-                continue;
-            }
-            if (Number < 270)
-            {
-                var Distance = SDDecode[Number -= 261] + 1;
-                if ((Bits = SDBits[Number]) > 0)
-                {
-                    Distance += Utility.URShift(GetBits(), (16 - Bits));
-                    AddBits(Bits);
-                }
-                CopyString20(2, Distance);
-            }
-        }
-        ReadLastTables();
-        await oldUnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     private void CopyString20(int Length, int Distance)
     {
         lastDist = oldDist[oldDistPtr++ & 3] = Distance;
@@ -691,120 +534,6 @@ internal partial class Unpack
         return (true);
     }
 
-    private async System.Threading.Tasks.Task<bool> ReadTables20Async(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        byte[] BitLength = new byte[PackDef.BC20];
-        byte[] Table = new byte[PackDef.MC20 * 4];
-        int TableSize,
-            N,
-            I;
-        if (inAddr > readTop - 25)
-        {
-            if (!await unpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return (false);
-            }
-        }
-        var BitField = GetBits();
-        UnpAudioBlock = (BitField & 0x8000);
-
-        if (0 == (BitField & 0x4000))
-        {
-            new Span<byte>(UnpOldTable20).Clear();
-        }
-        AddBits(2);
-
-        if (UnpAudioBlock != 0)
-        {
-            UnpChannels = ((Utility.URShift(BitField, 12)) & 3) + 1;
-            if (UnpCurChannel >= UnpChannels)
-            {
-                UnpCurChannel = 0;
-            }
-            AddBits(2);
-            TableSize = PackDef.MC20 * UnpChannels;
-        }
-        else
-        {
-            TableSize = PackDef.NC20 + PackDef.DC20 + PackDef.RC20;
-        }
-        for (I = 0; I < PackDef.BC20; I++)
-        {
-            BitLength[I] = (byte)(Utility.URShift(GetBits(), 12));
-            AddBits(4);
-        }
-        UnpackUtility.makeDecodeTables(BitLength, 0, BD, PackDef.BC20);
-        I = 0;
-        while (I < TableSize)
-        {
-            if (inAddr > readTop - 5)
-            {
-                if (!await unpReadBufAsync(cancellationToken).ConfigureAwait(false))
-                {
-                    return (false);
-                }
-            }
-            var Number = this.decodeNumber(BD);
-            if (Number < 16)
-            {
-                Table[I] = (byte)((Number + UnpOldTable20[I]) & 0xf);
-                I++;
-            }
-            else if (Number == 16)
-            {
-                N = (Utility.URShift(GetBits(), 14)) + 3;
-                AddBits(2);
-                while (N-- > 0 && I < TableSize)
-                {
-                    Table[I] = Table[I - 1];
-                    I++;
-                }
-            }
-            else
-            {
-                if (Number == 17)
-                {
-                    N = (Utility.URShift(GetBits(), 13)) + 3;
-                    AddBits(3);
-                }
-                else
-                {
-                    N = (Utility.URShift(GetBits(), 9)) + 11;
-                    AddBits(7);
-                }
-                while (N-- > 0 && I < TableSize)
-                {
-                    Table[I++] = 0;
-                }
-            }
-        }
-        if (inAddr > readTop)
-        {
-            return (true);
-        }
-        if (UnpAudioBlock != 0)
-        {
-            for (I = 0; I < UnpChannels; I++)
-            {
-                UnpackUtility.makeDecodeTables(Table, I * PackDef.MC20, MD[I], PackDef.MC20);
-            }
-        }
-        else
-        {
-            UnpackUtility.makeDecodeTables(Table, 0, LD, PackDef.NC20);
-            UnpackUtility.makeDecodeTables(Table, PackDef.NC20, DD, PackDef.DC20);
-            UnpackUtility.makeDecodeTables(Table, PackDef.NC20 + PackDef.DC20, RD, PackDef.RC20);
-        }
-
-        for (var i = 0; i < UnpOldTable20.Length; i++)
-        {
-            UnpOldTable20[i] = Table[i];
-        }
-        return (true);
-    }
-
     private void unpInitData20(bool Solid)
     {
         if (!Solid)

src/SharpCompress/Compressors/Rar/UnpackV1/Unpack50.cs

@@ -479,354 +479,6 @@ internal partial class Unpack
         return ReadCode != -1;
     }
 
-    private async System.Threading.Tasks.Task<bool> UnpReadBufAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var DataSize = ReadTop - Inp.InAddr; // Data left to process.
-        if (DataSize < 0)
-        {
-            return false;
-        }
-
-        BlockHeader.BlockSize -= Inp.InAddr - BlockHeader.BlockStart;
-        if (Inp.InAddr > MAX_SIZE / 2)
-        {
-            if (DataSize > 0)
-            {
-                Array.Copy(InBuf, inAddr, InBuf, 0, DataSize);
-            }
-
-            Inp.InAddr = 0;
-            ReadTop = DataSize;
-        }
-        else
-        {
-            DataSize = ReadTop;
-        }
-
-        var ReadCode = 0;
-        if (MAX_SIZE != DataSize)
-        {
-            ReadCode = await readStream
-                .ReadAsync(InBuf, DataSize, MAX_SIZE - DataSize, cancellationToken)
-                .ConfigureAwait(false);
-        }
-
-        if (ReadCode > 0) // Can be also -1.
-        {
-            ReadTop += ReadCode;
-        }
-
-        ReadBorder = ReadTop - 30;
-        BlockHeader.BlockStart = Inp.InAddr;
-        if (BlockHeader.BlockSize != -1) // '-1' means not defined yet.
-        {
-            ReadBorder = Math.Min(ReadBorder, BlockHeader.BlockStart + BlockHeader.BlockSize - 1);
-        }
-        return ReadCode != -1;
-    }
-
-    public async System.Threading.Tasks.Task Unpack5Async(
-        bool Solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        FileExtracted = true;
-
-        if (!Suspended)
-        {
-            UnpInitData(Solid);
-            if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return;
-            }
-
-            // Check TablesRead5 to be sure that we read tables at least once
-            // regardless of current block header TablePresent flag.
-            // So we can safefly use these tables below.
-            if (
-                !await ReadBlockHeaderAsync(cancellationToken).ConfigureAwait(false)
-                || !ReadTables()
-                || !TablesRead5
-            )
-            {
-                return;
-            }
-        }
-
-        while (true)
-        {
-            UnpPtr &= MaxWinMask;
-
-            if (Inp.InAddr >= ReadBorder)
-            {
-                var FileDone = false;
-
-                // We use 'while', because for empty block containing only Huffman table,
-                // we'll be on the block border once again just after reading the table.
-                while (
-                    Inp.InAddr > BlockHeader.BlockStart + BlockHeader.BlockSize - 1
-                    || Inp.InAddr == BlockHeader.BlockStart + BlockHeader.BlockSize - 1
-                        && Inp.InBit >= BlockHeader.BlockBitSize
-                )
-                {
-                    if (BlockHeader.LastBlockInFile)
-                    {
-                        FileDone = true;
-                        break;
-                    }
-                    if (
-                        !await ReadBlockHeaderAsync(cancellationToken).ConfigureAwait(false)
-                        || !ReadTables()
-                    )
-                    {
-                        return;
-                    }
-                }
-                if (FileDone || !await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-                {
-                    break;
-                }
-            }
-
-            if (
-                ((WriteBorder - UnpPtr) & MaxWinMask) < PackDef.MAX_LZ_MATCH + 3
-                && WriteBorder != UnpPtr
-            )
-            {
-                UnpWriteBuf();
-                if (WrittenFileSize > DestUnpSize)
-                {
-                    return;
-                }
-
-                if (Suspended)
-                {
-                    FileExtracted = false;
-                    return;
-                }
-            }
-
-            //uint MainSlot=DecodeNumber(Inp,LD);
-            var MainSlot = this.DecodeNumber(LD);
-            if (MainSlot < 256)
-            {
-                //              if (Fragmented)
-                //                FragWindow[UnpPtr++]=(byte)MainSlot;
-                //              else
-                Window[UnpPtr++] = (byte)MainSlot;
-                continue;
-            }
-            if (MainSlot >= 262)
-            {
-                var Length = SlotToLength(MainSlot - 262);
-
-                //uint DBits,Distance=1,DistSlot=DecodeNumber(Inp,&BlockTables.DD);
-                int DBits;
-                uint Distance = 1,
-                    DistSlot = this.DecodeNumber(DD);
-                if (DistSlot < 4)
-                {
-                    DBits = 0;
-                    Distance += DistSlot;
-                }
-                else
-                {
-                    //DBits=DistSlot/2 - 1;
-                    DBits = (int)((DistSlot / 2) - 1);
-                    Distance += (2 | (DistSlot & 1)) << DBits;
-                }
-
-                if (DBits > 0)
-                {
-                    if (DBits >= 4)
-                    {
-                        if (DBits > 4)
-                        {
-                            Distance += ((Inp.getbits() >> (36 - DBits)) << 4);
-                            Inp.AddBits(DBits - 4);
-                        }
-                        //uint LowDist=DecodeNumber(Inp,&BlockTables.LDD);
-                        var LowDist = this.DecodeNumber(LDD);
-                        Distance += LowDist;
-                    }
-                    else
-                    {
-                        Distance += Inp.getbits() >> (32 - DBits);
-                        Inp.AddBits(DBits);
-                    }
-                }
-
-                if (Distance > 0x100)
-                {
-                    Length++;
-                    if (Distance > 0x2000)
-                    {
-                        Length++;
-                        if (Distance > 0x40000)
-                        {
-                            Length++;
-                        }
-                    }
-                }
-
-                InsertOldDist(Distance);
-                LastLength = Length;
-                //              if (Fragmented)
-                //                FragWindow.CopyString(Length,Distance,UnpPtr,MaxWinMask);
-                //              else
-                CopyString(Length, Distance);
-                continue;
-            }
-            if (MainSlot == 256)
-            {
-                var Filter = new UnpackFilter();
-                if (
-                    !await ReadFilterAsync(Filter, cancellationToken).ConfigureAwait(false)
-                    || !AddFilter(Filter)
-                )
-                {
-                    break;
-                }
-
-                continue;
-            }
-            if (MainSlot == 257)
-            {
-                if (LastLength != 0)
-                //                if (Fragmented)
-                //                  FragWindow.CopyString(LastLength,OldDist[0],UnpPtr,MaxWinMask);
-                //                else
-                //CopyString(LastLength,OldDist[0]);
-                {
-                    CopyString(LastLength, OldDistN(0));
-                }
-
-                continue;
-            }
-            if (MainSlot < 262)
-            {
-                //uint DistNum=MainSlot-258;
-                var DistNum = (int)(MainSlot - 258);
-                //uint Distance=OldDist[DistNum];
-                var Distance = OldDistN(DistNum);
-                //for (uint I=DistNum;I>0;I--)
-                for (var I = DistNum; I > 0; I--)
-                //OldDistN[I]=OldDistN(I-1);
-                {
-                    SetOldDistN(I, OldDistN(I - 1));
-                }
-
-                //OldDistN[0]=Distance;
-                SetOldDistN(0, Distance);
-
-                var LengthSlot = this.DecodeNumber(RD);
-                var Length = SlotToLength(LengthSlot);
-                LastLength = Length;
-                //              if (Fragmented)
-                //                FragWindow.CopyString(Length,Distance,UnpPtr,MaxWinMask);
-                //              else
-                CopyString(Length, Distance);
-                continue;
-            }
-        }
-        UnpWriteBuf();
-    }
-
-    private async System.Threading.Tasks.Task<bool> ReadBlockHeaderAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        Header.HeaderSize = 0;
-
-        if (!Inp.ExternalBuffer && Inp.InAddr > ReadTop - 7)
-        {
-            if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return false;
-            }
-        }
-
-        //Inp.faddbits((8-Inp.InBit)&7);
-        Inp.faddbits((uint)((8 - Inp.InBit) & 7));
-
-        var BlockFlags = (byte)(Inp.fgetbits() >> 8);
-        Inp.faddbits(8);
-        //uint ByteCount=((BlockFlags>>3)&3)+1; // Block size byte count.
-        var ByteCount = (uint)(((BlockFlags >> 3) & 3) + 1); // Block size byte count.
-
-        if (ByteCount == 4)
-        {
-            return false;
-        }
-
-        //Header.HeaderSize=2+ByteCount;
-        Header.HeaderSize = (int)(2 + ByteCount);
-
-        Header.BlockBitSize = (BlockFlags & 7) + 1;
-
-        var SavedCheckSum = (byte)(Inp.fgetbits() >> 8);
-        Inp.faddbits(8);
-
-        var BlockSize = 0;
-        //for (uint I=0;I<ByteCount;I++)
-        for (var I = 0; I < ByteCount; I++)
-        {
-            //BlockSize+=(Inp.fgetbits()>>8)<<(I*8);
-            BlockSize += (int)(Inp.fgetbits() >> 8) << (I * 8);
-            Inp.AddBits(8);
-        }
-
-        Header.BlockSize = BlockSize;
-        var CheckSum = (byte)(0x5a ^ BlockFlags ^ BlockSize ^ (BlockSize >> 8) ^ (BlockSize >> 16));
-        if (CheckSum != SavedCheckSum)
-        {
-            return false;
-        }
-
-        Header.BlockStart = Inp.InAddr;
-        ReadBorder = Math.Min(ReadBorder, Header.BlockStart + Header.BlockSize - 1);
-
-        Header.LastBlockInFile = (BlockFlags & 0x40) != 0;
-        Header.TablePresent = (BlockFlags & 0x80) != 0;
-        return true;
-    }
-
-    private async System.Threading.Tasks.Task<bool> ReadFilterAsync(
-        UnpackFilter Filter,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (!Inp.ExternalBuffer && Inp.InAddr > ReadTop - 16)
-        {
-            if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return false;
-            }
-        }
-
-        Filter.uBlockStart = ReadFilterData();
-        Filter.uBlockLength = ReadFilterData();
-        if (Filter.BlockLength > MAX_FILTER_BLOCK_SIZE)
-        {
-            Filter.BlockLength = 0;
-        }
-
-        //Filter.Type=Inp.fgetbits()>>13;
-        Filter.Type = (byte)(Inp.fgetbits() >> 13);
-        Inp.faddbits(3);
-
-        if (Filter.Type == (byte)FilterType.FILTER_DELTA)
-        {
-            //Filter.Channels=(Inp.fgetbits()>>11)+1;
-            Filter.Channels = (byte)((Inp.fgetbits() >> 11) + 1);
-            Inp.faddbits(5);
-        }
-
-        return true;
-    }
-
     //?
     //        void UnpWriteBuf()
     //        {
@@ -1162,5 +814,116 @@ internal partial class Unpack
         Header.TablePresent = (BlockFlags & 0x80) != 0;
         return true;
     }
+
+    //?
+    //        bool ReadTables(BitInput Inp, ref UnpackBlockHeader Header, ref UnpackBlockTables Tables)
+    //        {
+    //          if (!Header.TablePresent)
+    //            return true;
+    //
+    //          if (!Inp.ExternalBuffer && Inp.InAddr>ReadTop-25)
+    //            if (!UnpReadBuf())
+    //              return false;
+    //
+    //          byte BitLength[BC];
+    //          for (uint I=0;I<BC;I++)
+    //          {
+    //            uint Length=(byte)(Inp.fgetbits() >> 12);
+    //            Inp.faddbits(4);
+    //            if (Length==15)
+    //            {
+    //              uint ZeroCount=(byte)(Inp.fgetbits() >> 12);
+    //              Inp.faddbits(4);
+    //              if (ZeroCount==0)
+    //                BitLength[I]=15;
+    //              else
+    //              {
+    //                ZeroCount+=2;
+    //                while (ZeroCount-- > 0 && I<ASIZE(BitLength))
+    //                  BitLength[I++]=0;
+    //                I--;
+    //              }
+    //            }
+    //            else
+    //              BitLength[I]=Length;
+    //          }
+    //
+    //          MakeDecodeTables(BitLength,&Tables.BD,BC);
+    //
+    //          byte Table[HUFF_TABLE_SIZE];
+    //          const uint TableSize=HUFF_TABLE_SIZE;
+    //          for (uint I=0;I<TableSize;)
+    //          {
+    //            if (!Inp.ExternalBuffer && Inp.InAddr>ReadTop-5)
+    //              if (!UnpReadBuf())
+    //                return false;
+    //            uint Number=DecodeNumber(Inp,&Tables.BD);
+    //            if (Number<16)
+    //            {
+    //              Table[I]=Number;
+    //              I++;
+    //            }
+    //            else
+    //              if (Number<18)
+    //              {
+    //                uint N;
+    //                if (Number==16)
+    //                {
+    //                  N=(Inp.fgetbits() >> 13)+3;
+    //                  Inp.faddbits(3);
+    //                }
+    //                else
+    //                {
+    //                  N=(Inp.fgetbits() >> 9)+11;
+    //                  Inp.faddbits(7);
+    //                }
+    //                if (I==0)
+    //                {
+    //                  // We cannot have "repeat previous" code at the first position.
+    //                  // Multiple such codes would shift Inp position without changing I,
+    //                  // which can lead to reading beyond of Inp boundary in mutithreading
+    //                  // mode, where Inp.ExternalBuffer disables bounds check and we just
+    //                  // reserve a lot of buffer space to not need such check normally.
+    //                  return false;
+    //                }
+    //                else
+    //                  while (N-- > 0 && I<TableSize)
+    //                  {
+    //                    Table[I]=Table[I-1];
+    //                    I++;
+    //                  }
+    //              }
+    //              else
+    //              {
+    //                uint N;
+    //                if (Number==18)
+    //                {
+    //                  N=(Inp.fgetbits() >> 13)+3;
+    //                  Inp.faddbits(3);
+    //                }
+    //                else
+    //                {
+    //                  N=(Inp.fgetbits() >> 9)+11;
+    //                  Inp.faddbits(7);
+    //                }
+    //                while (N-- > 0 && I<TableSize)
+    //                  Table[I++]=0;
+    //              }
+    //          }
+    //          TablesRead5=true;
+    //          if (!Inp.ExternalBuffer && Inp.InAddr>ReadTop)
+    //            return false;
+    //          MakeDecodeTables(&Table[0],&Tables.LD,NC);
+    //          MakeDecodeTables(&Table[NC],&Tables.DD,DC);
+    //          MakeDecodeTables(&Table[NC+DC],&Tables.LDD,LDC);
+    //          MakeDecodeTables(&Table[NC+DC+LDC],&Tables.RD,RC);
+    //          return true;
+    //        }
+
+    //?
+    //        void InitFilters()
+    //        {
+    //          Filters.SoftReset();
+    //        }
 }
 #endif

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.cs

@@ -29,28 +29,9 @@ internal partial class Unpack : IRarUnpack
         // NOTE: caller has logic to check for -1 for error we throw instead.
         readStream.Read(buf, offset, count);
 
-    private async System.Threading.Tasks.Task<int> UnpIO_UnpReadAsync(
-        byte[] buf,
-        int offset,
-        int count,
-        System.Threading.CancellationToken cancellationToken = default
-    ) =>
-        // NOTE: caller has logic to check for -1 for error we throw instead.
-        await readStream.ReadAsync(buf, offset, count, cancellationToken).ConfigureAwait(false);
-
     private void UnpIO_UnpWrite(byte[] buf, size_t offset, uint count) =>
         writeStream.Write(buf, checked((int)offset), checked((int)count));
 
-    private async System.Threading.Tasks.Task UnpIO_UnpWriteAsync(
-        byte[] buf,
-        size_t offset,
-        uint count,
-        System.Threading.CancellationToken cancellationToken = default
-    ) =>
-        await writeStream
-            .WriteAsync(buf, checked((int)offset), checked((int)count), cancellationToken)
-            .ConfigureAwait(false);
-
     public void DoUnpack(FileHeader fileHeader, Stream readStream, Stream writeStream)
     {
         // as of 12/2017 .NET limits array indexing to using a signed integer
@@ -72,25 +53,6 @@ internal partial class Unpack : IRarUnpack
         DoUnpack();
     }
 
-    public async System.Threading.Tasks.Task DoUnpackAsync(
-        FileHeader fileHeader,
-        Stream readStream,
-        Stream writeStream,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        DestUnpSize = fileHeader.UncompressedSize;
-        this.fileHeader = fileHeader;
-        this.readStream = readStream;
-        this.writeStream = writeStream;
-        if (!fileHeader.IsStored)
-        {
-            Init(fileHeader.WindowSize, fileHeader.IsSolid);
-        }
-        Suspended = false;
-        await DoUnpackAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     public void DoUnpack()
     {
         if (fileHeader.IsStored)
@@ -103,27 +65,6 @@ internal partial class Unpack : IRarUnpack
         }
     }
 
-    public async System.Threading.Tasks.Task DoUnpackAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (fileHeader.IsStored)
-        {
-            await UnstoreFileAsync(cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            // TODO: When compression methods are converted to async, call them here
-            // For now, fall back to synchronous version
-            await DoUnpackAsync(
-                    fileHeader.CompressionAlgorithm,
-                    fileHeader.IsSolid,
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
-        }
-    }
-
     private void UnstoreFile()
     {
         Span<byte> b = stackalloc byte[(int)Math.Min(0x10000, DestUnpSize)];
@@ -139,25 +80,6 @@ internal partial class Unpack : IRarUnpack
         } while (!Suspended);
     }
 
-    private async System.Threading.Tasks.Task UnstoreFileAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var buffer = new byte[(int)Math.Min(0x10000, DestUnpSize)];
-        do
-        {
-            var n = await readStream
-                .ReadAsync(buffer, 0, buffer.Length, cancellationToken)
-                .ConfigureAwait(false);
-            if (n == 0)
-            {
-                break;
-            }
-            await writeStream.WriteAsync(buffer, 0, n, cancellationToken).ConfigureAwait(false);
-            DestUnpSize -= n;
-        } while (!Suspended);
-    }
-
     public bool Suspended { get; set; }
 
     public long DestSize => DestUnpSize;

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack15_cpp.cs

@@ -200,102 +200,6 @@ internal partial class Unpack
         UnpWriteBuf20();
     }
 
-    private async System.Threading.Tasks.Task Unpack15Async(
-        bool Solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        UnpInitData(Solid);
-        UnpInitData15(Solid);
-        await UnpReadBufAsync(cancellationToken).ConfigureAwait(false);
-        if (!Solid)
-        {
-            InitHuff();
-            UnpPtr = 0;
-        }
-        else
-        {
-            UnpPtr = WrPtr;
-        }
-
-        --DestUnpSize;
-        if (DestUnpSize >= 0)
-        {
-            GetFlagsBuf();
-            FlagsCnt = 8;
-        }
-
-        while (DestUnpSize >= 0)
-        {
-            UnpPtr &= MaxWinMask;
-
-            if (
-                Inp.InAddr > ReadTop - 30
-                && !await UnpReadBufAsync(cancellationToken).ConfigureAwait(false)
-            )
-            {
-                break;
-            }
-
-            if (((WrPtr - UnpPtr) & MaxWinMask) < 270 && WrPtr != UnpPtr)
-            {
-                await UnpWriteBuf20Async(cancellationToken).ConfigureAwait(false);
-            }
-
-            if (StMode != 0)
-            {
-                HuffDecode();
-                continue;
-            }
-
-            if (--FlagsCnt < 0)
-            {
-                GetFlagsBuf();
-                FlagsCnt = 7;
-            }
-
-            if ((FlagBuf & 0x80) != 0)
-            {
-                FlagBuf <<= 1;
-                if (Nlzb > Nhfb)
-                {
-                    LongLZ();
-                }
-                else
-                {
-                    HuffDecode();
-                }
-            }
-            else
-            {
-                FlagBuf <<= 1;
-                if (--FlagsCnt < 0)
-                {
-                    GetFlagsBuf();
-                    FlagsCnt = 7;
-                }
-                if ((FlagBuf & 0x80) != 0)
-                {
-                    FlagBuf <<= 1;
-                    if (Nlzb > Nhfb)
-                    {
-                        HuffDecode();
-                    }
-                    else
-                    {
-                        LongLZ();
-                    }
-                }
-                else
-                {
-                    FlagBuf <<= 1;
-                    ShortLZ();
-                }
-            }
-        }
-        await UnpWriteBuf20Async(cancellationToken).ConfigureAwait(false);
-    }
-
     //#define GetShortLen1(pos) ((pos)==1 ? Buf60+3:ShortLen1[pos])
     private uint GetShortLen1(uint pos) => ((pos) == 1 ? (uint)(Buf60 + 3) : ShortLen1[pos]);
 

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack20_cpp.cs

@@ -349,170 +349,6 @@ internal partial class Unpack
         UnpWriteBuf20();
     }
 
-    private async System.Threading.Tasks.Task Unpack20Async(
-        bool Solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        uint Bits;
-
-        if (Suspended)
-        {
-            UnpPtr = WrPtr;
-        }
-        else
-        {
-            UnpInitData(Solid);
-            if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return;
-            }
-
-            if (
-                (!Solid || !TablesRead2)
-                && !await ReadTables20Async(cancellationToken).ConfigureAwait(false)
-            )
-            {
-                return;
-            }
-
-            --DestUnpSize;
-        }
-
-        while (DestUnpSize >= 0)
-        {
-            UnpPtr &= MaxWinMask;
-
-            if (Inp.InAddr > ReadTop - 30)
-            {
-                if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-                {
-                    break;
-                }
-            }
-
-            if (((WrPtr - UnpPtr) & MaxWinMask) < 270 && WrPtr != UnpPtr)
-            {
-                await UnpWriteBuf20Async(cancellationToken).ConfigureAwait(false);
-                if (Suspended)
-                {
-                    return;
-                }
-            }
-            if (UnpAudioBlock)
-            {
-                var AudioNumber = DecodeNumber(Inp, MD[UnpCurChannel]);
-
-                if (AudioNumber == 256)
-                {
-                    if (!await ReadTables20Async(cancellationToken).ConfigureAwait(false))
-                    {
-                        break;
-                    }
-
-                    continue;
-                }
-                Window[UnpPtr++] = DecodeAudio((int)AudioNumber);
-                if (++UnpCurChannel == UnpChannels)
-                {
-                    UnpCurChannel = 0;
-                }
-
-                --DestUnpSize;
-                continue;
-            }
-
-            var Number = DecodeNumber(Inp, BlockTables.LD);
-            if (Number < 256)
-            {
-                Window[UnpPtr++] = (byte)Number;
-                --DestUnpSize;
-                continue;
-            }
-            if (Number > 269)
-            {
-                var Length = (uint)(LDecode[Number -= 270] + 3);
-                if ((Bits = LBits[Number]) > 0)
-                {
-                    Length += Inp.getbits() >> (int)(16 - Bits);
-                    Inp.addbits(Bits);
-                }
-
-                var DistNumber = DecodeNumber(Inp, BlockTables.DD);
-                var Distance = DDecode[DistNumber] + 1;
-                if ((Bits = DBits[DistNumber]) > 0)
-                {
-                    Distance += Inp.getbits() >> (int)(16 - Bits);
-                    Inp.addbits(Bits);
-                }
-
-                if (Distance >= 0x2000)
-                {
-                    Length++;
-                    if (Distance >= 0x40000L)
-                    {
-                        Length++;
-                    }
-                }
-
-                CopyString20(Length, Distance);
-                continue;
-            }
-            if (Number == 269)
-            {
-                if (!await ReadTables20Async(cancellationToken).ConfigureAwait(false))
-                {
-                    break;
-                }
-
-                continue;
-            }
-            if (Number == 256)
-            {
-                CopyString20(LastLength, LastDist);
-                continue;
-            }
-            if (Number < 261)
-            {
-                var Distance = OldDist[(OldDistPtr - (Number - 256)) & 3];
-                var LengthNumber = DecodeNumber(Inp, BlockTables.RD);
-                var Length = (uint)(LDecode[LengthNumber] + 2);
-                if ((Bits = LBits[LengthNumber]) > 0)
-                {
-                    Length += Inp.getbits() >> (int)(16 - Bits);
-                    Inp.addbits(Bits);
-                }
-                if (Distance >= 0x101)
-                {
-                    Length++;
-                    if (Distance >= 0x2000)
-                    {
-                        Length++;
-                        if (Distance >= 0x40000)
-                        {
-                            Length++;
-                        }
-                    }
-                }
-                CopyString20(Length, Distance);
-                continue;
-            }
-            if (Number < 270)
-            {
-                var Distance = (uint)(SDDecode[Number -= 261] + 1);
-                if ((Bits = SDBits[Number]) > 0)
-                {
-                    Distance += Inp.getbits() >> (int)(16 - Bits);
-                    Inp.addbits(Bits);
-                }
-                CopyString20(2, Distance);
-                continue;
-            }
-        }
-        ReadLastTables();
-        await UnpWriteBuf20Async(cancellationToken).ConfigureAwait(false);
-    }
-
     private void UnpWriteBuf20()
     {
         if (UnpPtr != WrPtr)
@@ -534,36 +370,6 @@ internal partial class Unpack
         WrPtr = UnpPtr;
     }
 
-    private async System.Threading.Tasks.Task UnpWriteBuf20Async(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (UnpPtr != WrPtr)
-        {
-            UnpSomeRead = true;
-        }
-
-        if (UnpPtr < WrPtr)
-        {
-            await UnpIO_UnpWriteAsync(
-                    Window,
-                    WrPtr,
-                    (uint)(-(int)WrPtr & MaxWinMask),
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
-            await UnpIO_UnpWriteAsync(Window, 0, UnpPtr, cancellationToken).ConfigureAwait(false);
-            UnpAllBuf = true;
-        }
-        else
-        {
-            await UnpIO_UnpWriteAsync(Window, WrPtr, UnpPtr - WrPtr, cancellationToken)
-                .ConfigureAwait(false);
-        }
-
-        WrPtr = UnpPtr;
-    }
-
     private bool ReadTables20()
     {
         Span<byte> BitLength = stackalloc byte[checked((int)BC20)];
@@ -684,130 +490,6 @@ internal partial class Unpack
         return true;
     }
 
-    private async System.Threading.Tasks.Task<bool> ReadTables20Async(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        byte[] BitLength = new byte[checked((int)BC20)];
-        byte[] Table = new byte[checked((int)MC20 * 4)];
-        if (Inp.InAddr > ReadTop - 25)
-        {
-            if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return false;
-            }
-        }
-
-        var BitField = Inp.getbits();
-        UnpAudioBlock = (BitField & 0x8000) != 0;
-
-        if ((BitField & 0x4000) != 0)
-        {
-            Array.Clear(UnpOldTable20, 0, UnpOldTable20.Length);
-        }
-
-        Inp.addbits(2);
-
-        uint TableSize;
-        if (UnpAudioBlock)
-        {
-            UnpChannels = ((BitField >> 12) & 3) + 1;
-            if (UnpCurChannel >= UnpChannels)
-            {
-                UnpCurChannel = 0;
-            }
-
-            Inp.addbits(2);
-            TableSize = MC20 * UnpChannels;
-        }
-        else
-        {
-            TableSize = NC20 + DC20 + RC20;
-        }
-
-        for (int I = 0; I < checked((int)BC20); I++)
-        {
-            BitLength[I] = (byte)(Inp.getbits() >> 12);
-            Inp.addbits(4);
-        }
-        MakeDecodeTables(BitLength, 0, BlockTables.BD, BC20);
-        for (int I = 0; I < checked((int)TableSize); )
-        {
-            if (Inp.InAddr > ReadTop - 5)
-            {
-                if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-                {
-                    return false;
-                }
-            }
-
-            var Number = DecodeNumber(Inp, BlockTables.BD);
-            if (Number < 16)
-            {
-                Table[I] = (byte)((Number + UnpOldTable20[I]) & 0xF);
-                I++;
-            }
-            else if (Number < 18)
-            {
-                uint N;
-                if (Number == 16)
-                {
-                    N = (Inp.getbits() >> 14) + 3;
-                    Inp.addbits(2);
-                }
-                else
-                {
-                    N = (Inp.getbits() >> 13) + 11;
-                    Inp.addbits(3);
-                }
-                if (I == 0)
-                {
-                    return false;
-                }
-
-                while (N-- > 0 && I < checked((int)TableSize))
-                {
-                    Table[I] = Table[I - 1];
-                    I++;
-                }
-            }
-            else
-            {
-                uint N;
-                if (Number == 18)
-                {
-                    N = (Inp.getbits() >> 13) + 3;
-                    Inp.addbits(3);
-                }
-                else
-                {
-                    N = (Inp.getbits() >> 9) + 11;
-                    Inp.addbits(7);
-                }
-
-                while (N-- > 0 && I < checked((int)TableSize))
-                {
-                    Table[I++] = 0;
-                }
-            }
-        }
-        if (UnpAudioBlock)
-        {
-            for (int I = 0; I < UnpChannels; I++)
-            {
-                MakeDecodeTables(Table, (int)(I * MC20), MD[I], MC20);
-            }
-        }
-        else
-        {
-            MakeDecodeTables(Table, 0, BlockTables.LD, NC20);
-            MakeDecodeTables(Table, (int)NC20, BlockTables.DD, DC20);
-            MakeDecodeTables(Table, (int)(NC20 + DC20), BlockTables.RD, RC20);
-        }
-        Array.Copy(Table, 0, this.UnpOldTable20, 0, UnpOldTable20.Length);
-        return true;
-    }
-
     private void ReadLastTables()
     {
         if (ReadTop >= Inp.InAddr + 5)

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack30_cpp.cs

@@ -0,0 +1,793 @@
+#if !Rar2017_64bit
+#else
+using nint = System.Int64;
+using nuint = System.UInt64;
+using size_t = System.UInt64;
+#endif
+
+//using static SharpCompress.Compressors.Rar.UnpackV2017.Unpack.Unpack30Local;
+/*
+namespace SharpCompress.Compressors.Rar.UnpackV2017
+{
+    internal partial class Unpack
+    {
+
+#if !RarV2017_RAR5ONLY
+// We use it instead of direct PPM.DecodeChar call to be sure that
+// we reset PPM structures in case of corrupt data. It is important,
+// because these structures can be invalid after PPM.DecodeChar returned -1.
+int SafePPMDecodeChar()
+{
+  int Ch=PPM.DecodeChar();
+  if (Ch==-1)              // Corrupt PPM data found.
+  {
+    PPM.CleanUp();         // Reset possibly corrupt PPM data structures.
+    UnpBlockType=BLOCK_LZ; // Set faster and more fail proof LZ mode.
+  }
+  return(Ch);
+}
+
+internal static class Unpack30Local {
+  public static readonly byte[] LDecode={0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,32,40,48,56,64,80,96,112,128,160,192,224};
+  public static readonly byte[] LBits=  {0,0,0,0,0,0,0,0,1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4,  4,  5,  5,  5,  5};
+  public static readonly int[] DDecode = new int[DC];
+  public static readonly byte[] DBits = new byte[DC];
+  public static readonly int[] DBitLengthCounts= {4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,14,0,12};
+  public static readonly byte[] SDDecode={0,4,8,16,32,64,128,192};
+  public static readonly byte[] SDBits=  {2,2,3, 4, 5, 6,  6,  6};
+}
+void Unpack29(bool Solid)
+{
+  uint Bits;
+
+  if (DDecode[1]==0)
+  {
+    int Dist=0,BitLength=0,Slot=0;
+    for (int I=0;I<DBitLengthCounts.Length;I++,BitLength++)
+      for (int J=0;J<DBitLengthCounts[I];J++,Slot++,Dist+=(1<<BitLength))
+      {
+        DDecode[Slot]=Dist;
+        DBits[Slot]=(byte)BitLength;
+      }
+  }
+
+  FileExtracted=true;
+
+  if (!Suspended)
+  {
+    UnpInitData(Solid);
+    if (!UnpReadBuf30())
+      return;
+    if ((!Solid || !TablesRead3) && !ReadTables30())
+      return;
+  }
+
+  while (true)
+  {
+    UnpPtr&=MaxWinMask;
+
+    if (Inp.InAddr>ReadBorder)
+    {
+      if (!UnpReadBuf30())
+        break;
+    }
+    if (((WrPtr-UnpPtr) & MaxWinMask)<260 && WrPtr!=UnpPtr)
+    {
+      UnpWriteBuf30();
+      if (WrittenFileSize>DestUnpSize)
+        return;
+      if (Suspended)
+      {
+        FileExtracted=false;
+        return;
+      }
+    }
+    if (UnpBlockType==BLOCK_PPM)
+    {
+      // Here speed is critical, so we do not use SafePPMDecodeChar,
+      // because sometimes even the inline function can introduce
+      // some additional penalty.
+      int Ch=PPM.DecodeChar();
+      if (Ch==-1)              // Corrupt PPM data found.
+      {
+        PPM.CleanUp();         // Reset possibly corrupt PPM data structures.
+        UnpBlockType=BLOCK_LZ; // Set faster and more fail proof LZ mode.
+        break;
+      }
+      if (Ch==PPMEscChar)
+      {
+        int NextCh=SafePPMDecodeChar();
+        if (NextCh==0)  // End of PPM encoding.
+        {
+          if (!ReadTables30())
+            break;
+          continue;
+        }
+        if (NextCh==-1) // Corrupt PPM data found.
+          break;
+        if (NextCh==2)  // End of file in PPM mode.
+          break;
+        if (NextCh==3)  // Read VM code.
+        {
+          if (!ReadVMCodePPM())
+            break;
+          continue;
+        }
+        if (NextCh==4) // LZ inside of PPM.
+        {
+          uint Distance=0,Length;
+          bool Failed=false;
+          for (int I=0;I<4 && !Failed;I++)
+          {
+            int _Ch=SafePPMDecodeChar();
+            if (_Ch==-1)
+              Failed=true;
+            else
+              if (I==3)
+                Length=(byte)_Ch;
+              else
+                Distance=(Distance<<8)+(byte)_Ch;
+          }
+          if (Failed)
+            break;
+
+          CopyString(Length+32,Distance+2);
+          continue;
+        }
+        if (NextCh==5) // One byte distance match (RLE) inside of PPM.
+        {
+          int Length=SafePPMDecodeChar();
+          if (Length==-1)
+            break;
+          CopyString((uint)(Length+4),1);
+          continue;
+        }
+        // If we are here, NextCh must be 1, what means that current byte
+        // is equal to our 'escape' byte, so we just store it to Window.
+      }
+      Window[UnpPtr++]=(byte)Ch;
+      continue;
+    }
+
+    uint Number=DecodeNumber(Inp,BlockTables.LD);
+    if (Number<256)
+    {
+      Window[UnpPtr++]=(byte)Number;
+      continue;
+    }
+    if (Number>=271)
+    {
+      uint Length=(uint)(LDecode[Number-=271]+3);
+      if ((Bits=LBits[Number])>0)
+      {
+        Length+=Inp.getbits()>>(int)(16-Bits);
+        Inp.addbits(Bits);
+      }
+
+      uint DistNumber=DecodeNumber(Inp,BlockTables.DD);
+      uint Distance=(uint)(DDecode[DistNumber]+1);
+      if ((Bits=DBits[DistNumber])>0)
+      {
+        if (DistNumber>9)
+        {
+          if (Bits>4)
+          {
+            Distance+=((Inp.getbits()>>(int)(20-Bits))<<4);
+            Inp.addbits(Bits-4);
+          }
+          if (LowDistRepCount>0)
+          {
+            LowDistRepCount--;
+            Distance+=(uint)PrevLowDist;
+          }
+          else
+          {
+            uint LowDist=DecodeNumber(Inp,BlockTables.LDD);
+            if (LowDist==16)
+            {
+              LowDistRepCount=(int)(LOW_DIST_REP_COUNT-1);
+              Distance+=(uint)PrevLowDist;
+            }
+            else
+            {
+              Distance+=LowDist;
+              PrevLowDist=(int)LowDist;
+            }
+          }
+        }
+        else
+        {
+          Distance+=Inp.getbits()>>(int)(16-Bits);
+          Inp.addbits(Bits);
+        }
+      }
+
+      if (Distance>=0x2000)
+      {
+        Length++;
+        if (Distance>=0x40000)
+          Length++;
+      }
+
+      InsertOldDist(Distance);
+      LastLength=Length;
+      CopyString(Length,Distance);
+      continue;
+    }
+    if (Number==256)
+    {
+      if (!ReadEndOfBlock())
+        break;
+      continue;
+    }
+    if (Number==257)
+    {
+      if (!ReadVMCode())
+        break;
+      continue;
+    }
+    if (Number==258)
+    {
+      if (LastLength!=0)
+        CopyString(LastLength,OldDist[0]);
+      continue;
+    }
+    if (Number<263)
+    {
+      uint DistNum=Number-259;
+      uint Distance=OldDist[DistNum];
+      for (uint I=DistNum;I>0;I--)
+        OldDist[I]=OldDist[I-1];
+      OldDist[0]=Distance;
+
+      uint LengthNumber=DecodeNumber(Inp,BlockTables.RD);
+      int Length=LDecode[LengthNumber]+2;
+      if ((Bits=LBits[LengthNumber])>0)
+      {
+        Length+=(int)(Inp.getbits()>>(int)(16-Bits));
+        Inp.addbits(Bits);
+      }
+      LastLength=(uint)Length;
+      CopyString((uint)Length,Distance);
+      continue;
+    }
+    if (Number<272)
+    {
+      uint Distance=(uint)(SDDecode[Number-=263]+1);
+      if ((Bits=SDBits[Number])>0)
+      {
+        Distance+=Inp.getbits()>>(int)(16-Bits);
+        Inp.addbits(Bits);
+      }
+      InsertOldDist(Distance);
+      LastLength=2;
+      CopyString(2,Distance);
+      continue;
+    }
+  }
+  UnpWriteBuf30();
+}
+
+
+// Return 'false' to quit unpacking the current file or 'true' to continue.
+bool ReadEndOfBlock()
+{
+  uint BitField=Inp.getbits();
+  bool NewTable,NewFile=false;
+
+  // "1"  - no new file, new table just here.
+  // "00" - new file,    no new table.
+  // "01" - new file,    new table (in beginning of next file).
+  
+  if ((BitField & 0x8000)!=0)
+  {
+    NewTable=true;
+    Inp.addbits(1);
+  }
+  else
+  {
+    NewFile=true;
+    NewTable=(BitField & 0x4000)!=0;
+    Inp.addbits(2);
+  }
+  TablesRead3=!NewTable;
+
+  // Quit immediately if "new file" flag is set. If "new table" flag
+  // is present, we'll read the table in beginning of next file
+  // based on 'TablesRead3' 'false' value.
+  if (NewFile)
+    return false;
+  return ReadTables30(); // Quit only if we failed to read tables.
+}
+
+
+bool ReadVMCode()
+{
+  // Entire VM code is guaranteed to fully present in block defined
+  // by current Huffman table. Compressor checks that VM code does not cross
+  // Huffman block boundaries.
+  uint FirstByte=Inp.getbits()>>8;
+  Inp.addbits(8);
+  uint Length=(FirstByte & 7)+1;
+  if (Length==7)
+  {
+    Length=(Inp.getbits()>>8)+7;
+    Inp.addbits(8);
+  }
+  else
+    if (Length==8)
+    {
+      Length=Inp.getbits();
+      Inp.addbits(16);
+    }
+  if (Length==0)
+    return false;
+  Array<byte> VMCode(Length);
+  for (uint I=0;I<Length;I++)
+  {
+    // Try to read the new buffer if only one byte is left.
+    // But if we read all bytes except the last, one byte is enough.
+    if (Inp.InAddr>=ReadTop-1 && !UnpReadBuf30() && I<Length-1)
+      return false;
+    VMCode[I]=Inp.getbits()>>8;
+    Inp.addbits(8);
+  }
+  return AddVMCode(FirstByte,&VMCode[0],Length);
+}
+
+
+bool ReadVMCodePPM()
+{
+  uint FirstByte=(uint)SafePPMDecodeChar();
+  if ((int)FirstByte==-1)
+    return false;
+  uint Length=(FirstByte & 7)+1;
+  if (Length==7)
+  {
+    int B1=SafePPMDecodeChar();
+    if (B1==-1)
+      return false;
+    Length=B1+7;
+  }
+  else
+    if (Length==8)
+    {
+      int B1=SafePPMDecodeChar();
+      if (B1==-1)
+        return false;
+      int B2=SafePPMDecodeChar();
+      if (B2==-1)
+        return false;
+      Length=B1*256+B2;
+    }
+  if (Length==0)
+    return false;
+  Array<byte> VMCode(Length);
+  for (uint I=0;I<Length;I++)
+  {
+    int Ch=SafePPMDecodeChar();
+    if (Ch==-1)
+      return false;
+    VMCode[I]=Ch;
+  }
+  return AddVMCode(FirstByte,&VMCode[0],Length);
+}
+
+
+bool AddVMCode(uint FirstByte,byte[] Code,int CodeSize)
+{
+  VMCodeInp.InitBitInput();
+  //x memcpy(VMCodeInp.InBuf,Code,Min(BitInput.MAX_SIZE,CodeSize));
+  Array.Copy(Code, 0, VMCodeInp.InBuf, 0, Math.Min(BitInput.MAX_SIZE,CodeSize));
+  VM.Init();
+
+  uint FiltPos;
+  if ((FirstByte & 0x80)!=0)
+  {
+    FiltPos=RarVM.ReadData(VMCodeInp);
+    if (FiltPos==0)
+      InitFilters30(false);
+    else
+      FiltPos--;
+  }
+  else
+    FiltPos=(uint)this.LastFilter; // Use the same filter as last time.
+
+  if (FiltPos>Filters30.Count || FiltPos>OldFilterLengths.Count)
+    return false;
+  LastFilter=(int)FiltPos;
+  bool NewFilter=(FiltPos==Filters30.Count);
+
+  UnpackFilter30 StackFilter=new UnpackFilter30(); // New filter for PrgStack.
+
+  UnpackFilter30 Filter;
+  if (NewFilter) // New filter code, never used before since VM reset.
+  {
+    if (FiltPos>MAX3_UNPACK_FILTERS)
+    {
+      // Too many different filters, corrupt archive.
+      //delete StackFilter;
+      return false;
+    }
+
+    Filters30.Add(1);
+    Filters30[Filters30.Count-1]=Filter=new UnpackFilter30();
+    StackFilter.ParentFilter=(uint)(Filters30.Count-1);
+
+    // Reserve one item to store the data block length of our new filter
+    // entry. We'll set it to real block length below, after reading it.
+    // But we need to initialize it now, because when processing corrupt
+    // data, we can access this item even before we set it to real value.
+    OldFilterLengths.Add(0);
+  }
+  else  // Filter was used in the past.
+  {
+    Filter=Filters30[(int)FiltPos];
+    StackFilter.ParentFilter=FiltPos;
+  }
+
+  int EmptyCount=0;
+  for (int I=0;I<PrgStack.Count;I++)
+  {
+    PrgStack[I-EmptyCount]=PrgStack[I];
+    if (PrgStack[I]==null)
+      EmptyCount++;
+    if (EmptyCount>0)
+      PrgStack[I]=null;
+  }
+  if (EmptyCount==0)
+  {
+    if (PrgStack.Count>MAX3_UNPACK_FILTERS)
+    {
+      //delete StackFilter;
+      return false;
+    }
+    PrgStack.Add(1);
+    EmptyCount=1;
+  }
+  size_t StackPos=(uint)(this.PrgStack.Count-EmptyCount);
+  PrgStack[(int)StackPos]=StackFilter;
+ 
+  uint BlockStart=RarVM.ReadData(VMCodeInp);
+  if ((FirstByte & 0x40)!=0)
+    BlockStart+=258;
+  StackFilter.BlockStart=(uint)((BlockStart+UnpPtr)&MaxWinMask);
+  if ((FirstByte & 0x20)!=0)
+  {
+    StackFilter.BlockLength=RarVM.ReadData(VMCodeInp);
+
+    // Store the last data block length for current filter.
+    OldFilterLengths[(int)FiltPos]=(int)StackFilter.BlockLength;
+  }
+  else
+  {
+    // Set the data block size to same value as the previous block size
+    // for same filter. It is possible for corrupt data to access a new
+    // and not filled yet item of OldFilterLengths array here. This is why
+    // we set new OldFilterLengths items to zero above.
+    StackFilter.BlockLength=FiltPos<OldFilterLengths.Count ? OldFilterLengths[(int)FiltPos]:0;
+  }
+
+  StackFilter.NextWindow=WrPtr!=UnpPtr && ((WrPtr-UnpPtr)&MaxWinMask)<=BlockStart;
+
+//  DebugLog("\nNextWindow: UnpPtr=%08x WrPtr=%08x BlockStart=%08x",UnpPtr,WrPtr,BlockStart);
+
+  memset(StackFilter.Prg.InitR,0,sizeof(StackFilter.Prg.InitR));
+  StackFilter.Prg.InitR[4]=StackFilter.BlockLength;
+
+  if ((FirstByte & 0x10)!=0) // Set registers to optional parameters if any.
+  {
+    uint InitMask=VMCodeInp.fgetbits()>>9;
+    VMCodeInp.faddbits(7);
+    for (int I=0;I<7;I++)
+      if ((InitMask & (1<<I)) != 0)
+        StackFilter.Prg.InitR[I]=RarVM.ReadData(VMCodeInp);
+  }
+
+  if (NewFilter)
+  {
+    uint VMCodeSize=RarVM.ReadData(VMCodeInp);
+    if (VMCodeSize>=0x10000 || VMCodeSize==0)
+      return false;
+    Array<byte> VMCode(VMCodeSize);
+    for (uint I=0;I<VMCodeSize;I++)
+    {
+      if (VMCodeInp.Overflow(3))
+        return false;
+      VMCode[I]=VMCodeInp.fgetbits()>>8;
+      VMCodeInp.faddbits(8);
+    }
+    VM.Prepare(&VMCode[0],VMCodeSize,&Filter->Prg);
+  }
+  StackFilter.Prg.Type=Filter.Prg.Type;
+
+  return true;
+}
+
+
+bool UnpReadBuf30()
+{
+  int DataSize=ReadTop-Inp.InAddr; // Data left to process.
+  if (DataSize<0)
+    return false;
+  if (Inp.InAddr>BitInput.MAX_SIZE/2)
+  {
+    // If we already processed more than half of buffer, let's move
+    // remaining data into beginning to free more space for new data
+    // and ensure that calling function does not cross the buffer border
+    // even if we did not read anything here. Also it ensures that read size
+    // is not less than CRYPT_BLOCK_SIZE, so we can align it without risk
+    // to make it zero.
+    if (DataSize>0)
+      //x memmove(Inp.InBuf,Inp.InBuf+Inp.InAddr,DataSize);
+      Array.Copy(Inp.InBuf,Inp.InAddr,Inp.InBuf,0,DataSize);
+    Inp.InAddr=0;
+    ReadTop=DataSize;
+  }
+  else
+    DataSize=ReadTop;
+  int ReadCode=UnpIO_UnpRead(Inp.InBuf,DataSize,BitInput.MAX_SIZE-DataSize);
+  if (ReadCode>0)
+    ReadTop+=ReadCode;
+  ReadBorder=ReadTop-30;
+  return ReadCode!=-1;
+}
+
+
+void UnpWriteBuf30()
+{
+  uint WrittenBorder=(uint)WrPtr;
+  uint WriteSize=(uint)((UnpPtr-WrittenBorder)&MaxWinMask);
+  for (int I=0;I<PrgStack.Count;I++)
+  {
+    // Here we apply filters to data which we need to write.
+    // We always copy data to virtual machine memory before processing.
+    // We cannot process them just in place in Window buffer, because
+    // these data can be used for future string matches, so we must
+    // preserve them in original form.
+
+    UnpackFilter30 flt=PrgStack[I];
+    if (flt==null)
+      continue;
+    if (flt.NextWindow)
+    {
+      flt.NextWindow=false;
+      continue;
+    }
+    uint BlockStart=flt.BlockStart;
+    uint BlockLength=flt.BlockLength;
+    if (((BlockStart-WrittenBorder)&MaxWinMask)<WriteSize)
+    {
+      if (WrittenBorder!=BlockStart)
+      {
+        UnpWriteArea(WrittenBorder,BlockStart);
+        WrittenBorder=BlockStart;
+        WriteSize=(uint)((UnpPtr-WrittenBorder)&MaxWinMask);
+      }
+      if (BlockLength<=WriteSize)
+      {
+        uint BlockEnd=(BlockStart+BlockLength)&MaxWinMask;
+        if (BlockStart<BlockEnd || BlockEnd==0)
+          VM.SetMemory(0,Window+BlockStart,BlockLength);
+        else
+        {
+          uint FirstPartLength=uint(MaxWinSize-BlockStart);
+          VM.SetMemory(0,Window+BlockStart,FirstPartLength);
+          VM.SetMemory(FirstPartLength,Window,BlockEnd);
+        }
+
+        VM_PreparedProgram *ParentPrg=&Filters30[flt->ParentFilter]->Prg;
+        VM_PreparedProgram *Prg=&flt->Prg;
+
+        ExecuteCode(Prg);
+
+        byte[] FilteredData=Prg.FilteredData;
+        uint FilteredDataSize=Prg.FilteredDataSize;
+
+        delete PrgStack[I];
+        PrgStack[I]=null;
+        while (I+1<PrgStack.Count)
+        {
+          UnpackFilter30 NextFilter=PrgStack[I+1];
+          // It is required to check NextWindow here.
+          if (NextFilter==null || NextFilter.BlockStart!=BlockStart ||
+              NextFilter.BlockLength!=FilteredDataSize || NextFilter.NextWindow)
+            break;
+
+          // Apply several filters to same data block.
+
+          VM.SetMemory(0,FilteredData,FilteredDataSize);
+
+          VM_PreparedProgram *ParentPrg=&Filters30[NextFilter.ParentFilter]->Prg;
+          VM_PreparedProgram *NextPrg=&NextFilter->Prg;
+
+          ExecuteCode(NextPrg);
+
+          FilteredData=NextPrg.FilteredData;
+          FilteredDataSize=NextPrg.FilteredDataSize;
+          I++;
+          delete PrgStack[I];
+          PrgStack[I]=null;
+        }
+        UnpIO_UnpWrite(FilteredData,0,FilteredDataSize);
+        UnpSomeRead=true;
+        WrittenFileSize+=FilteredDataSize;
+        WrittenBorder=BlockEnd;
+        WriteSize=(uint)((UnpPtr-WrittenBorder)&MaxWinMask);
+      }
+      else
+      {
+        // Current filter intersects the window write border, so we adjust
+        // the window border to process this filter next time, not now.
+        for (size_t J=I;J<PrgStack.Count;J++)
+        {
+          UnpackFilter30 flt=PrgStack[J];
+          if (flt!=null && flt.NextWindow)
+            flt.NextWindow=false;
+        }
+        WrPtr=WrittenBorder;
+        return;
+      }
+    }
+  }
+      
+  UnpWriteArea(WrittenBorder,UnpPtr);
+  WrPtr=UnpPtr;
+}
+
+
+void ExecuteCode(VM_PreparedProgram *Prg)
+{
+  Prg->InitR[6]=(uint)WrittenFileSize;
+  VM.Execute(Prg);
+}
+
+
+bool ReadTables30()
+{
+  byte[] BitLength = new byte[BC];
+  byte[] Table = new byte[HUFF_TABLE_SIZE30];
+  if (Inp.InAddr>ReadTop-25)
+    if (!UnpReadBuf30())
+      return(false);
+  Inp.faddbits((uint)((8-Inp.InBit)&7));
+  uint BitField=Inp.fgetbits();
+  if ((BitField & 0x8000) != 0)
+  {
+    UnpBlockType=BLOCK_PPM;
+    return(PPM.DecodeInit(this,PPMEscChar));
+  }
+  UnpBlockType=BLOCK_LZ;
+  
+  PrevLowDist=0;
+  LowDistRepCount=0;
+
+  if ((BitField & 0x4000) == 0)
+    Utility.Memset(UnpOldTable,0,UnpOldTable.Length);
+  Inp.faddbits(2);
+
+  for (uint I=0;I<BC;I++)
+  {
+    uint Length=(byte)(Inp.fgetbits() >> 12);
+    Inp.faddbits(4);
+    if (Length==15)
+    {
+      uint ZeroCount=(byte)(Inp.fgetbits() >> 12);
+      Inp.faddbits(4);
+      if (ZeroCount==0)
+        BitLength[I]=15;
+      else
+      {
+        ZeroCount+=2;
+        while (ZeroCount-- > 0 && I<BitLength.Length)
+          BitLength[I++]=0;
+        I--;
+      }
+    }
+    else
+      BitLength[I]=(byte)Length;
+  }
+  MakeDecodeTables(BitLength,0,BlockTables.BD,BC30);
+
+  const uint TableSize=HUFF_TABLE_SIZE30;
+  for (uint I=0;I<TableSize;)
+  {
+    if (Inp.InAddr>ReadTop-5)
+      if (!UnpReadBuf30())
+        return(false);
+    uint Number=DecodeNumber(Inp,BlockTables.BD);
+    if (Number<16)
+    {
+      Table[I]=(byte)((Number+this.UnpOldTable[I]) & 0xf);
+      I++;
+    }
+    else
+      if (Number<18)
+      {
+        uint N;
+        if (Number==16)
+        {
+          N=(Inp.fgetbits() >> 13)+3;
+          Inp.faddbits(3);
+        }
+        else
+        {
+          N=(Inp.fgetbits() >> 9)+11;
+          Inp.faddbits(7);
+        }
+        if (I==0)
+          return false; // We cannot have "repeat previous" code at the first position.
+        else
+          while (N-- > 0 && I<TableSize)
+          {
+            Table[I]=Table[I-1];
+            I++;
+          }
+      }
+      else
+      {
+        uint N;
+        if (Number==18)
+        {
+          N=(Inp.fgetbits() >> 13)+3;
+          Inp.faddbits(3);
+        }
+        else
+        {
+          N=(Inp.fgetbits() >> 9)+11;
+          Inp.faddbits(7);
+        }
+        while (N-- > 0 && I<TableSize)
+          Table[I++]=0;
+      }
+  }
+  TablesRead3=true;
+  if (Inp.InAddr>ReadTop)
+    return false;
+  MakeDecodeTables(Table,0,BlockTables.LD,NC30);
+  MakeDecodeTables(Table,(int)NC30,BlockTables.DD,DC30);
+  MakeDecodeTables(Table,(int)(NC30+DC30),BlockTables.LDD,LDC30);
+  MakeDecodeTables(Table,(int)(NC30+DC30+LDC30),BlockTables.RD,RC30);
+  //x memcpy(UnpOldTable,Table,sizeof(UnpOldTable));
+  Array.Copy(Table,0,UnpOldTable,0,UnpOldTable.Length);
+  return true;
+}
+
+#endif
+
+void UnpInitData30(bool Solid)
+{
+  if (!Solid)
+  {
+    TablesRead3=false;
+    Utility.Memset(UnpOldTable, 0, UnpOldTable.Length);
+    PPMEscChar=2;
+    UnpBlockType=BLOCK_LZ;
+  }
+  InitFilters30(Solid);
+}
+
+
+void InitFilters30(bool Solid)
+{
+  if (!Solid)
+  {
+    //OldFilterLengths.SoftReset();
+    OldFilterLengths.Clear();
+    LastFilter=0;
+
+    //for (size_t I=0;I<Filters30.Count;I++)
+    //  delete Filters30[I];
+    //Filters30.SoftReset();
+    Filters30.Clear();
+  }
+  //for (size_t I=0;I<PrgStack.Count;I++)
+  //  delete PrgStack[I];
+  //PrgStack.SoftReset();
+  PrgStack.Clear();
+}
+
+
+    }
+}
+*/

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack50_cpp.cs

@@ -222,180 +222,6 @@ internal partial class Unpack
         UnpWriteBuf();
     }
 
-    private async System.Threading.Tasks.Task Unpack5Async(
-        bool Solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        FileExtracted = true;
-
-        if (!Suspended)
-        {
-            UnpInitData(Solid);
-            if (!await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-            {
-                return;
-            }
-
-            if (
-                !ReadBlockHeader(Inp, ref BlockHeader)
-                || !ReadTables(Inp, ref BlockHeader, ref BlockTables)
-                || !TablesRead5
-            )
-            {
-                return;
-            }
-        }
-
-        while (true)
-        {
-            UnpPtr &= MaxWinMask;
-
-            if (Inp.InAddr >= ReadBorder)
-            {
-                var FileDone = false;
-
-                while (
-                    Inp.InAddr > BlockHeader.BlockStart + BlockHeader.BlockSize - 1
-                    || Inp.InAddr == BlockHeader.BlockStart + BlockHeader.BlockSize - 1
-                        && Inp.InBit >= BlockHeader.BlockBitSize
-                )
-                {
-                    if (BlockHeader.LastBlockInFile)
-                    {
-                        FileDone = true;
-                        break;
-                    }
-                    if (
-                        !ReadBlockHeader(Inp, ref BlockHeader)
-                        || !ReadTables(Inp, ref BlockHeader, ref BlockTables)
-                    )
-                    {
-                        return;
-                    }
-                }
-                if (FileDone || !await UnpReadBufAsync(cancellationToken).ConfigureAwait(false))
-                {
-                    break;
-                }
-            }
-
-            if (((WriteBorder - UnpPtr) & MaxWinMask) < MAX_LZ_MATCH + 3 && WriteBorder != UnpPtr)
-            {
-                await UnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-                if (WrittenFileSize > DestUnpSize)
-                {
-                    return;
-                }
-            }
-
-            uint MainSlot = DecodeNumber(Inp, BlockTables.LD);
-            if (MainSlot < 256)
-            {
-                if (Fragmented)
-                {
-                    FragWindow[UnpPtr++] = (byte)MainSlot;
-                }
-                else
-                {
-                    Window[UnpPtr++] = (byte)MainSlot;
-                }
-                continue;
-            }
-            if (MainSlot >= 262)
-            {
-                uint Length = SlotToLength(Inp, MainSlot - 262);
-
-                uint DBits,
-                    Distance = 1,
-                    DistSlot = DecodeNumber(Inp, BlockTables.DD);
-                if (DistSlot < 4)
-                {
-                    DBits = 0;
-                    Distance += DistSlot;
-                }
-                else
-                {
-                    DBits = (DistSlot / 2) - 1;
-                    Distance += (2 | (DistSlot & 1)) << (int)DBits;
-                }
-
-                if (DBits > 0)
-                {
-                    if (DBits >= 4)
-                    {
-                        if (DBits > 4)
-                        {
-                            Distance += ((Inp.getbits() >> (int)(20 - DBits)) << 4);
-                            Inp.addbits(DBits - 4);
-                        }
-
-                        uint LowDist = DecodeNumber(Inp, BlockTables.LDD);
-                        Distance += LowDist;
-                    }
-                    else
-                    {
-                        Distance += Inp.getbits() >> (int)(16 - DBits);
-                        Inp.addbits(DBits);
-                    }
-                }
-
-                if (Distance > 0x100)
-                {
-                    Length++;
-                    if (Distance > 0x2000)
-                    {
-                        Length++;
-                        if (Distance > 0x40000)
-                        {
-                            Length++;
-                        }
-                    }
-                }
-
-                InsertOldDist(Distance);
-                LastLength = Length;
-                CopyString(Length, Distance);
-                continue;
-            }
-            if (MainSlot == 256)
-            {
-                var Filter = new UnpackFilter();
-                if (!ReadFilter(Inp, Filter) || !AddFilter(Filter))
-                {
-                    break;
-                }
-                continue;
-            }
-            if (MainSlot == 257)
-            {
-                if (LastLength != 0)
-                {
-                    CopyString((uint)LastLength, (uint)OldDist[0]);
-                }
-                continue;
-            }
-            if (MainSlot < 262)
-            {
-                uint DistNum = MainSlot - 258;
-                uint Distance = (uint)OldDist[(int)DistNum];
-                for (var I = (int)DistNum; I > 0; I--)
-                {
-                    OldDist[I] = OldDist[I - 1];
-                }
-                OldDist[0] = Distance;
-
-                uint LengthSlot = DecodeNumber(Inp, BlockTables.RD);
-                uint Length = SlotToLength(Inp, LengthSlot);
-                LastLength = Length;
-                CopyString(Length, Distance);
-
-                continue;
-            }
-        }
-        await UnpWriteBufAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     private uint ReadFilterData(BitInput Inp)
     {
         var ByteCount = (Inp.fgetbits() >> 14) + 1;
@@ -513,58 +339,6 @@ internal partial class Unpack
         return ReadCode != -1;
     }
 
-    private async System.Threading.Tasks.Task<bool> UnpReadBufAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var DataSize = ReadTop - Inp.InAddr; // Data left to process.
-        if (DataSize < 0)
-        {
-            return false;
-        }
-
-        BlockHeader.BlockSize -= Inp.InAddr - BlockHeader.BlockStart;
-        if (Inp.InAddr > MAX_SIZE / 2)
-        {
-            if (DataSize > 0)
-            {
-                Buffer.BlockCopy(Inp.InBuf, Inp.InAddr, Inp.InBuf, 0, DataSize);
-            }
-
-            Inp.InAddr = 0;
-            ReadTop = DataSize;
-        }
-        else
-        {
-            DataSize = ReadTop;
-        }
-
-        var ReadCode = 0;
-        if (MAX_SIZE != DataSize)
-        {
-            ReadCode = await UnpIO_UnpReadAsync(
-                    Inp.InBuf,
-                    DataSize,
-                    MAX_SIZE - DataSize,
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
-        }
-
-        if (ReadCode > 0) // Can be also -1.
-        {
-            ReadTop += ReadCode;
-        }
-
-        ReadBorder = ReadTop - 30;
-        BlockHeader.BlockStart = Inp.InAddr;
-        if (BlockHeader.BlockSize != -1) // '-1' means not defined yet.
-        {
-            ReadBorder = Math.Min(ReadBorder, BlockHeader.BlockStart + BlockHeader.BlockSize - 1);
-        }
-        return ReadCode != -1;
-    }
-
     private void UnpWriteBuf()
     {
         var WrittenBorder = WrPtr;
@@ -759,163 +533,6 @@ internal partial class Unpack
         }
     }
 
-    private async System.Threading.Tasks.Task UnpWriteBufAsync(
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        var WrittenBorder = WrPtr;
-        var FullWriteSize = (UnpPtr - WrittenBorder) & MaxWinMask;
-        var WriteSizeLeft = FullWriteSize;
-        var NotAllFiltersProcessed = false;
-
-        for (var I = 0; I < Filters.Count; I++)
-        {
-            var flt = Filters[I];
-            if (flt.Type == FILTER_NONE)
-            {
-                continue;
-            }
-
-            if (flt.NextWindow)
-            {
-                if (((flt.BlockStart - WrPtr) & MaxWinMask) <= FullWriteSize)
-                {
-                    flt.NextWindow = false;
-                }
-                continue;
-            }
-
-            var BlockStart = flt.BlockStart;
-            var BlockLength = flt.BlockLength;
-            if (((BlockStart - WrittenBorder) & MaxWinMask) < WriteSizeLeft)
-            {
-                if (WrittenBorder != BlockStart)
-                {
-                    await UnpWriteAreaAsync(WrittenBorder, BlockStart, cancellationToken)
-                        .ConfigureAwait(false);
-                    WrittenBorder = BlockStart;
-                    WriteSizeLeft = (UnpPtr - WrittenBorder) & MaxWinMask;
-                }
-                if (BlockLength <= WriteSizeLeft)
-                {
-                    if (BlockLength > 0)
-                    {
-                        var BlockEnd = (BlockStart + BlockLength) & MaxWinMask;
-
-                        FilterSrcMemory = EnsureCapacity(
-                            FilterSrcMemory,
-                            checked((int)BlockLength)
-                        );
-                        var Mem = FilterSrcMemory;
-                        if (BlockStart < BlockEnd || BlockEnd == 0)
-                        {
-                            if (Fragmented)
-                            {
-                                FragWindow.CopyData(Mem, 0, BlockStart, BlockLength);
-                            }
-                            else
-                            {
-                                Buffer.BlockCopy(Window, (int)BlockStart, Mem, 0, (int)BlockLength);
-                            }
-                        }
-                        else
-                        {
-                            var FirstPartLength = MaxWinSize - BlockStart;
-                            if (Fragmented)
-                            {
-                                FragWindow.CopyData(Mem, 0, BlockStart, FirstPartLength);
-                                FragWindow.CopyData(Mem, FirstPartLength, 0, BlockEnd);
-                            }
-                            else
-                            {
-                                Buffer.BlockCopy(
-                                    Window,
-                                    (int)BlockStart,
-                                    Mem,
-                                    0,
-                                    (int)FirstPartLength
-                                );
-                                Buffer.BlockCopy(
-                                    Window,
-                                    0,
-                                    Mem,
-                                    (int)FirstPartLength,
-                                    (int)BlockEnd
-                                );
-                            }
-                        }
-
-                        var OutMem = ApplyFilter(Mem, BlockLength, flt);
-
-                        Filters[I].Type = FILTER_NONE;
-
-                        if (OutMem != null)
-                        {
-                            await UnpIO_UnpWriteAsync(OutMem, 0, BlockLength, cancellationToken)
-                                .ConfigureAwait(false);
-                            WrittenFileSize += BlockLength;
-                        }
-
-                        WrittenBorder = BlockEnd;
-                        WriteSizeLeft = (UnpPtr - WrittenBorder) & MaxWinMask;
-                    }
-                }
-                else
-                {
-                    NotAllFiltersProcessed = true;
-                    for (var J = I; J < Filters.Count; J++)
-                    {
-                        var fltj = Filters[J];
-                        if (
-                            fltj.Type != FILTER_NONE
-                            && fltj.NextWindow == false
-                            && ((fltj.BlockStart - WrPtr) & MaxWinMask) < FullWriteSize
-                        )
-                        {
-                            fltj.NextWindow = true;
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-
-        var EmptyCount = 0;
-        for (var I = 0; I < Filters.Count; I++)
-        {
-            if (EmptyCount > 0)
-            {
-                Filters[I - EmptyCount] = Filters[I];
-            }
-
-            if (Filters[I].Type == FILTER_NONE)
-            {
-                EmptyCount++;
-            }
-        }
-        if (EmptyCount > 0)
-        {
-            Filters.RemoveRange(Filters.Count - EmptyCount, EmptyCount);
-        }
-
-        if (!NotAllFiltersProcessed)
-        {
-            await UnpWriteAreaAsync(WrittenBorder, UnpPtr, cancellationToken).ConfigureAwait(false);
-            WrPtr = UnpPtr;
-        }
-
-        WriteBorder = (UnpPtr + Math.Min(MaxWinSize, UNPACK_MAX_WRITE)) & MaxWinMask;
-
-        if (
-            WriteBorder == UnpPtr
-            || WrPtr != UnpPtr
-                && ((WrPtr - UnpPtr) & MaxWinMask) < ((WriteBorder - UnpPtr) & MaxWinMask)
-        )
-        {
-            WriteBorder = WrPtr;
-        }
-    }
-
     private byte[] ApplyFilter(byte[] __d, uint DataSize, UnpackFilter Flt)
     {
         var Data = 0;
@@ -1047,48 +664,6 @@ internal partial class Unpack
         }
     }
 
-    private async System.Threading.Tasks.Task UnpWriteAreaAsync(
-        size_t StartPtr,
-        size_t EndPtr,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (EndPtr != StartPtr)
-        {
-            UnpSomeRead = true;
-        }
-
-        if (EndPtr < StartPtr)
-        {
-            UnpAllBuf = true;
-        }
-
-        if (Fragmented)
-        {
-            var SizeToWrite = (EndPtr - StartPtr) & MaxWinMask;
-            while (SizeToWrite > 0)
-            {
-                var BlockSize = FragWindow.GetBlockSize(StartPtr, SizeToWrite);
-                FragWindow.GetBuffer(StartPtr, out var __buffer, out var __offset);
-                await UnpWriteDataAsync(__buffer, __offset, BlockSize, cancellationToken)
-                    .ConfigureAwait(false);
-                SizeToWrite -= BlockSize;
-                StartPtr = (StartPtr + BlockSize) & MaxWinMask;
-            }
-        }
-        else if (EndPtr < StartPtr)
-        {
-            await UnpWriteDataAsync(Window, StartPtr, MaxWinSize - StartPtr, cancellationToken)
-                .ConfigureAwait(false);
-            await UnpWriteDataAsync(Window, 0, EndPtr, cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            await UnpWriteDataAsync(Window, StartPtr, EndPtr - StartPtr, cancellationToken)
-                .ConfigureAwait(false);
-        }
-    }
-
     private void UnpWriteData(byte[] Data, size_t offset, size_t Size)
     {
         if (WrittenFileSize >= DestUnpSize)
@@ -1107,29 +682,6 @@ internal partial class Unpack
         WrittenFileSize += Size;
     }
 
-    private async System.Threading.Tasks.Task UnpWriteDataAsync(
-        byte[] Data,
-        size_t offset,
-        size_t Size,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        if (WrittenFileSize >= DestUnpSize)
-        {
-            return;
-        }
-
-        var WriteSize = Size;
-        var LeftToWrite = DestUnpSize - WrittenFileSize;
-        if (WriteSize > LeftToWrite)
-        {
-            WriteSize = (size_t)LeftToWrite;
-        }
-
-        await UnpIO_UnpWriteAsync(Data, offset, WriteSize, cancellationToken).ConfigureAwait(false);
-        WrittenFileSize += Size;
-    }
-
     private void UnpInitData50(bool Solid)
     {
         if (!Solid)

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack_cpp.cs

@@ -1,11 +1,16 @@
 #nullable disable
 
 using System;
-using System.Buffers;
 using SharpCompress.Common;
 using static SharpCompress.Compressors.Rar.UnpackV2017.PackDef;
 using static SharpCompress.Compressors.Rar.UnpackV2017.UnpackGlobal;
+#if !Rar2017_64bit
 using size_t = System.UInt32;
+#else
+using nint = System.Int64;
+using nuint = System.UInt64;
+using size_t = System.UInt64;
+#endif
 
 namespace SharpCompress.Compressors.Rar.UnpackV2017;
 
@@ -37,9 +42,11 @@ internal sealed partial class Unpack : BitInput
         // It prevents crash if first DoUnpack call is later made with wrong
         // (true) 'Solid' value.
         UnpInitData(false);
+#if !RarV2017_SFX_MODULE
         // RAR 1.5 decompression initialization
         UnpInitData15(false);
         InitHuff();
+#endif
     }
 
     // later: may need Dispose() if we support thread pool
@@ -103,7 +110,7 @@ internal sealed partial class Unpack : BitInput
             throw new InvalidFormatException("Grow && Fragmented");
         }
 
-        var NewWindow = Fragmented ? null : ArrayPool<byte>.Shared.Rent((int)WinSize);
+        var NewWindow = Fragmented ? null : new byte[WinSize];
 
         if (NewWindow == null)
         {
@@ -119,7 +126,6 @@ internal sealed partial class Unpack : BitInput
                 if (Window != null) // If allocated by preceding files.
                 {
                     //free(Window);
-                    ArrayPool<byte>.Shared.Return(Window);
                     Window = null;
                 }
                 FragWindow.Init(WinSize);
@@ -164,6 +170,7 @@ internal sealed partial class Unpack : BitInput
         // just for extra safety.
         switch (Method)
         {
+#if !RarV2017_SFX_MODULE
             case 15: // rar 1.5 compression
                 if (!Fragmented)
                 {
@@ -178,65 +185,34 @@ internal sealed partial class Unpack : BitInput
                     Unpack20(Solid);
                 }
 
-                break;
-            case 29: // rar 3.x compression
-                if (!Fragmented)
-                {
-                    throw new NotImplementedException();
-                }
-
-                break;
-            case 50: // RAR 5.0 compression algorithm.
-                Unpack5(Solid);
-                break;
-#if !Rar2017_NOSTRICT
-            default:
-                throw new InvalidFormatException("unknown compression method " + Method);
-#endif
-        }
-    }
-
-    private async System.Threading.Tasks.Task DoUnpackAsync(
-        uint Method,
-        bool Solid,
-        System.Threading.CancellationToken cancellationToken = default
-    )
-    {
-        // Methods <50 will crash in Fragmented mode when accessing NULL Window.
-        // They cannot be called in such mode now, but we check it below anyway
-        // just for extra safety.
-        switch (Method)
-        {
-#if !RarV2017_SFX_MODULE
-            case 15: // rar 1.5 compression
-                if (!Fragmented)
-                {
-                    await Unpack15Async(Solid, cancellationToken).ConfigureAwait(false);
-                }
-
-                break;
-            case 20: // rar 2.x compression
-            case 26: // files larger than 2GB
-                if (!Fragmented)
-                {
-                    await Unpack20Async(Solid, cancellationToken).ConfigureAwait(false);
-                }
-
                 break;
 #endif
 #if !RarV2017_RAR5ONLY
             case 29: // rar 3.x compression
                 if (!Fragmented)
                 {
-                    // TODO: Create Unpack29Async when ready
                     throw new NotImplementedException();
                 }
 
                 break;
 #endif
             case 50: // RAR 5.0 compression algorithm.
-                // RAR 5.0 has full async support via UnpReadBufAsync and UnpWriteBuf
-                await Unpack5Async(Solid, cancellationToken).ConfigureAwait(false);
+                /*#if RarV2017_RAR_SMP
+                                if (MaxUserThreads > 1)
+                                {
+                                    //      We do not use the multithreaded unpack routine to repack RAR archives
+                                    //      in 'suspended' mode, because unlike the single threaded code it can
+                                    //      write more than one dictionary for same loop pass. So we would need
+                                    //      larger buffers of unknown size. Also we do not support multithreading
+                                    //      in fragmented window mode.
+                                    if (!Fragmented)
+                                    {
+                                        Unpack5MT(Solid);
+                                        break;
+                                    }
+                                }
+                #endif*/
+                Unpack5(Solid);
                 break;
 #if !Rar2017_NOSTRICT
             default:

src/SharpCompress/Compressors/Squeezed/SqueezedStream.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
 using SharpCompress.Compressors.RLE90;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Squeezed
 {
-    [CLSCompliant(true)]
     public class SqueezeStream : Stream, IStreamStack
     {
 #if DEBUG_STREAMS
@@ -34,15 +35,12 @@ namespace SharpCompress.Compressors.Squeezed
         private readonly int _compressedSize;
         private const int NUMVALS = 257;
         private const int SPEOF = 256;
-
-        private Stream _decodedStream;
+        private bool _processed = false;
 
         public SqueezeStream(Stream stream, int compressedSize)
         {
-            _stream = stream ?? throw new ArgumentNullException(nameof(stream));
+            _stream = stream;
             _compressedSize = compressedSize;
-            _decodedStream = BuildDecodedStream();
-
 #if DEBUG_STREAMS
             this.DebugConstruct(typeof(SqueezeStream));
 #endif
@@ -53,46 +51,52 @@ namespace SharpCompress.Compressors.Squeezed
 #if DEBUG_STREAMS
             this.DebugDispose(typeof(SqueezeStream));
 #endif
-            _decodedStream?.Dispose();
             base.Dispose(disposing);
         }
 
         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 Length => throw new NotImplementedException();
+
         public override long Position
         {
-            get => throw new NotSupportedException();
-            set => throw new NotSupportedException();
+            get => _stream.Position;
+            set => throw new NotImplementedException();
         }
 
-        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();
+        public override void Flush() => throw new NotImplementedException();
 
         public override int Read(byte[] buffer, int offset, int count)
         {
-            return _decodedStream.Read(buffer, offset, count);
-        }
-
-        private Stream BuildDecodedStream()
-        {
-            var binaryReader = new BinaryReader(_stream, Encoding.Default, leaveOpen: true);
-            int numnodes = binaryReader.ReadUInt16();
-
-            if (numnodes >= NUMVALS || numnodes == 0)
+            if (_processed)
             {
-                return new MemoryStream(Array.Empty<byte>());
+                return 0;
+            }
+            _processed = true;
+            using var binaryReader = new BinaryReader(_stream);
+
+            // Read numnodes (equivalent to convert_u16!(numnodes, buf))
+            var numnodes = binaryReader.ReadUInt16();
+
+            // Validation: numnodes should be within bounds
+            if (numnodes >= NUMVALS)
+            {
+                throw new InvalidDataException(
+                    $"Invalid number of nodes {numnodes} (max {NUMVALS - 1})"
+                );
             }
 
+            // Handle the case where no nodes exist
+            if (numnodes == 0)
+            {
+                return 0;
+            }
+
+            // Build dnode (tree of nodes)
             var dnode = new int[numnodes, 2];
             for (int j = 0; j < numnodes; j++)
             {
@@ -100,27 +104,42 @@ namespace SharpCompress.Compressors.Squeezed
                 dnode[j, 1] = binaryReader.ReadInt16();
             }
 
+            // Initialize BitReader for reading bits
             var bitReader = new BitReader(_stream);
-            var huffmanDecoded = new MemoryStream();
-            int i = 0;
+            var decoded = new List<byte>();
 
+            int i = 0;
+            // Decode the buffer using the dnode tree
             while (true)
             {
                 i = dnode[i, bitReader.ReadBit() ? 1 : 0];
                 if (i < 0)
                 {
-                    i = -(i + 1);
+                    i = (short)-(i + 1);
                     if (i == SPEOF)
                     {
                         break;
                     }
-                    huffmanDecoded.WriteByte((byte)i);
-                    i = 0;
+                    else
+                    {
+                        decoded.Add((byte)i);
+                        i = 0;
+                    }
                 }
             }
 
-            huffmanDecoded.Position = 0;
-            return new RunLength90Stream(huffmanDecoded, (int)huffmanDecoded.Length);
+            // Unpack the decoded buffer using the RLE class
+            var unpacked = RLE.UnpackRLE(decoded.ToArray());
+            unpacked.CopyTo(buffer, 0);
+            return unpacked.Count();
         }
+
+        public override long Seek(long offset, SeekOrigin origin) =>
+            throw new NotImplementedException();
+
+        public override void SetLength(long value) => throw new NotImplementedException();
+
+        public override void Write(byte[] buffer, int offset, int count) =>
+            throw new NotImplementedException();
     }
 }

src/SharpCompress/Compressors/Xz/BinaryUtils.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Buffers.Binary;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Compressors.Xz;
 
@@ -32,28 +30,6 @@ public static class BinaryUtils
     internal static uint ReadLittleEndianUInt32(this Stream stream) =>
         unchecked((uint)ReadLittleEndianInt32(stream));
 
-    public static async Task<int> ReadLittleEndianInt32Async(
-        this Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var bytes = new byte[4];
-        var read = await stream.ReadFullyAsync(bytes, cancellationToken).ConfigureAwait(false);
-        if (!read)
-        {
-            throw new EndOfStreamException();
-        }
-        return BinaryPrimitives.ReadInt32LittleEndian(bytes);
-    }
-
-    internal static async Task<uint> ReadLittleEndianUInt32Async(
-        this Stream stream,
-        CancellationToken cancellationToken = default
-    ) =>
-        unchecked(
-            (uint)await ReadLittleEndianInt32Async(stream, cancellationToken).ConfigureAwait(false)
-        );
-
     internal static byte[] ToBigEndianBytes(this uint uint32)
     {
         var result = BitConverter.GetBytes(uint32);

src/SharpCompress/Compressors/Xz/MultiByteIntegers.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 
 namespace SharpCompress.Compressors.Xz;
@@ -41,75 +39,4 @@ internal static class MultiByteIntegers
         }
         return Output;
     }
-
-    public static async Task<ulong> ReadXZIntegerAsync(
-        this BinaryReader reader,
-        CancellationToken cancellationToken = default,
-        int MaxBytes = 9
-    )
-    {
-        if (MaxBytes <= 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(MaxBytes));
-        }
-
-        if (MaxBytes > 9)
-        {
-            MaxBytes = 9;
-        }
-
-        var LastByte = await ReadByteAsync(reader, cancellationToken).ConfigureAwait(false);
-        var Output = (ulong)LastByte & 0x7F;
-
-        var i = 0;
-        while ((LastByte & 0x80) != 0)
-        {
-            if (++i >= MaxBytes)
-            {
-                throw new InvalidFormatException();
-            }
-
-            LastByte = await ReadByteAsync(reader, cancellationToken).ConfigureAwait(false);
-            if (LastByte == 0)
-            {
-                throw new InvalidFormatException();
-            }
-
-            Output |= ((ulong)(LastByte & 0x7F)) << (i * 7);
-        }
-        return Output;
-    }
-
-    public static async Task<byte> ReadByteAsync(
-        this BinaryReader reader,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var buffer = new byte[1];
-        var bytesRead = await reader
-            .BaseStream.ReadAsync(buffer, 0, 1, cancellationToken)
-            .ConfigureAwait(false);
-        if (bytesRead != 1)
-        {
-            throw new EndOfStreamException();
-        }
-        return buffer[0];
-    }
-
-    public static async Task<byte[]> ReadBytesAsync(
-        this BinaryReader reader,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var buffer = new byte[count];
-        var bytesRead = await reader
-            .BaseStream.ReadAsync(buffer, 0, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (bytesRead != count)
-        {
-            throw new EndOfStreamException();
-        }
-        return buffer;
-    }
 }

src/SharpCompress/Compressors/Xz/XZBlock.cs

@@ -4,8 +4,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.Compressors.Xz.Filters;
 
@@ -74,49 +72,6 @@ public sealed class XZBlock : XZReadOnlyStream
         return bytesRead;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var bytesRead = 0;
-        if (!HeaderIsLoaded)
-        {
-            await LoadHeaderAsync(cancellationToken).ConfigureAwait(false);
-        }
-
-        if (!_streamConnected)
-        {
-            ConnectStream();
-        }
-
-        if (!_endOfStream)
-        {
-            bytesRead = await _decomStream
-                .ReadAsync(buffer, offset, count, cancellationToken)
-                .ConfigureAwait(false);
-        }
-
-        if (bytesRead != count)
-        {
-            _endOfStream = true;
-        }
-
-        if (_endOfStream && !_paddingSkipped)
-        {
-            await SkipPaddingAsync(cancellationToken).ConfigureAwait(false);
-        }
-
-        if (_endOfStream && !_crcChecked)
-        {
-            await CheckCrcAsync(cancellationToken).ConfigureAwait(false);
-        }
-
-        return bytesRead;
-    }
-
     private void SkipPadding()
     {
         var bytes = (BaseStream.Position - _startPosition) % 4;
@@ -132,23 +87,6 @@ public sealed class XZBlock : XZReadOnlyStream
         _paddingSkipped = true;
     }
 
-    private async Task SkipPaddingAsync(CancellationToken cancellationToken = default)
-    {
-        var bytes = (BaseStream.Position - _startPosition) % 4;
-        if (bytes > 0)
-        {
-            var paddingBytes = new byte[4 - bytes];
-            await BaseStream
-                .ReadAsync(paddingBytes, 0, paddingBytes.Length, cancellationToken)
-                .ConfigureAwait(false);
-            if (paddingBytes.Any(b => b != 0))
-            {
-                throw new InvalidFormatException("Padding bytes were non-null");
-            }
-        }
-        _paddingSkipped = true;
-    }
-
     private void CheckCrc()
     {
         var crc = new byte[_checkSize];
@@ -158,15 +96,6 @@ public sealed class XZBlock : XZReadOnlyStream
         _crcChecked = true;
     }
 
-    private async Task CheckCrcAsync(CancellationToken cancellationToken = default)
-    {
-        var crc = new byte[_checkSize];
-        await BaseStream.ReadAsync(crc, 0, _checkSize, cancellationToken).ConfigureAwait(false);
-        // Actually do a check (and read in the bytes
-        //   into the function throughout the stream read).
-        _crcChecked = true;
-    }
-
     private void ConnectStream()
     {
         _decomStream = BaseStream;
@@ -194,21 +123,6 @@ public sealed class XZBlock : XZReadOnlyStream
         HeaderIsLoaded = true;
     }
 
-    private async Task LoadHeaderAsync(CancellationToken cancellationToken = default)
-    {
-        await ReadHeaderSizeAsync(cancellationToken).ConfigureAwait(false);
-        var headerCache = await CacheHeaderAsync(cancellationToken).ConfigureAwait(false);
-
-        using (var cache = new MemoryStream(headerCache))
-        using (var cachedReader = new BinaryReader(cache))
-        {
-            cachedReader.BaseStream.Position = 1; // skip the header size byte
-            ReadBlockFlags(cachedReader);
-            ReadFilters(cachedReader);
-        }
-        HeaderIsLoaded = true;
-    }
-
     private void ReadHeaderSize()
     {
         _blockHeaderSizeByte = (byte)BaseStream.ReadByte();
@@ -218,17 +132,6 @@ public sealed class XZBlock : XZReadOnlyStream
         }
     }
 
-    private async Task ReadHeaderSizeAsync(CancellationToken cancellationToken = default)
-    {
-        var buffer = new byte[1];
-        await BaseStream.ReadAsync(buffer, 0, 1, cancellationToken).ConfigureAwait(false);
-        _blockHeaderSizeByte = buffer[0];
-        if (_blockHeaderSizeByte == 0)
-        {
-            throw new XZIndexMarkerReachedException();
-        }
-    }
-
     private byte[] CacheHeader()
     {
         var blockHeaderWithoutCrc = new byte[BlockHeaderSize - 4];
@@ -236,7 +139,7 @@ public sealed class XZBlock : XZReadOnlyStream
         var read = BaseStream.Read(blockHeaderWithoutCrc, 1, BlockHeaderSize - 5);
         if (read != BlockHeaderSize - 5)
         {
-            throw new EndOfStreamException("Reached end of stream unexpectedly");
+            throw new EndOfStreamException("Reached end of stream unexectedly");
         }
 
         var crc = BaseStream.ReadLittleEndianUInt32();
@@ -249,30 +152,6 @@ public sealed class XZBlock : XZReadOnlyStream
         return blockHeaderWithoutCrc;
     }
 
-    private async Task<byte[]> CacheHeaderAsync(CancellationToken cancellationToken = default)
-    {
-        var blockHeaderWithoutCrc = new byte[BlockHeaderSize - 4];
-        blockHeaderWithoutCrc[0] = _blockHeaderSizeByte;
-        var read = await BaseStream
-            .ReadAsync(blockHeaderWithoutCrc, 1, BlockHeaderSize - 5, cancellationToken)
-            .ConfigureAwait(false);
-        if (read != BlockHeaderSize - 5)
-        {
-            throw new EndOfStreamException("Reached end of stream unexpectedly");
-        }
-
-        var crc = await BaseStream
-            .ReadLittleEndianUInt32Async(cancellationToken)
-            .ConfigureAwait(false);
-        var calcCrc = Crc32.Compute(blockHeaderWithoutCrc);
-        if (crc != calcCrc)
-        {
-            throw new InvalidFormatException("Block header corrupt");
-        }
-
-        return blockHeaderWithoutCrc;
-    }
-
     private void ReadBlockFlags(BinaryReader reader)
     {
         var blockFlags = reader.ReadByte();

src/SharpCompress/Compressors/Xz/XZFooter.cs

@@ -1,8 +1,6 @@
 using System;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
@@ -29,16 +27,6 @@ public class XZFooter
         return footer;
     }
 
-    public static async Task<XZFooter> FromStreamAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var footer = new XZFooter(new BinaryReader(stream, Encoding.UTF8, true));
-        await footer.ProcessAsync(cancellationToken).ConfigureAwait(false);
-        return footer;
-    }
-
     public void Process()
     {
         var crc = _reader.ReadLittleEndianUInt32();
@@ -61,29 +49,4 @@ public class XZFooter
             throw new InvalidFormatException("Magic footer missing");
         }
     }
-
-    public async Task ProcessAsync(CancellationToken cancellationToken = default)
-    {
-        var crc = await _reader
-            .BaseStream.ReadLittleEndianUInt32Async(cancellationToken)
-            .ConfigureAwait(false);
-        var footerBytes = await _reader.ReadBytesAsync(6, cancellationToken).ConfigureAwait(false);
-        var myCrc = Crc32.Compute(footerBytes);
-        if (crc != myCrc)
-        {
-            throw new InvalidFormatException("Footer corrupt");
-        }
-
-        using (var stream = new MemoryStream(footerBytes))
-        using (var reader = new BinaryReader(stream))
-        {
-            BackwardSize = (reader.ReadLittleEndianUInt32() + 1) * 4;
-            StreamFlags = reader.ReadBytes(2);
-        }
-        var magBy = await _reader.ReadBytesAsync(2, cancellationToken).ConfigureAwait(false);
-        if (!magBy.AsSpan().SequenceEqual(_magicBytes))
-        {
-            throw new InvalidFormatException("Magic footer missing");
-        }
-    }
 }

src/SharpCompress/Compressors/Xz/XZHeader.cs

@@ -1,8 +1,6 @@
 using System.IO;
 using System.Linq;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
@@ -25,28 +23,12 @@ public class XZHeader
         return header;
     }
 
-    public static async Task<XZHeader> FromStreamAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var header = new XZHeader(new BinaryReader(stream, Encoding.UTF8, true));
-        await header.ProcessAsync(cancellationToken).ConfigureAwait(false);
-        return header;
-    }
-
     public void Process()
     {
         CheckMagicBytes(_reader.ReadBytes(6));
         ProcessStreamFlags();
     }
 
-    public async Task ProcessAsync(CancellationToken cancellationToken = default)
-    {
-        CheckMagicBytes(await _reader.ReadBytesAsync(6, cancellationToken).ConfigureAwait(false));
-        await ProcessStreamFlagsAsync(cancellationToken).ConfigureAwait(false);
-    }
-
     private void ProcessStreamFlags()
     {
         var streamFlags = _reader.ReadBytes(2);
@@ -65,26 +47,6 @@ public class XZHeader
         }
     }
 
-    private async Task ProcessStreamFlagsAsync(CancellationToken cancellationToken = default)
-    {
-        var streamFlags = await _reader.ReadBytesAsync(2, cancellationToken).ConfigureAwait(false);
-        var crc = await _reader
-            .BaseStream.ReadLittleEndianUInt32Async(cancellationToken)
-            .ConfigureAwait(false);
-        var calcCrc = Crc32.Compute(streamFlags);
-        if (crc != calcCrc)
-        {
-            throw new InvalidFormatException("Stream header corrupt");
-        }
-
-        BlockCheckType = (CheckType)(streamFlags[1] & 0x0F);
-        var futureUse = (byte)(streamFlags[1] & 0xF0);
-        if (futureUse != 0 || streamFlags[0] != 0)
-        {
-            throw new InvalidFormatException("Unknown XZ Stream Version");
-        }
-    }
-
     private void CheckMagicBytes(byte[] header)
     {
         if (!header.SequenceEqual(MagicHeader))

src/SharpCompress/Compressors/Xz/XZIndex.cs

@@ -3,8 +3,6 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
@@ -41,20 +39,6 @@ public class XZIndex
         return index;
     }
 
-    public static async Task<XZIndex> FromStreamAsync(
-        Stream stream,
-        bool indexMarkerAlreadyVerified,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var index = new XZIndex(
-            new BinaryReader(stream, Encoding.UTF8, true),
-            indexMarkerAlreadyVerified
-        );
-        await index.ProcessAsync(cancellationToken).ConfigureAwait(false);
-        return index;
-    }
-
     public void Process()
     {
         if (!_indexMarkerAlreadyVerified)
@@ -71,26 +55,6 @@ public class XZIndex
         VerifyCrc32();
     }
 
-    public async Task ProcessAsync(CancellationToken cancellationToken = default)
-    {
-        if (!_indexMarkerAlreadyVerified)
-        {
-            await VerifyIndexMarkerAsync(cancellationToken).ConfigureAwait(false);
-        }
-
-        NumberOfRecords = await _reader.ReadXZIntegerAsync(cancellationToken).ConfigureAwait(false);
-        for (ulong i = 0; i < NumberOfRecords; i++)
-        {
-            Records.Add(
-                await XZIndexRecord
-                    .FromBinaryReaderAsync(_reader, cancellationToken)
-                    .ConfigureAwait(false)
-            );
-        }
-        await SkipPaddingAsync(cancellationToken).ConfigureAwait(false);
-        await VerifyCrc32Async(cancellationToken).ConfigureAwait(false);
-    }
-
     private void VerifyIndexMarker()
     {
         var marker = _reader.ReadByte();
@@ -100,15 +64,6 @@ public class XZIndex
         }
     }
 
-    private async Task VerifyIndexMarkerAsync(CancellationToken cancellationToken = default)
-    {
-        var marker = await _reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-        if (marker != 0)
-        {
-            throw new InvalidFormatException("Not an index block");
-        }
-    }
-
     private void SkipPadding()
     {
         var bytes = (int)(_reader.BaseStream.Position - StreamStartPosition) % 4;
@@ -122,32 +77,9 @@ public class XZIndex
         }
     }
 
-    private async Task SkipPaddingAsync(CancellationToken cancellationToken = default)
-    {
-        var bytes = (int)(_reader.BaseStream.Position - StreamStartPosition) % 4;
-        if (bytes > 0)
-        {
-            var paddingBytes = await _reader
-                .ReadBytesAsync(4 - bytes, cancellationToken)
-                .ConfigureAwait(false);
-            if (paddingBytes.Any(b => b != 0))
-            {
-                throw new InvalidFormatException("Padding bytes were non-null");
-            }
-        }
-    }
-
     private void VerifyCrc32()
     {
         var crc = _reader.ReadLittleEndianUInt32();
         // TODO verify this matches
     }
-
-    private async Task VerifyCrc32Async(CancellationToken cancellationToken = default)
-    {
-        var crc = await _reader
-            .BaseStream.ReadLittleEndianUInt32Async(cancellationToken)
-            .ConfigureAwait(false);
-        // TODO verify this matches
-    }
 }

src/SharpCompress/Compressors/Xz/XZIndexMarkerReachedException.cs

@@ -1,5 +1,5 @@
-using SharpCompress.Common;
+using System;
 
 namespace SharpCompress.Compressors.Xz;
 
-public class XZIndexMarkerReachedException : SharpCompressException { }
+public class XZIndexMarkerReachedException : Exception { }

src/SharpCompress/Compressors/Xz/XZIndexRecord.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Compressors.Xz;
 
@@ -20,16 +18,4 @@ public class XZIndexRecord
         record.UncompressedSize = br.ReadXZInteger();
         return record;
     }
-
-    public static async Task<XZIndexRecord> FromBinaryReaderAsync(
-        BinaryReader br,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var record = new XZIndexRecord();
-        record.UnpaddedSize = await br.ReadXZIntegerAsync(cancellationToken).ConfigureAwait(false);
-        record.UncompressedSize = await br.ReadXZIntegerAsync(cancellationToken)
-            .ConfigureAwait(false);
-        return record;
-    }
 }

src/SharpCompress/Compressors/Xz/XZStream.cs

@@ -2,8 +2,6 @@
 
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
@@ -106,35 +104,6 @@ public sealed class XZStream : XZReadOnlyStream, IStreamStack
         return bytesRead;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var bytesRead = 0;
-        if (_endOfStream)
-        {
-            return bytesRead;
-        }
-
-        if (!HeaderIsRead)
-        {
-            await ReadHeaderAsync(cancellationToken).ConfigureAwait(false);
-        }
-
-        bytesRead = await ReadBlocksAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (bytesRead < count)
-        {
-            _endOfStream = true;
-            await ReadIndexAsync(cancellationToken).ConfigureAwait(false);
-            await ReadFooterAsync(cancellationToken).ConfigureAwait(false);
-        }
-        return bytesRead;
-    }
-
     private void ReadHeader()
     {
         Header = XZHeader.FromStream(BaseStream);
@@ -142,31 +111,12 @@ public sealed class XZStream : XZReadOnlyStream, IStreamStack
         HeaderIsRead = true;
     }
 
-    private async Task ReadHeaderAsync(CancellationToken cancellationToken = default)
-    {
-        Header = await XZHeader
-            .FromStreamAsync(BaseStream, cancellationToken)
-            .ConfigureAwait(false);
-        AssertBlockCheckTypeIsSupported();
-        HeaderIsRead = true;
-    }
-
     private void ReadIndex() => Index = XZIndex.FromStream(BaseStream, true);
 
-    private async Task ReadIndexAsync(CancellationToken cancellationToken = default) =>
-        Index = await XZIndex
-            .FromStreamAsync(BaseStream, true, cancellationToken)
-            .ConfigureAwait(false);
-
-    // TODO verify Index
+    // TODO veryfy Index
     private void ReadFooter() => Footer = XZFooter.FromStream(BaseStream);
 
     // TODO verify footer
-    private async Task ReadFooterAsync(CancellationToken cancellationToken = default) =>
-        Footer = await XZFooter
-            .FromStreamAsync(BaseStream, cancellationToken)
-            .ConfigureAwait(false);
-
     private int ReadBlocks(byte[] buffer, int offset, int count)
     {
         var bytesRead = 0;
@@ -202,48 +152,6 @@ public sealed class XZStream : XZReadOnlyStream, IStreamStack
         return bytesRead;
     }
 
-    private async Task<int> ReadBlocksAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var bytesRead = 0;
-        if (_currentBlock is null)
-        {
-            NextBlock();
-        }
-
-        for (; ; )
-        {
-            try
-            {
-                if (bytesRead >= count)
-                {
-                    break;
-                }
-
-                var remaining = count - bytesRead;
-                var newOffset = offset + bytesRead;
-                var justRead = await _currentBlock
-                    .ReadAsync(buffer, newOffset, remaining, cancellationToken)
-                    .ConfigureAwait(false);
-                if (justRead < remaining)
-                {
-                    NextBlock();
-                }
-
-                bytesRead += justRead;
-            }
-            catch (XZIndexMarkerReachedException)
-            {
-                break;
-            }
-        }
-        return bytesRead;
-    }
-
     private void NextBlock() =>
         _currentBlock = new XZBlock(BaseStream, Header.BlockCheckType, Header.BlockCheckSize);
 }

src/SharpCompress/Factories/ArjFactory.cs

@@ -1,42 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Common.Arj.Headers;
-using SharpCompress.Readers;
-using SharpCompress.Readers.Arj;
-
-namespace SharpCompress.Factories
-{
-    public class ArjFactory : Factory, IReaderFactory
-    {
-        public override string Name => "Arj";
-
-        public override ArchiveType? KnownArchiveType => ArchiveType.Arj;
-
-        public override IEnumerable<string> GetSupportedExtensions()
-        {
-            yield return "arj";
-        }
-
-        public override bool IsArchive(
-            Stream stream,
-            string? password = null,
-            int bufferSize = ReaderOptions.DefaultBufferSize
-        )
-        {
-            var arjHeader = new ArjMainHeader(new ArchiveEncoding());
-            if (arjHeader.Read(stream) == null)
-            {
-                return false;
-            }
-            return true;
-        }
-
-        public IReader OpenReader(Stream stream, ReaderOptions? options) =>
-            ArjReader.Open(stream, options);
-    }
-}

src/SharpCompress/Factories/Factory.cs

@@ -18,7 +18,6 @@ public abstract class Factory : IFactory
         RegisterFactory(new GZipFactory());
         RegisterFactory(new TarFactory());
         RegisterFactory(new ArcFactory());
-        RegisterFactory(new ArjFactory());
     }
 
     private static readonly HashSet<Factory> _factories = new();

src/SharpCompress/IO/IStreamStack.cs

@@ -143,6 +143,7 @@ namespace SharpCompress.IO
             var stack = new List<IStreamStack>();
             Stream? current = stream as Stream;
             int lastBufferingIndex = -1;
+            int firstSeekableIndex = -1;
             Stream? firstSeekableStream = null;
 
             // Traverse the stack, collecting info
@@ -160,6 +161,7 @@ namespace SharpCompress.IO
             // Find the first seekable stream (closest to the root)
             if (current != null && current.CanSeek)
             {
+                firstSeekableIndex = stack.Count;
                 firstSeekableStream = current;
             }
 
@@ -167,17 +169,16 @@ namespace SharpCompress.IO
             if (lastBufferingIndex != -1)
             {
                 var bufferingStream = stack[lastBufferingIndex];
-                var targetBufferPosition =
-                    position - bufferingStream.GetPosition() + bufferingStream.BufferPosition;
-
-                if (targetBufferPosition >= 0 && targetBufferPosition <= bufferingStream.BufferSize)
+                if (position >= 0 && position < bufferingStream.BufferSize)
                 {
-                    bufferingStream.BufferPosition = (int)targetBufferPosition;
+                    bufferingStream.BufferPosition = (int)position;
                     return position;
                 }
-
-                // If position is not in buffer, reset buffer and proceed as non-buffering
-                bufferingStream.BufferPosition = 0;
+                else
+                {
+                    // If position is not in buffer, reset buffer and proceed as non-buffering
+                    bufferingStream.BufferPosition = 0;
+                }
                 // Continue to seek as if no buffer is present
             }
 

src/SharpCompress/IO/ReadOnlySubStream.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Diagnostics;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.IO;
 
@@ -95,47 +93,6 @@ internal class ReadOnlySubStream : SharpCompressStream, IStreamStack
     }
 #endif
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        if (BytesLeftToRead < count)
-        {
-            count = (int)BytesLeftToRead;
-        }
-        var read = await Stream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (read > 0)
-        {
-            BytesLeftToRead -= read;
-            _position += read;
-        }
-        return read;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var sliceLen = BytesLeftToRead < buffer.Length ? BytesLeftToRead : buffer.Length;
-        var read = await Stream
-            .ReadAsync(buffer.Slice(0, (int)sliceLen), cancellationToken)
-            .ConfigureAwait(false);
-        if (read > 0)
-        {
-            BytesLeftToRead -= read;
-            _position += 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/IO/SharpCompressStream.cs

@@ -79,7 +79,7 @@ public class SharpCompressStream : Stream, IStreamStack
             {
                 if (value < 0 || value > _bufferedLength)
                     throw new ArgumentOutOfRangeException(nameof(value));
-                _internalPosition = _internalPosition - _bufferPosition + value;
+                _internalPosition = value;
                 _bufferPosition = value;
                 ValidateBufferState(); // Add here
             }
@@ -90,6 +90,8 @@ public class SharpCompressStream : Stream, IStreamStack
 
     public Stream Stream { get; }
 
+    //private MemoryStream _bufferStream = new();
+
     private bool _readOnly; //some archive detection requires seek to be disabled to cause it to exception to try the next arc type
 
     //private bool _isRewound;
@@ -291,7 +293,7 @@ public class SharpCompressStream : Stream, IStreamStack
 
         long bufferPos = _internalPosition - _bufferPosition;
 
-        if (targetPos >= bufferPos && targetPos <= bufferPos + _bufferedLength)
+        if (targetPos >= bufferPos && targetPos < bufferPos + _bufferedLength)
         {
             _bufferPosition = (int)(targetPos - bufferPos); //repoint within the buffer
             _internalPosition = targetPos;