Mark for 0.32.2

add more tests for uncompressed streaming zips
Merge pull request #686 from Erior/477
2026-02-04 13:34:59 +00:00 · 2022-07-29 10:45:56 +01:00 · 2022-07-29 09:47:35 +01:00 · 2022-07-29 09:41:24 +01:00 · 2022-07-28 23:03:06 +02:00 · 2022-07-28 21:20:42 +02:00
234 changed files with 7114 additions and 3997 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -0,0 +1,543 @@
+# Version: 2.0.1 (Using https://semver.org/)
+# Updated: 2020-12-11
+# See https://github.com/RehanSaeed/EditorConfig/releases for release notes.
+# See https://github.com/RehanSaeed/EditorConfig for updates to this file.
+# See http://EditorConfig.org for more information about .editorconfig files.
+
+##########################################
+# Common Settings
+##########################################
+
+# This file is the top-most EditorConfig file
+root = true
+
+# All Files
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 4
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+##########################################
+# File Extension Settings
+##########################################
+
+# Visual Studio Solution Files
+[*.sln]
+indent_style = tab
+
+# Visual Studio XML Project Files
+[*.{csproj,vbproj,vcxproj.filters,proj,projitems,shproj}]
+indent_size = 2
+
+# XML Configuration Files
+[*.{xml,config,props,targets,nuspec,resx,ruleset,vsixmanifest,vsct}]
+indent_size = 2
+
+# JSON Files
+[*.{json,json5,webmanifest}]
+indent_size = 2
+
+# YAML Files
+[*.{yml,yaml}]
+indent_size = 2
+
+# Markdown Files
+[*.md]
+trim_trailing_whitespace = false
+
+# Web Files
+[*.{htm,html,js,jsm,ts,tsx,css,sass,scss,less,svg,vue}]
+indent_size = 2
+
+# Batch Files
+[*.{cmd,bat}]
+end_of_line = crlf
+
+# Bash Files
+[*.sh]
+end_of_line = lf
+
+# Makefiles
+[Makefile]
+indent_style = tab
+
+##########################################
+# Default .NET Code Style Severities
+# https://docs.microsoft.com/dotnet/fundamentals/code-analysis/configuration-options#scope
+##########################################
+
+[*.{cs,csx,cake,vb,vbx}]
+# Default Severity for all .NET Code Style rules below
+dotnet_analyzer_diagnostic.severity = warning
+
+##########################################
+# File Header (Uncomment to support file headers)
+# https://docs.microsoft.com/visualstudio/ide/reference/add-file-header
+##########################################
+
+# [*.{cs,csx,cake,vb,vbx}]
+# file_header_template = <copyright file="{fileName}" company="PROJECT-AUTHOR">\n© PROJECT-AUTHOR\n</copyright>
+
+# SA1636: File header copyright text should match
+# Justification: .editorconfig supports file headers. If this is changed to a value other than "none", a stylecop.json file will need to added to the project.
+# dotnet_diagnostic.SA1636.severity = none
+
+##########################################
+# .NET Language Conventions
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions
+##########################################
+
+# .NET Code Style Settings
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#net-code-style-settings
+[*.{cs,csx,cake,vb,vbx}]
+# "this." and "Me." qualifiers
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#this-and-me
+#dotnet_style_qualification_for_field = true:warning
+#dotnet_style_qualification_for_property = true:warning
+#dotnet_style_qualification_for_method = true:warning
+#dotnet_style_qualification_for_event = true:warning
+# Language keywords instead of framework type names for type references
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#language-keywords
+dotnet_style_predefined_type_for_locals_parameters_members = true:warning
+dotnet_style_predefined_type_for_member_access = true:warning
+# Modifier preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#normalize-modifiers
+dotnet_style_require_accessibility_modifiers = always:warning
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning
+visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:warning
+dotnet_style_readonly_field = true:warning
+# Parentheses preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parentheses-preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_operators = always_for_clarity:suggestion
+# Expression-level preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
+dotnet_style_object_initializer = true:warning
+dotnet_style_collection_initializer = true:warning
+dotnet_style_explicit_tuple_names = true:warning
+dotnet_style_prefer_inferred_tuple_names = true:warning
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
+dotnet_style_prefer_auto_properties = true:warning
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
+dotnet_style_prefer_conditional_expression_over_assignment = false:suggestion
+dotnet_diagnostic.IDE0045.severity = suggestion
+dotnet_style_prefer_conditional_expression_over_return = false:suggestion
+dotnet_diagnostic.IDE0046.severity = suggestion
+dotnet_style_prefer_compound_assignment = true:warning
+# Null-checking preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#null-checking-preferences
+dotnet_style_coalesce_expression = true:warning
+dotnet_style_null_propagation = true:warning
+# Parameter preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parameter-preferences
+dotnet_code_quality_unused_parameters = all:warning
+# More style options (Undocumented)
+# https://github.com/MicrosoftDocs/visualstudio-docs/issues/3641
+dotnet_style_operator_placement_when_wrapping = end_of_line
+# https://github.com/dotnet/roslyn/pull/40070
+dotnet_style_prefer_simplified_interpolation = true:warning
+
+# C# Code Style Settings
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-code-style-settings
+[*.{cs,csx,cake}]
+# Implicit and explicit types
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#implicit-and-explicit-types
+csharp_style_var_for_built_in_types = true:warning
+csharp_style_var_when_type_is_apparent = true:warning
+csharp_style_var_elsewhere = true:warning
+# Expression-bodied members
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-bodied-members
+csharp_style_expression_bodied_methods = true:warning
+csharp_style_expression_bodied_constructors = true:warning
+csharp_style_expression_bodied_operators = true:warning
+csharp_style_expression_bodied_properties = true:warning
+csharp_style_expression_bodied_indexers = true:warning
+csharp_style_expression_bodied_accessors = true:warning
+csharp_style_expression_bodied_lambdas = true:warning
+csharp_style_expression_bodied_local_functions = true:warning
+# Pattern matching
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#pattern-matching
+csharp_style_pattern_matching_over_is_with_cast_check = true:warning
+csharp_style_pattern_matching_over_as_with_null_check = true:warning
+# Inlined variable declarations
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#inlined-variable-declarations
+csharp_style_inlined_variable_declaration = true:warning
+# Expression-level preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
+csharp_prefer_simple_default_expression = true:warning
+# "Null" checking preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-null-checking-preferences
+csharp_style_throw_expression = true:warning
+csharp_style_conditional_delegate_call = true:warning
+# Code block preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#code-block-preferences
+csharp_prefer_braces = true:warning
+# Unused value preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#unused-value-preferences
+csharp_style_unused_value_expression_statement_preference = discard_variable:suggestion
+dotnet_diagnostic.IDE0058.severity = suggestion
+csharp_style_unused_value_assignment_preference = discard_variable:suggestion
+dotnet_diagnostic.IDE0059.severity = suggestion
+# Index and range preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#index-and-range-preferences
+csharp_style_prefer_index_operator = true:warning
+csharp_style_prefer_range_operator = true:warning
+# Miscellaneous preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#miscellaneous-preferences
+csharp_style_deconstructed_variable_declaration = true:warning
+csharp_style_pattern_local_over_anonymous_function = true:warning
+csharp_using_directive_placement = outside_namespace:warning
+csharp_prefer_static_local_function = true:warning
+csharp_prefer_simple_using_statement = true:suggestion
+dotnet_diagnostic.IDE0063.severity = suggestion
+
+csharp_style_namespace_declarations = file_scoped
+
+##########################################
+# .NET Formatting Conventions
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-code-style-settings-reference#formatting-conventions
+##########################################
+
+# Organize usings
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#organize-using-directives
+dotnet_sort_system_directives_first = true
+# Newline options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#new-line-options
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_between_query_expression_clauses = true
+# Indentation options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#indentation-options
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = no_change
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents_when_block = false
+# Spacing options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#spacing-options
+csharp_space_after_cast = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_between_parentheses = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_after_comma = true
+csharp_space_before_comma = false
+csharp_space_after_dot = false
+csharp_space_before_dot = false
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_around_declaration_statements = false
+csharp_space_before_open_square_brackets = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_square_brackets = false
+# Wrapping options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#wrap-options
+csharp_preserve_single_line_statements = false
+csharp_preserve_single_line_blocks = true
+
+##########################################
+# .NET Naming Conventions
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-naming-conventions
+##########################################
+
+[*.{cs,csx,cake,vb,vbx}]
+dotnet_diagnostic.CA1000.severity = suggestion
+dotnet_diagnostic.CA1001.severity = error
+dotnet_diagnostic.CA1018.severity = error
+dotnet_diagnostic.CA1051.severity = suggestion
+dotnet_diagnostic.CA1068.severity = error
+dotnet_diagnostic.CA1069.severity = error
+dotnet_diagnostic.CA1304.severity = error
+dotnet_diagnostic.CA1305.severity = suggestion
+dotnet_diagnostic.CA1309.severity = suggestion
+dotnet_diagnostic.CA1310.severity = error
+dotnet_diagnostic.CA1707.severity = suggestion
+dotnet_diagnostic.CA1708.severity = suggestion
+dotnet_diagnostic.CA1711.severity = suggestion
+dotnet_diagnostic.CA1716.severity = suggestion
+dotnet_diagnostic.CA1720.severity = suggestion
+dotnet_diagnostic.CA1725.severity = suggestion
+dotnet_diagnostic.CA1805.severity = suggestion
+dotnet_diagnostic.CA1816.severity = suggestion
+dotnet_diagnostic.CA1822.severity = suggestion
+dotnet_diagnostic.CA1825.severity = error
+dotnet_diagnostic.CA1826.severity = silent
+dotnet_diagnostic.CA1827.severity = error
+dotnet_diagnostic.CA1829.severity = suggestion
+dotnet_diagnostic.CA1834.severity = error
+dotnet_diagnostic.CA1845.severity = suggestion
+dotnet_diagnostic.CA1848.severity = suggestion
+dotnet_diagnostic.CA2016.severity = suggestion
+dotnet_diagnostic.CA2201.severity = error
+dotnet_diagnostic.CA2206.severity = error
+dotnet_diagnostic.CA2208.severity = error
+dotnet_diagnostic.CA2211.severity = error
+dotnet_diagnostic.CA2249.severity = error
+dotnet_diagnostic.CA2251.severity = error
+dotnet_diagnostic.CA2252.severity = none
+dotnet_diagnostic.CA2254.severity = suggestion
+
+dotnet_diagnostic.CS0169.severity = error
+dotnet_diagnostic.CS0219.severity = error
+dotnet_diagnostic.CS1998.severity = error
+dotnet_diagnostic.CS8602.severity = error
+dotnet_diagnostic.CS8604.severity = error
+dotnet_diagnostic.CS8618.severity = error
+dotnet_diagnostic.CS0618.severity = error
+dotnet_diagnostic.CS1998.severity = error
+dotnet_diagnostic.CS4014.severity = error
+dotnet_diagnostic.CS8600.severity = error
+dotnet_diagnostic.CS8603.severity = error
+dotnet_diagnostic.CS8625.severity = error
+
+dotnet_diagnostic.BL0005.severity = suggestion
+
+dotnet_diagnostic.MVC1000.severity = suggestion
+
+dotnet_diagnostic.IDE0055.severity = suggestion # Fix formatting
+dotnet_diagnostic.IDE0023.severity = suggestion # use expression body for operators
+dotnet_diagnostic.IDE0025.severity = suggestion # use expression body for properties
+dotnet_diagnostic.IDE1006.severity = suggestion # Naming rule violation: These words cannot contain lower case characters
+dotnet_diagnostic.IDE0072.severity = suggestion # Populate switch - forces population of all cases even when default specified
+dotnet_diagnostic.IDE0027.severity = suggestion # Use expression body for accessors
+dotnet_diagnostic.IDE0032.severity = suggestion # Use auto property
+dotnet_diagnostic.IDE0007.severity = error # Use var
+dotnet_diagnostic.IDE0160.severity = suggestion # Use block scoped
+dotnet_diagnostic.IDE0011.severity = error # Use braces on if statements
+dotnet_diagnostic.IDE0057.severity = suggestion # substring can be simplified
+dotnet_diagnostic.IDE0004.severity = error # redundant cast
+dotnet_diagnostic.IDE0010.severity = silent # populate switch
+dotnet_diagnostic.IDE0021.severity = silent # expression body for constructors
+dotnet_diagnostic.IDE0022.severity = silent # expression body for methods
+dotnet_diagnostic.IDE0024.severity = silent # expression body for operators
+dotnet_diagnostic.IDE0028.severity = silent
+dotnet_diagnostic.IDE0033.severity = error # prefer tuple name
+dotnet_diagnostic.IDE0040.severity = error # modifiers required
+dotnet_diagnostic.IDE0041.severity = error # simplify null
+dotnet_diagnostic.IDE0042.severity = error # deconstruct variable
+dotnet_diagnostic.IDE0044.severity = error # make field only when possible
+dotnet_diagnostic.IDE0047.severity = suggestion # paratemeter name
+dotnet_diagnostic.IDE0051.severity = error # unused field
+dotnet_diagnostic.IDE0052.severity = error # unused member
+dotnet_diagnostic.IDE0060.severity = suggestion # unused parameters
+dotnet_diagnostic.IDE0066.severity = suggestion # switch expression
+dotnet_diagnostic.IDE0078.severity = suggestion # use pattern matching
+dotnet_diagnostic.IDE0090.severity = suggestion # new can be simplified
+dotnet_diagnostic.IDE0130.severity = suggestion # namespace folder structure
+dotnet_diagnostic.IDE0160.severity = silent # Use block namespaces ARE NOT required
+dotnet_diagnostic.IDE0161.severity = suggestion # Please use file namespaces
+
+##########################################
+# Styles
+##########################################
+
+# camel_case_style - Define the camelCase style
+dotnet_naming_style.camel_case_style.capitalization = camel_case
+# pascal_case_style - Define the PascalCase style
+dotnet_naming_style.pascal_case_style.capitalization = pascal_case
+# constant_case - Define the CONSTANT_CASE style
+dotnet_naming_style.constant_case.capitalization = all_upper
+dotnet_naming_style.constant_case.word_separator = _
+# first_upper_style - The first character must start with an upper-case character
+dotnet_naming_style.first_upper_style.capitalization = first_word_upper
+# prefix_interface_with_i_style - Interfaces must be PascalCase and the first character of an interface must be an 'I'
+dotnet_naming_style.prefix_interface_with_i_style.capitalization = pascal_case
+dotnet_naming_style.prefix_interface_with_i_style.required_prefix = I
+# prefix_type_parameters_with_t_style - Generic Type Parameters must be PascalCase and the first character must be a 'T'
+dotnet_naming_style.prefix_type_parameters_with_t_style.capitalization = pascal_case
+dotnet_naming_style.prefix_type_parameters_with_t_style.required_prefix = T
+# disallowed_style - Anything that has this style applied is marked as disallowed
+dotnet_naming_style.disallowed_style.capitalization  = pascal_case
+dotnet_naming_style.disallowed_style.required_prefix = ____RULE_VIOLATION____
+dotnet_naming_style.disallowed_style.required_suffix = ____RULE_VIOLATION____
+# internal_error_style - This style should never occur... if it does, it indicates a bug in file or in the parser using the file
+dotnet_naming_style.internal_error_style.capitalization  = pascal_case
+dotnet_naming_style.internal_error_style.required_prefix = ____INTERNAL_ERROR____
+dotnet_naming_style.internal_error_style.required_suffix = ____INTERNAL_ERROR____
+
+# prefix_interface_with_i_style - Interfaces must be PascalCase and the first character of an interface must be an 'I'
+dotnet_naming_style.underscore_camel_case_style.capitalization = camel_case
+dotnet_naming_style.underscore_camel_case_style.required_prefix = _
+
+##########################################
+# .NET Design Guideline Field Naming Rules
+# Naming rules for fields follow the .NET Framework design guidelines
+# https://docs.microsoft.com/dotnet/standard/design-guidelines/index
+##########################################
+
+# All public/protected/protected_internal constant fields must be constant_case
+# https://docs.microsoft.com/dotnet/standard/design-guidelines/field
+dotnet_naming_symbols.public_protected_constant_fields_group.applicable_accessibilities = public, protected, protected_internal
+dotnet_naming_symbols.public_protected_constant_fields_group.required_modifiers         = const
+dotnet_naming_symbols.public_protected_constant_fields_group.applicable_kinds           = field
+dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.symbols    = public_protected_constant_fields_group
+dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.style      = constant_case
+dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.severity   = warning
+
+# All public/protected/protected_internal static readonly fields must be constant_case
+# https://docs.microsoft.com/dotnet/standard/design-guidelines/field
+dotnet_naming_symbols.public_protected_static_readonly_fields_group.applicable_accessibilities = public, protected, protected_internal
+dotnet_naming_symbols.public_protected_static_readonly_fields_group.required_modifiers         = static, readonly
+dotnet_naming_symbols.public_protected_static_readonly_fields_group.applicable_kinds           = field
+dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.symbols    = public_protected_static_readonly_fields_group
+dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.style      = constant_case
+dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.severity   = warning
+
+# No other public/protected/protected_internal fields are allowed
+# https://docs.microsoft.com/dotnet/standard/design-guidelines/field
+dotnet_naming_symbols.other_public_protected_fields_group.applicable_accessibilities = public, protected, protected_internal
+dotnet_naming_symbols.other_public_protected_fields_group.applicable_kinds           = field
+dotnet_naming_rule.other_public_protected_fields_disallowed_rule.symbols             = other_public_protected_fields_group
+dotnet_naming_rule.other_public_protected_fields_disallowed_rule.style               = disallowed_style
+dotnet_naming_rule.other_public_protected_fields_disallowed_rule.severity            = error
+
+##########################################
+# StyleCop Field Naming Rules
+# Naming rules for fields follow the StyleCop analyzers
+# This does not override any rules using disallowed_style above
+# https://github.com/DotNetAnalyzers/StyleCopAnalyzers
+##########################################
+
+# All constant fields must be constant_case
+# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1303.md
+dotnet_naming_symbols.stylecop_constant_fields_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected, private
+dotnet_naming_symbols.stylecop_constant_fields_group.required_modifiers         = const
+dotnet_naming_symbols.stylecop_constant_fields_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.symbols    = stylecop_constant_fields_group
+dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.style      = constant_case
+dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.severity   = warning
+
+# All static readonly fields must be constant_case
+# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1311.md
+dotnet_naming_symbols.stylecop_static_readonly_fields_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected, private
+dotnet_naming_symbols.stylecop_static_readonly_fields_group.required_modifiers         = static, readonly
+dotnet_naming_symbols.stylecop_static_readonly_fields_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.symbols    = stylecop_static_readonly_fields_group
+dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.style      = constant_case
+dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.severity   = warning
+
+# No non-private instance fields are allowed
+# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1401.md
+dotnet_naming_symbols.stylecop_fields_must_be_private_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected
+dotnet_naming_symbols.stylecop_fields_must_be_private_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.symbols               = stylecop_fields_must_be_private_group
+dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.style                 = disallowed_style
+dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.severity              = error
+
+# Private fields must be camelCase
+# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1306.md
+dotnet_naming_symbols.stylecop_private_fields_group.applicable_accessibilities = private
+dotnet_naming_symbols.stylecop_private_fields_group.applicable_kinds           = field
+dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.symbols     = stylecop_private_fields_group
+dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.style       = underscore_camel_case_style
+dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.severity    = warning
+
+# Local variables must be camelCase
+# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1312.md
+dotnet_naming_symbols.stylecop_local_fields_group.applicable_accessibilities = local
+dotnet_naming_symbols.stylecop_local_fields_group.applicable_kinds           = local
+dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.symbols     = stylecop_local_fields_group
+dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.style       = camel_case_style
+dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.severity    = warning
+
+# This rule should never fire.  However, it's included for at least two purposes:
+# First, it helps to understand, reason about, and root-case certain types of issues, such as bugs in .editorconfig parsers.
+# Second, it helps to raise immediate awareness if a new field type is added (as occurred recently in C#).
+dotnet_naming_symbols.sanity_check_uncovered_field_case_group.applicable_accessibilities = *
+dotnet_naming_symbols.sanity_check_uncovered_field_case_group.applicable_kinds           = field
+dotnet_naming_rule.sanity_check_uncovered_field_case_rule.symbols  = sanity_check_uncovered_field_case_group
+dotnet_naming_rule.sanity_check_uncovered_field_case_rule.style    = internal_error_style
+dotnet_naming_rule.sanity_check_uncovered_field_case_rule.severity = error
+
+
+##########################################
+# Other Naming Rules
+##########################################
+
+# All of the following must be PascalCase:
+# - Namespaces
+#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-namespaces
+#   https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1300.md
+# - Classes and Enumerations
+#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces
+#   https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1300.md
+# - Delegates
+#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces#names-of-common-types
+# - Constructors, Properties, Events, Methods
+#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-type-members
+dotnet_naming_symbols.element_group.applicable_kinds = namespace, class, enum, struct, delegate, event, method, property
+dotnet_naming_rule.element_rule.symbols              = element_group
+dotnet_naming_rule.element_rule.style                = pascal_case_style
+dotnet_naming_rule.element_rule.severity             = warning
+
+# Interfaces use PascalCase and are prefixed with uppercase 'I'
+# https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces
+dotnet_naming_symbols.interface_group.applicable_kinds = interface
+dotnet_naming_rule.interface_rule.symbols              = interface_group
+dotnet_naming_rule.interface_rule.style                = prefix_interface_with_i_style
+dotnet_naming_rule.interface_rule.severity             = warning
+
+# Generics Type Parameters use PascalCase and are prefixed with uppercase 'T'
+# https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces
+dotnet_naming_symbols.type_parameter_group.applicable_kinds = type_parameter
+dotnet_naming_rule.type_parameter_rule.symbols              = type_parameter_group
+dotnet_naming_rule.type_parameter_rule.style                = prefix_type_parameters_with_t_style
+dotnet_naming_rule.type_parameter_rule.severity             = warning
+
+# Function parameters use camelCase
+# https://docs.microsoft.com/dotnet/standard/design-guidelines/naming-parameters
+dotnet_naming_symbols.parameters_group.applicable_kinds = parameter
+dotnet_naming_rule.parameters_rule.symbols              = parameters_group
+dotnet_naming_rule.parameters_rule.style                = camel_case_style
+dotnet_naming_rule.parameters_rule.severity             = warning
+
+##########################################
+# License
+##########################################
+# The following applies as to the .editorconfig file ONLY, and is
+# included below for reference, per the requirements of the license
+# corresponding to this .editorconfig file.
+# See: https://github.com/RehanSaeed/EditorConfig
+#
+# MIT License
+#
+# Copyright (c) 2017-2019 Muhammad Rehan Saeed
+# Copyright (c) 2019 Henry Gabryjelski
+#
+# Permission is hereby granted, free of charge, to any
+# person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the
+# Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute,
+# sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject
+# to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+##########################################
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # search for actions - there are other options available
+    directory: "/" # search in .github/workflows under root `/`
+    schedule:
+      interval: "weekly" # check for action update every week
--- a/.github/workflows/dotnetcore.yml
+++ b/.github/workflows/dotnetcore.yml
@@ -9,16 +9,12 @@ jobs:
        os: [windows-latest, ubuntu-latest]

    steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-dotnet@v1
+    - uses: actions/checkout@v3
+    - uses: actions/setup-dotnet@v2
      with:
-        dotnet-version: 5.0.101
+        dotnet-version: 6.0.x
    - run: dotnet run -p build/build.csproj
-    - uses: actions/upload-artifact@v2
+    - uses: actions/upload-artifact@v3
      with:
        name: ${{ matrix.os }}-sharpcompress.nupkg
        path: artifacts/*
-    - uses: actions/upload-artifact@v2
-      with:
-        name: ${{ matrix.os }}-sharpcompress.snupkg
-        path: artifacts/*
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,4 @@ tools

 .DS_Store
 *.snupkg
+/tests/TestArchives/6d23a38c-f064-4ef1-ad89-b942396f53b9/Scratch
--- a/FORMATS.md
+++ b/FORMATS.md
@@ -19,7 +19,6 @@
 | Tar.XZ                 | LZMA2                                             | Decompress          | TarArchive      | TarReader  | TarWriter (3) |
 | GZip (single file)     | DEFLATE                                           | Both                | GZipArchive     | GZipReader | GZipWriter    |
 | 7Zip (4)               | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate      | Decompress          | SevenZipArchive | N/A        | N/A           |
-| LZip (single file) (5) | LZip (LZMA)                                       | Both                | LZipArchive     | LZipReader | LZipWriter    |

 1. SOLID Rars are only supported in the RarReader API.
 2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading.
--- a/README.md
+++ b/README.md
@@ -182,6 +182,8 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un

 XZ implementation based on: https://github.com/sambott/XZ.NET by @sambott

+XZ BCJ filters support contributed by Louis-Michel Bergeron, on behalf of aDolus Technology Inc. - 2022
+
 7Zip implementation based on: https://code.google.com/p/managed-lzma/

 LICENSE
--- a/build/Program.cs
+++ b/build/Program.cs
@@ -6,78 +6,78 @@ using GlobExpressions;
 using static Bullseye.Targets;
 using static SimpleExec.Command;

-class Program
-{
-    private const string Clean = "clean";
-    private const string Format = "format";
-    private const string Build = "build";
-    private const string Test = "test";
-    private const string Publish = "publish";
+const string Clean = "clean";
+const string Format = "format";
+const string Build = "build";
+const string Test = "test";
+const string Publish = "publish";

-    static void Main(string[] args)
-    {
-        Target(Clean,
-            ForEach("**/bin", "**/obj"),
-            dir =>
-            {
-                IEnumerable<string> GetDirectories(string d)
-                {
-                    return Glob.Directories(".", d);
-                }
+Target(Clean,
+       ForEach("**/bin", "**/obj"),
+       dir =>
+       {
+           IEnumerable<string> GetDirectories(string d)
+           {
+               return Glob.Directories(".", d);
+           }

-                void RemoveDirectory(string d)
-                {
-                    if (Directory.Exists(d))
-                    {
-                        Console.WriteLine(d);
-                        Directory.Delete(d, true);
-                    }
-                }
-
-                foreach (var d in GetDirectories(dir))
-                {
-                    RemoveDirectory(d);
-                }
-            });
-
-        Target(Format, () =>
-        {
-            Run("dotnet", "tool restore");
-            Run("dotnet", "format --check");
-        });
-
-        Target(Build, DependsOn(Format),
-               framework =>
+           void RemoveDirectory(string d)
+           {
+               if (Directory.Exists(d))
               {
-                   if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net46")
-                   {
-                       return;
-                   }
-                   Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release");
-               });
+                   Console.WriteLine(d);
+                   Directory.Delete(d, true);
+               }
+           }

-        Target(Test, DependsOn(Build), ForEach("net5.0"),
-               framework =>
-               {
-                   IEnumerable<string> GetFiles(string d)
-                   {
-                       return Glob.Files(".", d);
-                   }
+           foreach (var d in GetDirectories(dir))
+           {
+               RemoveDirectory(d);
+           }
+       });

-                   foreach (var file in GetFiles("**/*.Test.csproj"))
-                   {
-                       Run("dotnet", $"test {file} -c Release -f {framework}");
-                   }
-               });
+Target(Format,
+       () =>
+       {
+           Run("dotnet", "tool restore");
+           Run("dotnet", "format --check");
+       });

-        Target(Publish, DependsOn(Test),
-               () =>
-               {
-                   Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
-               });
+Target(Build,
+       DependsOn(Format),
+       framework =>
+       {
+           Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release");
+       });

-        Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));
+Target(Test,
+       DependsOn(Build),
+       ForEach("net6.0", "net461"),
+       framework =>
+       {
+           IEnumerable<string> GetFiles(string d)
+           {
+               return Glob.Files(".", d);
+           }

-        RunTargetsAndExit(args);
-    }
-}
+           if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net461")
+           {
+               return;
+           }
+
+           foreach (var file in GetFiles("**/*.Test.csproj"))
+           {
+               Run("dotnet", $"test {file} -c Release -f {framework}");
+           }
+       });
+
+Target(Publish,
+       DependsOn(Test),
+       () =>
+       {
+           Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
+       });
+
+Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));
+
+await RunTargetsAndExitAsync(args);
--- a/build/build.csproj
+++ b/build/build.csproj
@@ -2,13 +2,13 @@

  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Bullseye" Version="3.6.0" />
-    <PackageReference Include="Glob" Version="1.1.8" />
-    <PackageReference Include="SimpleExec" Version="6.4.0" />
+    <PackageReference Include="Bullseye" Version="4.0.0" />
+    <PackageReference Include="Glob" Version="1.1.9" />
+    <PackageReference Include="SimpleExec" Version="10.0.0" />
  </ItemGroup>

 </Project>
--- a/global.json
+++ b/global.json
@@ -1,5 +1,6 @@
 {
  "sdk": {
-    "version": "5.0.101"
+    "version": "6.0.200",
+    "rollForward": "latestFeature"
  }
 }
--- a/src/SharpCompress/Algorithms/Adler32.cs
+++ b/src/SharpCompress/Algorithms/Adler32.cs
@@ -0,0 +1,420 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+#if !NETSTANDARD2_0 && !NETSTANDARD2_1 && !NETFRAMEWORK
+#define SUPPORTS_RUNTIME_INTRINSICS
+#define SUPPORTS_HOTPATH
+#endif
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+#if SUPPORTS_RUNTIME_INTRINSICS
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+#endif
+
+#pragma warning disable IDE0007 // Use implicit type
+namespace SharpCompress.Algorithms
+{
+    /// <summary>
+    /// Calculates the 32 bit Adler checksum of a given buffer according to
+    /// RFC 1950. ZLIB Compressed Data Format Specification version 3.3)
+    /// </summary>
+    internal static class Adler32 // From https://github.com/SixLabors/ImageSharp/blob/main/src/ImageSharp/Compression/Zlib/Adler32.cs
+    {
+        /// <summary>
+        /// Global inlining options. Helps temporarily disable inlining for better profiler output.
+        /// </summary>
+        private static class InliningOptions // From https://github.com/SixLabors/ImageSharp/blob/main/src/ImageSharp/Common/Helpers/InliningOptions.cs
+        {
+            /// <summary>
+            /// <see cref="MethodImplOptions.AggressiveInlining"/> regardless of the build conditions.
+            /// </summary>
+            public const MethodImplOptions AlwaysInline = MethodImplOptions.AggressiveInlining;
+#if PROFILING
+            public const MethodImplOptions HotPath = MethodImplOptions.NoInlining;
+            public const MethodImplOptions ShortMethod = MethodImplOptions.NoInlining;
+#else
+#if SUPPORTS_HOTPATH
+            public const MethodImplOptions HotPath = MethodImplOptions.AggressiveOptimization;
+#else
+            public const MethodImplOptions HotPath = MethodImplOptions.AggressiveInlining;
+#endif
+            public const MethodImplOptions ShortMethod = MethodImplOptions.AggressiveInlining;
+#endif
+            public const MethodImplOptions ColdPath = MethodImplOptions.NoInlining;
+        }
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+        /// <summary>
+        /// Provides optimized static methods for trigonometric, logarithmic,
+        /// and other common mathematical functions.
+        /// </summary>
+        private static class Numerics // From https://github.com/SixLabors/ImageSharp/blob/main/src/ImageSharp/Common/Helpers/Numerics.cs
+        {
+            /// <summary>
+            /// Reduces elements of the vector into one sum.
+            /// </summary>
+            /// <param name="accumulator">The accumulator to reduce.</param>
+            /// <returns>The sum of all elements.</returns>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static int ReduceSum(Vector256<int> accumulator)
+            {
+                // Add upper lane to lower lane.
+                Vector128<int> vsum = Sse2.Add(accumulator.GetLower(), accumulator.GetUpper());
+
+                // Add odd to even.
+                vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_11_01_01));
+
+                // Add high to low.
+                vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_10_11_10));
+
+                return Sse2.ConvertToInt32(vsum);
+            }
+
+            /// <summary>
+            /// Reduces even elements of the vector into one sum.
+            /// </summary>
+            /// <param name="accumulator">The accumulator to reduce.</param>
+            /// <returns>The sum of even elements.</returns>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public static int EvenReduceSum(Vector256<int> accumulator)
+            {
+                Vector128<int> vsum = Sse2.Add(accumulator.GetLower(), accumulator.GetUpper()); // add upper lane to lower lane
+                vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_10_11_10));                      // add high to low
+
+                // Vector128<int>.ToScalar() isn't optimized pre-net5.0 https://github.com/dotnet/runtime/pull/37882
+                return Sse2.ConvertToInt32(vsum);
+            }
+        }
+#endif
+
+        /// <summary>
+        /// The default initial seed value of a Adler32 checksum calculation.
+        /// </summary>
+        public const uint SeedValue = 1U;
+
+        // Largest prime smaller than 65536
+        private const uint BASE = 65521;
+
+        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+        private const uint NMAX = 5552;
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+        private const int MinBufferSize = 64;
+
+        private const int BlockSize = 1 << 5;
+
+        // The C# compiler emits this as a compile-time constant embedded in the PE file.
+        private static ReadOnlySpan<byte> Tap1Tap2 => new byte[]
+        {
+            32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, // tap1
+            16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 // tap2
+        };
+#endif
+
+        /// <summary>
+        /// Calculates the Adler32 checksum with the bytes taken from the span.
+        /// </summary>
+        /// <param name="buffer">The readonly span of bytes.</param>
+        /// <returns>The <see cref="uint"/>.</returns>
+        [MethodImpl(InliningOptions.ShortMethod)]
+        public static uint Calculate(ReadOnlySpan<byte> buffer)
+            => Calculate(SeedValue, buffer);
+
+        /// <summary>
+        /// Calculates the Adler32 checksum with the bytes taken from the span and seed.
+        /// </summary>
+        /// <param name="adler">The input Adler32 value.</param>
+        /// <param name="buffer">The readonly span of bytes.</param>
+        /// <returns>The <see cref="uint"/>.</returns>
+        [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+        public static uint Calculate(uint adler, ReadOnlySpan<byte> buffer)
+        {
+            if (buffer.IsEmpty)
+            {
+                return adler;
+            }
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+            if (Avx2.IsSupported && buffer.Length >= MinBufferSize)
+            {
+                return CalculateAvx2(adler, buffer);
+            }
+
+            if (Ssse3.IsSupported && buffer.Length >= MinBufferSize)
+            {
+                return CalculateSse(adler, buffer);
+            }
+
+            return CalculateScalar(adler, buffer);
+#else
+            return CalculateScalar(adler, buffer);
+#endif
+        }
+
+        // Based on https://github.com/chromium/chromium/blob/master/third_party/zlib/adler32_simd.c
+#if SUPPORTS_RUNTIME_INTRINSICS
+        [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+        private static unsafe uint CalculateSse(uint adler, ReadOnlySpan<byte> buffer)
+        {
+            uint s1 = adler & 0xFFFF;
+            uint s2 = (adler >> 16) & 0xFFFF;
+
+            // Process the data in blocks.
+            uint length = (uint)buffer.Length;
+            uint blocks = length / BlockSize;
+            length -= blocks * BlockSize;
+
+            fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
+            {
+                fixed (byte* tapPtr = &MemoryMarshal.GetReference(Tap1Tap2))
+                {
+                    byte* localBufferPtr = bufferPtr;
+
+                    // _mm_setr_epi8 on x86
+                    Vector128<sbyte> tap1 = Sse2.LoadVector128((sbyte*)tapPtr);
+                    Vector128<sbyte> tap2 = Sse2.LoadVector128((sbyte*)(tapPtr + 0x10));
+                    Vector128<byte> zero = Vector128<byte>.Zero;
+                    var ones = Vector128.Create((short)1);
+
+                    while (blocks > 0)
+                    {
+                        uint n = NMAX / BlockSize;  /* The NMAX constraint. */
+                        if (n > blocks)
+                        {
+                            n = blocks;
+                        }
+
+                        blocks -= n;
+
+                        // Process n blocks of data. At most NMAX data bytes can be
+                        // processed before s2 must be reduced modulo BASE.
+                        Vector128<uint> v_ps = Vector128.CreateScalar(s1 * n);
+                        Vector128<uint> v_s2 = Vector128.CreateScalar(s2);
+                        Vector128<uint> v_s1 = Vector128<uint>.Zero;
+
+                        do
+                        {
+                            // Load 32 input bytes.
+                            Vector128<byte> bytes1 = Sse3.LoadDquVector128(localBufferPtr);
+                            Vector128<byte> bytes2 = Sse3.LoadDquVector128(localBufferPtr + 0x10);
+
+                            // Add previous block byte sum to v_ps.
+                            v_ps = Sse2.Add(v_ps, v_s1);
+
+                            // Horizontally add the bytes for s1, multiply-adds the
+                            // bytes by [ 32, 31, 30, ... ] for s2.
+                            v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes1, zero).AsUInt32());
+                            Vector128<short> mad1 = Ssse3.MultiplyAddAdjacent(bytes1, tap1);
+                            v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad1, ones).AsUInt32());
+
+                            v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes2, zero).AsUInt32());
+                            Vector128<short> mad2 = Ssse3.MultiplyAddAdjacent(bytes2, tap2);
+                            v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad2, ones).AsUInt32());
+
+                            localBufferPtr += BlockSize;
+                        }
+                        while (--n > 0);
+
+                        v_s2 = Sse2.Add(v_s2, Sse2.ShiftLeftLogical(v_ps, 5));
+
+                        // Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
+                        const byte S2301 = 0b1011_0001;  // A B C D -> B A D C
+                        const byte S1032 = 0b0100_1110;  // A B C D -> C D A B
+
+                        v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S1032));
+
+                        s1 += v_s1.ToScalar();
+
+                        v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S2301));
+                        v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S1032));
+
+                        s2 = v_s2.ToScalar();
+
+                        // Reduce.
+                        s1 %= BASE;
+                        s2 %= BASE;
+                    }
+
+                    if (length > 0)
+                    {
+                        HandleLeftOver(localBufferPtr, length, ref s1, ref s2);
+                    }
+
+                    return s1 | (s2 << 16);
+                }
+            }
+        }
+
+        // Based on: https://github.com/zlib-ng/zlib-ng/blob/develop/arch/x86/adler32_avx2.c
+        [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+        public static unsafe uint CalculateAvx2(uint adler, ReadOnlySpan<byte> buffer)
+        {
+            uint s1 = adler & 0xFFFF;
+            uint s2 = (adler >> 16) & 0xFFFF;
+            uint length = (uint)buffer.Length;
+
+            fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
+            {
+                byte* localBufferPtr = bufferPtr;
+
+                Vector256<byte> zero = Vector256<byte>.Zero;
+                var dot3v = Vector256.Create((short)1);
+                var dot2v = Vector256.Create(32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
+
+                // Process n blocks of data. At most NMAX data bytes can be
+                // processed before s2 must be reduced modulo BASE.
+                var vs1 = Vector256.CreateScalar(s1);
+                var vs2 = Vector256.CreateScalar(s2);
+
+                while (length >= 32)
+                {
+                    int k = length < NMAX ? (int)length : (int)NMAX;
+                    k -= k % 32;
+                    length -= (uint)k;
+
+                    Vector256<uint> vs10 = vs1;
+                    Vector256<uint> vs3 = Vector256<uint>.Zero;
+
+                    while (k >= 32)
+                    {
+                        // Load 32 input bytes.
+                        Vector256<byte> block = Avx.LoadVector256(localBufferPtr);
+
+                        // Sum of abs diff, resulting in 2 x int32's
+                        Vector256<ushort> vs1sad = Avx2.SumAbsoluteDifferences(block, zero);
+
+                        vs1 = Avx2.Add(vs1, vs1sad.AsUInt32());
+                        vs3 = Avx2.Add(vs3, vs10);
+
+                        // sum 32 uint8s to 16 shorts.
+                        Vector256<short> vshortsum2 = Avx2.MultiplyAddAdjacent(block, dot2v);
+
+                        // sum 16 shorts to 8 uint32s.
+                        Vector256<int> vsum2 = Avx2.MultiplyAddAdjacent(vshortsum2, dot3v);
+
+                        vs2 = Avx2.Add(vsum2.AsUInt32(), vs2);
+                        vs10 = vs1;
+
+                        localBufferPtr += BlockSize;
+                        k -= 32;
+                    }
+
+                    // Defer the multiplication with 32 to outside of the loop.
+                    vs3 = Avx2.ShiftLeftLogical(vs3, 5);
+                    vs2 = Avx2.Add(vs2, vs3);
+
+                    s1 = (uint)Numerics.EvenReduceSum(vs1.AsInt32());
+                    s2 = (uint)Numerics.ReduceSum(vs2.AsInt32());
+
+                    s1 %= BASE;
+                    s2 %= BASE;
+
+                    vs1 = Vector256.CreateScalar(s1);
+                    vs2 = Vector256.CreateScalar(s2);
+                }
+
+                if (length > 0)
+                {
+                    HandleLeftOver(localBufferPtr, length, ref s1, ref s2);
+                }
+
+                return s1 | (s2 << 16);
+            }
+        }
+
+        private static unsafe void HandleLeftOver(byte* localBufferPtr, uint length, ref uint s1, ref uint s2)
+        {
+            if (length >= 16)
+            {
+                s2 += s1 += localBufferPtr[0];
+                s2 += s1 += localBufferPtr[1];
+                s2 += s1 += localBufferPtr[2];
+                s2 += s1 += localBufferPtr[3];
+                s2 += s1 += localBufferPtr[4];
+                s2 += s1 += localBufferPtr[5];
+                s2 += s1 += localBufferPtr[6];
+                s2 += s1 += localBufferPtr[7];
+                s2 += s1 += localBufferPtr[8];
+                s2 += s1 += localBufferPtr[9];
+                s2 += s1 += localBufferPtr[10];
+                s2 += s1 += localBufferPtr[11];
+                s2 += s1 += localBufferPtr[12];
+                s2 += s1 += localBufferPtr[13];
+                s2 += s1 += localBufferPtr[14];
+                s2 += s1 += localBufferPtr[15];
+
+                localBufferPtr += 16;
+                length -= 16;
+            }
+
+            while (length-- > 0)
+            {
+                s2 += s1 += *localBufferPtr++;
+            }
+
+            if (s1 >= BASE)
+            {
+                s1 -= BASE;
+            }
+
+            s2 %= BASE;
+        }
+#endif
+
+        [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+        private static unsafe uint CalculateScalar(uint adler, ReadOnlySpan<byte> buffer)
+        {
+            uint s1 = adler & 0xFFFF;
+            uint s2 = (adler >> 16) & 0xFFFF;
+            uint k;
+
+            fixed (byte* bufferPtr = buffer)
+            {
+                var localBufferPtr = bufferPtr;
+                uint length = (uint)buffer.Length;
+
+                while (length > 0)
+                {
+                    k = length < NMAX ? length : NMAX;
+                    length -= k;
+
+                    while (k >= 16)
+                    {
+                        s2 += s1 += localBufferPtr[0];
+                        s2 += s1 += localBufferPtr[1];
+                        s2 += s1 += localBufferPtr[2];
+                        s2 += s1 += localBufferPtr[3];
+                        s2 += s1 += localBufferPtr[4];
+                        s2 += s1 += localBufferPtr[5];
+                        s2 += s1 += localBufferPtr[6];
+                        s2 += s1 += localBufferPtr[7];
+                        s2 += s1 += localBufferPtr[8];
+                        s2 += s1 += localBufferPtr[9];
+                        s2 += s1 += localBufferPtr[10];
+                        s2 += s1 += localBufferPtr[11];
+                        s2 += s1 += localBufferPtr[12];
+                        s2 += s1 += localBufferPtr[13];
+                        s2 += s1 += localBufferPtr[14];
+                        s2 += s1 += localBufferPtr[15];
+
+                        localBufferPtr += 16;
+                        k -= 16;
+                    }
+
+                    while (k-- > 0)
+                    {
+                        s2 += s1 += *localBufferPtr++;
+                    }
+
+                    s1 %= BASE;
+                    s2 %= BASE;
+                }
+
+                return (s2 << 16) | s1;
+            }
+        }
+    }
+}
--- a/src/SharpCompress/Algorithms/Alder32.cs
+++ b/src/SharpCompress/Algorithms/Alder32.cs
@@ -1,285 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the GNU Affero General Public License, Version 3.
-
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-#endif
-
-namespace SharpCompress.Algorithms
-{
-    /// <summary>
-    /// Calculates the 32 bit Adler checksum of a given buffer according to
-    /// RFC 1950. ZLIB Compressed Data Format Specification version 3.3)
-    /// </summary>
-    internal static class Adler32
-    {
-        /// <summary>
-        /// The default initial seed value of a Adler32 checksum calculation.
-        /// </summary>
-        public const uint SeedValue = 1U;
-
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-        private const int MinBufferSize = 64;
-#endif
-
-        // Largest prime smaller than 65536
-        private const uint BASE = 65521;
-
-        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
-        private const uint NMAX = 5552;
-
-        /// <summary>
-        /// Calculates the Adler32 checksum with the bytes taken from the span.
-        /// </summary>
-        /// <param name="buffer">The readonly span of bytes.</param>
-        /// <returns>The <see cref="uint"/>.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint Calculate(ReadOnlySpan<byte> buffer)
-        {
-            return Calculate(SeedValue, buffer);
-        }
-
-        /// <summary>
-        /// Calculates the Adler32 checksum with the bytes taken from the span and seed.
-        /// </summary>
-        /// <param name="adler">The input Adler32 value.</param>
-        /// <param name="buffer">The readonly span of bytes.</param>
-        /// <returns>The <see cref="uint"/>.</returns>
-        public static uint Calculate(uint adler, ReadOnlySpan<byte> buffer)
-        {
-            if (buffer.IsEmpty)
-            {
-                return SeedValue;
-            }
-
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-            if (Sse3.IsSupported && buffer.Length >= MinBufferSize)
-            {
-                return CalculateSse(adler, buffer);
-            }
-
-            return CalculateScalar(adler, buffer);
-#else
-            return CalculateScalar(adler, buffer);
-#endif
-        }
-
-        // Based on https://github.com/chromium/chromium/blob/master/third_party/zlib/adler32_simd.c
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-        private static unsafe uint CalculateSse(uint adler, ReadOnlySpan<byte> buffer)
-        {
-            uint s1 = adler & 0xFFFF;
-            uint s2 = (adler >> 16) & 0xFFFF;
-
-            // Process the data in blocks.
-            const int BLOCK_SIZE = 1 << 5;
-
-            uint length = (uint)buffer.Length;
-            uint blocks = length / BLOCK_SIZE;
-            length -= blocks * BLOCK_SIZE;
-
-            int index = 0;
-            fixed (byte* bufferPtr = &buffer[0])
-            {
-                index += (int)blocks * BLOCK_SIZE;
-                var localBufferPtr = bufferPtr;
-
-                // _mm_setr_epi8 on x86
-                var tap1 = Vector128.Create(32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17);
-                var tap2 = Vector128.Create(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
-                Vector128<byte> zero = Vector128<byte>.Zero;
-                var ones = Vector128.Create((short)1);
-
-                while (blocks > 0)
-                {
-                    uint n = NMAX / BLOCK_SIZE;  /* The NMAX constraint. */
-                    if (n > blocks)
-                    {
-                        n = blocks;
-                    }
-
-                    blocks -= n;
-
-                    // Process n blocks of data. At most NMAX data bytes can be
-                    // processed before s2 must be reduced modulo BASE.
-                    Vector128<int> v_ps = Vector128.CreateScalar(s1 * n).AsInt32();
-                    Vector128<int> v_s2 = Vector128.CreateScalar(s2).AsInt32();
-                    Vector128<int> v_s1 = Vector128<int>.Zero;
-
-                    do
-                    {
-                        // Load 32 input bytes.
-                        Vector128<byte> bytes1 = Sse3.LoadDquVector128(localBufferPtr);
-                        Vector128<byte> bytes2 = Sse3.LoadDquVector128(localBufferPtr + 16);
-
-                        // Add previous block byte sum to v_ps.
-                        v_ps = Sse2.Add(v_ps, v_s1);
-
-                        // Horizontally add the bytes for s1, multiply-adds the
-                        // bytes by [ 32, 31, 30, ... ] for s2.
-                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes1, zero).AsInt32());
-                        Vector128<short> mad1 = Ssse3.MultiplyAddAdjacent(bytes1, tap1);
-                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad1, ones));
-
-                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes2, zero).AsInt32());
-                        Vector128<short> mad2 = Ssse3.MultiplyAddAdjacent(bytes2, tap2);
-                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad2, ones));
-
-                        localBufferPtr += BLOCK_SIZE;
-                    }
-                    while (--n > 0);
-
-                    v_s2 = Sse2.Add(v_s2, Sse2.ShiftLeftLogical(v_ps, 5));
-
-                    // Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
-                    const byte S2301 = 0b1011_0001;  // A B C D -> B A D C
-                    const byte S1032 = 0b0100_1110;  // A B C D -> C D A B
-
-                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S2301));
-                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S1032));
-
-                    s1 += (uint)v_s1.ToScalar();
-
-                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S2301));
-                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S1032));
-
-                    s2 = (uint)v_s2.ToScalar();
-
-                    // Reduce.
-                    s1 %= BASE;
-                    s2 %= BASE;
-                }
-            }
-
-            ref byte bufferRef = ref MemoryMarshal.GetReference(buffer);
-
-            if (length > 0)
-            {
-                if (length >= 16)
-                {
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    length -= 16;
-                }
-
-                while (length-- > 0)
-                {
-                    s2 += s1 += Unsafe.Add(ref bufferRef, index++);
-                }
-
-                if (s1 >= BASE)
-                {
-                    s1 -= BASE;
-                }
-
-                s2 %= BASE;
-            }
-
-            return s1 | (s2 << 16);
-        }
-#endif
-
-        private static uint CalculateScalar(uint adler, ReadOnlySpan<byte> buffer)
-        {
-            uint s1 = adler & 0xFFFF;
-            uint s2 = (adler >> 16) & 0xFFFF;
-            uint k;
-
-            ref byte bufferRef = ref MemoryMarshal.GetReference<byte>(buffer);
-            uint length = (uint)buffer.Length;
-            int index = 0;
-
-            while (length > 0)
-            {
-                k = length < NMAX ? length : NMAX;
-                length -= k;
-
-                while (k >= 16)
-                {
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    k -= 16;
-                }
-
-                if (k != 0)
-                {
-                    do
-                    {
-                        s1 += Unsafe.Add(ref bufferRef, index++);
-                        s2 += s1;
-                    }
-                    while (--k != 0);
-                }
-
-                s1 %= BASE;
-                s2 %= BASE;
-            }
-
-            return (s2 << 16) | s1;
-        }
-    }
-}
--- a/src/SharpCompress/Archives/AbstractArchive.cs
+++ b/src/SharpCompress/Archives/AbstractArchive.cs
@@ -1,58 +1,61 @@
-using System;
+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.Readers;

 namespace SharpCompress.Archives
 {
-    public abstract class AbstractArchive<TEntry, TVolume> : IArchive
+    public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
        where TEntry : IArchiveEntry
        where TVolume : IVolume
    {
        private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
        private readonly LazyReadOnlyCollection<TEntry> lazyEntries;

-        protected ReaderOptions ReaderOptions { get; } = new ();
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
+
+        public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
+        public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
+
+        protected ReaderOptions ReaderOptions { get; }

        private bool disposed;
+        protected SourceStream SrcStream;

-        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions, CancellationToken cancellationToken)
+        internal AbstractArchive(ArchiveType type, SourceStream srcStream)
        {
            Type = type;
-            if (!fileInfo.Exists)
-            {
-                throw new ArgumentException("File does not exist: " + fileInfo.FullName);
-            }
-            ReaderOptions = readerOptions;
-            readerOptions.LeaveStreamOpen = false;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo, cancellationToken));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes, cancellationToken));
-        }
-
-
-        protected abstract IAsyncEnumerable<TVolume> LoadVolumes(FileInfo file, CancellationToken cancellationToken);
-
-        internal AbstractArchive(ArchiveType type, IAsyncEnumerable<Stream> streams, ReaderOptions readerOptions, CancellationToken cancellationToken)
-        {
-            Type = type;
-            ReaderOptions = readerOptions;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams), cancellationToken));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes, cancellationToken));
+            ReaderOptions = srcStream.ReaderOptions;
+            SrcStream = srcStream;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
        }

+#nullable disable
        internal AbstractArchive(ArchiveType type)
        {
            Type = type;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>( AsyncEnumerable.Empty<TVolume>());
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(AsyncEnumerable.Empty<TEntry>());
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
        }
+#nullable enable

        public ArchiveType Type { get; }

+        void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry)
+        {
+            EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+        }
+
+        void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry)
+        {
+            EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+        }
+
        private static Stream CheckStreams(Stream stream)
        {
            if (!stream.CanSeek || !stream.CanRead)
@@ -65,48 +68,65 @@ namespace SharpCompress.Archives
        /// <summary>
        /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
        /// </summary>
-        public virtual IAsyncEnumerable<TEntry> Entries => lazyEntries;
+        public virtual ICollection<TEntry> Entries => lazyEntries;

        /// <summary>
        /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
        /// </summary>
-        public IAsyncEnumerable<TVolume> Volumes => lazyVolumes;
+        public ICollection<TVolume> Volumes => lazyVolumes;

        /// <summary>
        /// The total size of the files compressed in the archive.
        /// </summary>
-        public virtual async ValueTask<long> TotalSizeAsync()
-        {
-            await EnsureEntriesLoaded();
-            return await Entries.AggregateAsync(0L, (total, cf) => total + cf.CompressedSize);
-        }
+        public virtual long TotalSize => Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize);

        /// <summary>
        /// The total size of the files as uncompressed in the archive.
        /// </summary>
-        public virtual async ValueTask<long> TotalUncompressedSizeAsync()
-        {
-            await EnsureEntriesLoaded();
-            return await Entries.AggregateAsync(0L, (total, cf) => total + cf.Size);
-        }
+        public virtual long TotalUncompressSize => Entries.Aggregate(0L, (total, cf) => total + cf.Size);

-        protected abstract IAsyncEnumerable<TVolume> LoadVolumes(IAsyncEnumerable<Stream> streams, CancellationToken cancellationToken);
-        protected abstract IAsyncEnumerable<TEntry> LoadEntries(IAsyncEnumerable<TVolume> volumes, CancellationToken cancellationToken);
+        protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream srcStream);
+        protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);

-        IAsyncEnumerable<IArchiveEntry> IArchive.Entries => Entries.Select(x => (IArchiveEntry)x);
+        IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();

-        IAsyncEnumerable<IVolume> IArchive.Volumes => lazyVolumes.Select(x => (IVolume)x);
+        IEnumerable<IVolume> IArchive.Volumes => lazyVolumes.Cast<IVolume>();

-        public virtual async ValueTask DisposeAsync()
+        public virtual void Dispose()
        {
            if (!disposed)
            {
-                await lazyVolumes.ForEachAsync(async v => await v.DisposeAsync());
-                await lazyEntries.GetLoaded().Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
+                lazyVolumes.ForEach(v => v.Dispose());
+                lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+                if (SrcStream != null)
+                    SrcStream.Dispose();
                disposed = true;
            }
        }

+        void IArchiveExtractionListener.EnsureEntriesLoaded()
+        {
+            lazyEntries.EnsureFullyLoaded();
+            lazyVolumes.EnsureFullyLoaded();
+        }
+
+        void IExtractionListener.FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes)
+        {
+            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs(
+                currentFilePartCompressedBytesRead: currentPartCompressedBytes,
+                compressedBytesRead: compressedReadBytes
+            ));
+        }
+
+        void IExtractionListener.FireFilePartExtractionBegin(string name, long size, long compressedSize)
+        {
+            FilePartExtractionBegin?.Invoke(this, new FilePartExtractionBeginEventArgs(
+                compressedSize: compressedSize,
+                size: size,
+                name: name
+            ));
+        }
+
        /// <summary>
        /// Use this method to extract all entries in an archive in order.
        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
@@ -118,32 +138,29 @@ namespace SharpCompress.Archives
        /// occur if this is used at the same time as other extraction methods on this instance.
        /// </summary>
        /// <returns></returns>
-        public async ValueTask<IReader> ExtractAllEntries()
+        public IReader ExtractAllEntries()
        {
-            await EnsureEntriesLoaded();
-            return await CreateReaderForSolidExtraction();
-        }
-        
-        public async ValueTask EnsureEntriesLoaded()
-        {
-            await lazyEntries.EnsureFullyLoaded();
-            await lazyVolumes.EnsureFullyLoaded();
+            ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
+            return CreateReaderForSolidExtraction();
        }

-        protected abstract ValueTask<IReader> CreateReaderForSolidExtraction();
+        protected abstract IReader CreateReaderForSolidExtraction();

        /// <summary>
        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
        /// </summary>
-        public virtual ValueTask<bool> IsSolidAsync() => new(false);
+        public virtual bool IsSolid => false;

        /// <summary>
        /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
        /// </summary>
-        public async ValueTask<bool> IsCompleteAsync()
+        public bool IsComplete
        {
-            await EnsureEntriesLoaded();
-            return await Entries.AllAsync(x => x.IsComplete);
+            get
+            {
+                ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
+                return Entries.All(x => x.IsComplete);
+            }
        }
    }
 }
--- a/src/SharpCompress/Archives/AbstractWritableArchive.cs
+++ b/src/SharpCompress/Archives/AbstractWritableArchive.cs
@@ -1,10 +1,9 @@
-using System;
+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.Readers;
 using SharpCompress.Writers;

@@ -14,7 +13,7 @@ namespace SharpCompress.Archives
        where TEntry : IArchiveEntry
        where TVolume : IVolume
    {
-        private class RebuildPauseDisposable : IAsyncDisposable
+        private class RebuildPauseDisposable : IDisposable
        {
            private readonly AbstractWritableArchive<TEntry, TVolume> archive;

@@ -24,16 +23,16 @@ namespace SharpCompress.Archives
                archive.pauseRebuilding = true;
            }

-            public async ValueTask DisposeAsync()
+            public void Dispose()
            {
                archive.pauseRebuilding = false;
-                await archive.RebuildModifiedCollection();
+                archive.RebuildModifiedCollection();
            }
        }
-        private readonly List<TEntry> newEntries = new();
-        private readonly List<TEntry> removedEntries = new();
+        private readonly List<TEntry> newEntries = new List<TEntry>();
+        private readonly List<TEntry> removedEntries = new List<TEntry>();

-        private readonly List<TEntry> modifiedEntries = new();
+        private readonly List<TEntry> modifiedEntries = new List<TEntry>();
        private bool hasModifications;
        private bool pauseRebuilding;

@@ -42,36 +41,29 @@ namespace SharpCompress.Archives
        {
        }

-        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions,
-                                         CancellationToken cancellationToken)
-            : base(type, stream.AsAsyncEnumerable(), readerFactoryOptions, cancellationToken)
+        internal AbstractWritableArchive(ArchiveType type, SourceStream srcStream)
+            : base(type, srcStream)
        {
        }

-        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions,
-                                         CancellationToken cancellationToken)
-            : base(type, fileInfo, readerFactoryOptions, cancellationToken)
-        {
-        }
-
-        public override IAsyncEnumerable<TEntry> Entries
+        public override ICollection<TEntry> Entries
        {
            get
            {
                if (hasModifications)
                {
-                    return modifiedEntries.ToAsyncEnumerable();
+                    return modifiedEntries;
                }
                return base.Entries;
            }
        }

-        public IAsyncDisposable PauseEntryRebuilding()
+        public IDisposable PauseEntryRebuilding()
        {
            return new RebuildPauseDisposable(this);
        }

-        private async ValueTask RebuildModifiedCollection()
+        private void RebuildModifiedCollection()
        {
            if (pauseRebuilding)
            {
@@ -80,57 +72,56 @@ namespace SharpCompress.Archives
            hasModifications = true;
            newEntries.RemoveAll(v => removedEntries.Contains(v));
            modifiedEntries.Clear();
-            modifiedEntries.AddRange(await OldEntries.Concat(newEntries.ToAsyncEnumerable()).ToListAsync());
+            modifiedEntries.AddRange(OldEntries.Concat(newEntries));
        }

-        private IAsyncEnumerable<TEntry> OldEntries { get { return base.Entries.Where(x => !removedEntries.Contains(x)); } }
+        private IEnumerable<TEntry> OldEntries { get { return base.Entries.Where(x => !removedEntries.Contains(x)); } }

-        public async ValueTask RemoveEntryAsync(TEntry entry)
+        public void RemoveEntry(TEntry entry)
        {
            if (!removedEntries.Contains(entry))
            {
                removedEntries.Add(entry);
-                await RebuildModifiedCollection();
+                RebuildModifiedCollection();
            }
        }

-        ValueTask IWritableArchive.RemoveEntryAsync(IArchiveEntry entry, CancellationToken cancellationToken)
+        void IWritableArchive.RemoveEntry(IArchiveEntry entry)
        {
-            return RemoveEntryAsync((TEntry)entry);
+            RemoveEntry((TEntry)entry);
        }

-        public ValueTask<TEntry>  AddEntryAsync(string key, Stream source,
-                                                       long size = 0, DateTime? modified = null, 
-                                                       CancellationToken cancellationToken = default)
+        public TEntry AddEntry(string key, Stream source,
+                               long size = 0, DateTime? modified = null)
        {
-            return AddEntryAsync(key, source, false, size, modified, cancellationToken);
+            return AddEntry(key, source, false, size, modified);
        }

-        async ValueTask<IArchiveEntry> IWritableArchive.AddEntryAsync(string key, Stream source, bool closeStream, long size, DateTime? modified, CancellationToken cancellationToken)
+        IArchiveEntry IWritableArchive.AddEntry(string key, Stream source, bool closeStream, long size, DateTime? modified)
        {
-            return await AddEntryAsync(key, source, closeStream, size, modified, cancellationToken);
+            return AddEntry(key, source, closeStream, size, modified);
        }

-        public async ValueTask<TEntry> AddEntryAsync(string key, Stream source, bool closeStream,
-                                    long size = 0, DateTime? modified = null, CancellationToken cancellationToken = default)
+        public TEntry AddEntry(string key, Stream source, bool closeStream,
+                               long size = 0, DateTime? modified = null)
        {
            if (key.Length > 0 && key[0] is '/' or '\\')
            {
                key = key.Substring(1);
            }
-            if (await DoesKeyMatchExisting(key))
+            if (DoesKeyMatchExisting(key))
            {
                throw new ArchiveException("Cannot add entry with duplicate key: " + key);
            }
-            var entry = await CreateEntry(key, source, size, modified, closeStream, cancellationToken);
+            var entry = CreateEntry(key, source, size, modified, closeStream);
            newEntries.Add(entry);
-            await RebuildModifiedCollection();
+            RebuildModifiedCollection();
            return entry;
        }

-        private async ValueTask<bool> DoesKeyMatchExisting(string key)
+        private bool DoesKeyMatchExisting(string key)
        {
-            await foreach (var path in Entries.Select(x => x.Key))
+            foreach (var path in Entries.Select(x => x.Key))
            {
                var p = path.Replace('/', '\\');
                if (p.Length > 0 && p[0] == '\\')
@@ -142,35 +133,34 @@ namespace SharpCompress.Archives
            return false;
        }

-        public async ValueTask SaveToAsync(Stream stream, WriterOptions options, CancellationToken cancellationToken = default)
+        public void SaveTo(Stream stream, WriterOptions options)
        {
            //reset streams of new entries
            newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-            await SaveToAsync(stream, options, OldEntries, newEntries.ToAsyncEnumerable(), cancellationToken);
+            SaveTo(stream, options, OldEntries, newEntries);
        }

-        protected ValueTask<TEntry> CreateEntry(string key, Stream source, long size, DateTime? modified,
-                                                bool closeStream, CancellationToken cancellationToken)
+        protected TEntry CreateEntry(string key, Stream source, long size, DateTime? modified,
+                                     bool closeStream)
        {
            if (!source.CanRead || !source.CanSeek)
            {
                throw new ArgumentException("Streams must be readable and seekable to use the Writing Archive API");
            }
-            return CreateEntryInternal(key, source, size, modified, closeStream, cancellationToken);
+            return CreateEntryInternal(key, source, size, modified, closeStream);
        }

-        protected abstract ValueTask<TEntry> CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
-                                                      bool closeStream, CancellationToken cancellationToken);
+        protected abstract TEntry CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
+                                                      bool closeStream);

-        protected abstract ValueTask SaveToAsync(Stream stream, WriterOptions options, IAsyncEnumerable<TEntry> oldEntries, IAsyncEnumerable<TEntry> newEntries,
-                                                 CancellationToken cancellationToken = default);
+        protected abstract void SaveTo(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);

-        public override async ValueTask DisposeAsync()
+        public override void Dispose()
        {
-            await base.DisposeAsync();
-            await newEntries.Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
-            await removedEntries.Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
-            await modifiedEntries.Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
+            base.Dispose();
+            newEntries.Cast<Entry>().ForEach(x => x.Close());
+            removedEntries.Cast<Entry>().ForEach(x => x.Close());
+            modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
        }
    }
 }
--- a/src/SharpCompress/Archives/ArchiveFactory.cs
+++ b/src/SharpCompress/Archives/ArchiveFactory.cs
@@ -1,13 +1,14 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Linq;
 using SharpCompress.Archives.GZip;
-//using SharpCompress.Archives.Rar;
-//using SharpCompress.Archives.SevenZip;
+using SharpCompress.Archives.Rar;
+using SharpCompress.Archives.SevenZip;
 using SharpCompress.Archives.Tar;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
+using SharpCompress.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Archives
@@ -20,7 +21,7 @@ namespace SharpCompress.Archives
        /// <param name="stream"></param>
        /// <param name="readerOptions"></param>
        /// <returns></returns>
-        public static async ValueTask<IArchive> OpenAsync(Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default)
+        public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
            if (!stream.CanRead || !stream.CanSeek)
@@ -28,35 +29,26 @@ namespace SharpCompress.Archives
                throw new ArgumentException("Stream should be readable and seekable");
            }
            readerOptions ??= new ReaderOptions();
-            if (await ZipArchive.IsZipFileAsync(stream, null, cancellationToken))
+
+            ArchiveType? type;
+            IsArchive(stream, out type); //test and reset stream position
+
+            if (type != null)
            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return ZipArchive.Open(stream, readerOptions);
+                switch (type.Value)
+                {
+                    case ArchiveType.Zip:
+                        return ZipArchive.Open(stream, readerOptions);
+                    case ArchiveType.SevenZip:
+                        return SevenZipArchive.Open(stream, readerOptions);
+                    case ArchiveType.GZip:
+                        return GZipArchive.Open(stream, readerOptions);
+                    case ArchiveType.Rar:
+                        return RarArchive.Open(stream, readerOptions);
+                    case ArchiveType.Tar:
+                        return TarArchive.Open(stream, readerOptions);
+                }
            }
-            stream.Seek(0, SeekOrigin.Begin);
-            /*if (SevenZipArchive.IsSevenZipFile(stream))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return SevenZipArchive.Open(stream, readerOptions);
-            }
-            stream.Seek(0, SeekOrigin.Begin);  */
-            if (await GZipArchive.IsGZipFileAsync(stream, cancellationToken))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return GZipArchive.Open(stream, readerOptions);
-            }
-            stream.Seek(0, SeekOrigin.Begin);
-           /* if (RarArchive.IsRarFile(stream, readerOptions))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return RarArchive.Open(stream, readerOptions);
-            }
-            stream.Seek(0, SeekOrigin.Begin);  */
-            if (await TarArchive.IsTarFileAsync(stream, cancellationToken))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return TarArchive.Open(stream, readerOptions);
-            }                    
            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
        }

@@ -65,7 +57,7 @@ namespace SharpCompress.Archives
            return type switch
            {
                ArchiveType.Zip => ZipArchive.Create(),
-                //ArchiveType.Tar => TarArchive.Create(),
+                ArchiveType.Tar => TarArchive.Create(),
                ArchiveType.GZip => GZipArchive.Create(),
                _ => throw new NotSupportedException("Cannot create Archives of type: " + type)
            };
@@ -76,10 +68,10 @@ namespace SharpCompress.Archives
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="options"></param>
-        public static ValueTask<IArchive> OpenAsync(string filePath, ReaderOptions? options = null)
+        public static IArchive Open(string filePath, ReaderOptions? options = null)
        {
            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return OpenAsync(new FileInfo(filePath), options);
+            return Open(new FileInfo(filePath), options);
        }

        /// <summary>
@@ -87,51 +79,217 @@ namespace SharpCompress.Archives
        /// </summary>
        /// <param name="fileInfo"></param>
        /// <param name="options"></param>
-        public static async ValueTask<IArchive> OpenAsync(FileInfo fileInfo, ReaderOptions? options = null, CancellationToken cancellationToken = default)
+        public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
            options ??= new ReaderOptions { LeaveStreamOpen = false };

-            await using var stream = fileInfo.OpenRead();
-            if (await ZipArchive.IsZipFileAsync(stream, null, cancellationToken))
+            ArchiveType? type;
+            using (Stream stream = fileInfo.OpenRead())
            {
-                return ZipArchive.Open(fileInfo, options);
+                IsArchive(stream, out type); //test and reset stream position
+
+                if (type != null)
+                {
+                    switch (type.Value)
+                    {
+                        case ArchiveType.Zip:
+                            return ZipArchive.Open(fileInfo, options);
+                        case ArchiveType.SevenZip:
+                            return SevenZipArchive.Open(fileInfo, options);
+                        case ArchiveType.GZip:
+                            return GZipArchive.Open(fileInfo, options);
+                        case ArchiveType.Rar:
+                            return RarArchive.Open(fileInfo, options);
+                        case ArchiveType.Tar:
+                            return TarArchive.Open(fileInfo, options);
+                    }
+                }
            }
-            stream.Seek(0, SeekOrigin.Begin);
-            /*if (SevenZipArchive.IsSevenZipFile(stream))
+            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
+        }
+
+        /// <summary>
+        /// Constructor with IEnumerable FileInfo objects, multi and split support.
+        /// </summary>
+        /// <param name="fileInfos"></param>
+        /// <param name="options"></param>
+        public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
+        {
+            fileInfos.CheckNotNull(nameof(fileInfos));
+            FileInfo[] files = fileInfos.ToArray();
+            if (files.Length == 0)
+                throw new InvalidOperationException("No files to open");
+            FileInfo fileInfo = files[0];
+            if (files.Length == 1)
+                return Open(fileInfo, options);
+
+
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+            ArchiveType? type;
+            using (Stream stream = fileInfo.OpenRead())
+                IsArchive(stream, out type); //test and reset stream position
+
+            if (type != null)
            {
-                return SevenZipArchive.Open(fileInfo, options);
+                switch (type.Value)
+                {
+                    case ArchiveType.Zip:
+                        return ZipArchive.Open(files, options);
+                    case ArchiveType.SevenZip:
+                        return SevenZipArchive.Open(files, options);
+                    case ArchiveType.GZip:
+                        return GZipArchive.Open(files, options);
+                    case ArchiveType.Rar:
+                        return RarArchive.Open(files, options);
+                    case ArchiveType.Tar:
+                        return TarArchive.Open(files, options);
+                }
            }
-            stream.Seek(0, SeekOrigin.Begin);     */
-            if (await GZipArchive.IsGZipFileAsync(stream, cancellationToken))
+            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
+        }
+
+        /// <summary>
+        /// Constructor with IEnumerable FileInfo objects, multi and split support.
+        /// </summary>
+        /// <param name="streams"></param>
+        /// <param name="options"></param>
+        public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
+        {
+            streams.CheckNotNull(nameof(streams));
+            if (streams.Count() == 0)
+                throw new InvalidOperationException("No streams");
+            if (streams.Count() == 1)
+                return Open(streams.First(), options);
+
+
+            options ??= new ReaderOptions();
+
+            ArchiveType? type;
+            using (Stream stream = streams.First())
+                IsArchive(stream, out type); //test and reset stream position
+
+            if (type != null)
            {
-                return GZipArchive.Open(fileInfo, options);
+                switch (type.Value)
+                {
+                    case ArchiveType.Zip:
+                        return ZipArchive.Open(streams, options);
+                    case ArchiveType.SevenZip:
+                        return SevenZipArchive.Open(streams, options);
+                    case ArchiveType.GZip:
+                        return GZipArchive.Open(streams, options);
+                    case ArchiveType.Rar:
+                        return RarArchive.Open(streams, options);
+                    case ArchiveType.Tar:
+                        return TarArchive.Open(streams, options);
+                }
            }
-            stream.Seek(0, SeekOrigin.Begin);
-            /*if (RarArchive.IsRarFile(stream, options))
-            {
-                return RarArchive.Open(fileInfo, options);
-            }
-            stream.Seek(0, SeekOrigin.Begin);
-            if (TarArchive.IsTarFile(stream))
-            {
-                return TarArchive.Open(fileInfo, options);
-            }                          */
            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
        }

        /// <summary>
        /// Extract to specific directory, retaining filename
        /// </summary>
-        public static async ValueTask WriteToDirectory(string sourceArchive, 
-                                                       string destinationDirectory,
-                                                 ExtractionOptions? options = null, 
-                                                 CancellationToken cancellationToken = default)
+        public static void WriteToDirectory(string sourceArchive, string destinationDirectory,
+                                            ExtractionOptions? options = null)
        {
-            await using IArchive archive = await OpenAsync(sourceArchive);
-            await foreach (IArchiveEntry entry in archive.Entries.WithCancellation(cancellationToken))
+            using IArchive archive = Open(sourceArchive);
+            foreach (IArchiveEntry entry in archive.Entries)
            {
-                await entry.WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken);
+                entry.WriteToDirectory(destinationDirectory, options);
+            }
+        }
+
+        public static bool IsArchive(string filePath, out ArchiveType? type)
+        {
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            using (Stream s = File.OpenRead(filePath))
+                return IsArchive(s, out type);
+        }
+
+        private static bool IsArchive(Stream stream, out ArchiveType? type)
+        {
+            type = null;
+            stream.CheckNotNull(nameof(stream));
+
+            if (!stream.CanRead || !stream.CanSeek)
+            {
+                throw new ArgumentException("Stream should be readable and seekable");
+            }
+            if (ZipArchive.IsZipFile(stream, null))
+                type = ArchiveType.Zip;
+            stream.Seek(0, SeekOrigin.Begin);
+            if (type == null)
+            {
+                if (SevenZipArchive.IsSevenZipFile(stream))
+                    type = ArchiveType.SevenZip;
+                stream.Seek(0, SeekOrigin.Begin);
+            }
+            if (type == null)
+            {
+                if (GZipArchive.IsGZipFile(stream))
+                    type = ArchiveType.GZip;
+                stream.Seek(0, SeekOrigin.Begin);
+            }
+            if (type == null)
+            {
+                if (RarArchive.IsRarFile(stream))
+                    type = ArchiveType.Rar;
+                stream.Seek(0, SeekOrigin.Begin);
+            }
+            if (type == null)
+            {
+                if (TarArchive.IsTarFile(stream))
+                    type = ArchiveType.Tar;
+                stream.Seek(0, SeekOrigin.Begin);
+            }
+            if (type == null) //test multipartzip as it could find zips in other non compressed archive types?
+            {
+                if (ZipArchive.IsZipMulti(stream)) //test the zip (last) file of a multipart zip
+                    type = ArchiveType.Zip;
+                stream.Seek(0, SeekOrigin.Begin);
+            }
+
+            return type != null;
+        }
+
+        /// <summary>
+        /// From a passed in archive (zip, rar, 7z, 001), return all parts.
+        /// </summary>
+        /// <param name="part1"></param>
+        /// <returns></returns>
+        public static IEnumerable<string> GetFileParts(string part1)
+        {
+            part1.CheckNotNullOrEmpty(nameof(part1));
+            return GetFileParts(new FileInfo(part1)).Select(a => a.FullName);
+        }
+
+        /// <summary>
+        /// From a passed in archive (zip, rar, 7z, 001), return all parts.
+        /// </summary>
+        /// <param name="part1"></param>
+        /// <returns></returns>
+        public static IEnumerable<FileInfo> GetFileParts(FileInfo part1)
+        {
+            part1.CheckNotNull(nameof(part1));
+            yield return part1;
+            int i = 1;
+
+            FileInfo? part = RarArchiveVolumeFactory.GetFilePart(i++, part1);
+            if (part != null)
+            {
+                yield return part;
+                while ((part = RarArchiveVolumeFactory.GetFilePart(i++, part1)) != null) //tests split too
+                    yield return part;
+            }
+            else
+            {
+                i = 1;
+                while ((part = ZipArchiveVolumeFactory.GetFilePart(i++, part1)) != null) //tests split too
+                    yield return part;
            }
        }
    }
--- a/src/SharpCompress/Archives/ArchiveVolumeFactory.cs
+++ b/src/SharpCompress/Archives/ArchiveVolumeFactory.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Readers;
+using System.Linq;
+using System.Text;
+using SharpCompress.Common.Rar.Headers;
+using System.Text.RegularExpressions;
+
+namespace SharpCompress.Archives
+{
+    internal abstract class ArchiveVolumeFactory
+    {
+        internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
+        {
+            FileInfo? item = null;
+
+            //split 001, 002 ...
+            Match m = Regex.Match(part1.Name, @"^(.*\.)([0-9]+)$", RegexOptions.IgnoreCase);
+            if (m.Success)
+                item = new FileInfo(Path.Combine(part1.DirectoryName!, String.Concat(m.Groups[1].Value, (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0'))));
+
+            if (item != null && item.Exists)
+                return item;
+            return null;
+        }
+
+    }
+}
--- a/src/SharpCompress/Archives/GZip/GZipArchive.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchive.cs
@@ -1,13 +1,10 @@
-using System;
-using System.Buffers;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
 using SharpCompress.Writers;
@@ -33,11 +30,34 @@ namespace SharpCompress.Archives.GZip
        /// </summary>
        /// <param name="fileInfo"></param>
        /// <param name="readerOptions"></param>
-        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null,
-                                       CancellationToken cancellationToken = default)
+        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions(), cancellationToken);
+            return new GZipArchive(new SourceStream(fileInfo, i => ArchiveVolumeFactory.GetFilePart(i, fileInfo), readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all file parts passed in
+        /// </summary>
+        /// <param name="fileInfos"></param>
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? readerOptions = null)
+        {
+            fileInfos.CheckNotNull(nameof(fileInfos));
+            FileInfo[] files = fileInfos.ToArray();
+            return new GZipArchive(new SourceStream(files[0], i => i < files.Length ? files[i] : null, readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all stream parts passed in
+        /// </summary>
+        /// <param name="streams"></param>
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+        {
+            streams.CheckNotNull(nameof(streams));
+            Stream[] strms = streams.ToArray();
+            return new GZipArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
        }

        /// <summary>
@@ -45,11 +65,10 @@ namespace SharpCompress.Archives.GZip
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="readerOptions"></param>
-        public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null,
-                                       CancellationToken cancellationToken = default)
+        public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
-            return new GZipArchive(stream, readerOptions ?? new ReaderOptions(), cancellationToken);
+            return new GZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
        }

        public static GZipArchive Create()
@@ -58,62 +77,62 @@ namespace SharpCompress.Archives.GZip
        }

        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
+        /// Constructor with a SourceStream able to handle FileInfo and Streams.
        /// </summary>
-        /// <param name="fileInfo"></param>
+        /// <param name="srcStream"></param>
        /// <param name="options"></param>
-        internal GZipArchive(FileInfo fileInfo, ReaderOptions options,
-                             CancellationToken cancellationToken)
-            : base(ArchiveType.GZip, fileInfo, options, cancellationToken)
+        internal GZipArchive(SourceStream srcStream)
+            : base(ArchiveType.Tar, srcStream)
        {
        }

-        protected override IAsyncEnumerable<GZipVolume> LoadVolumes(FileInfo file,
-                                                                    CancellationToken cancellationToken)
+        protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream srcStream)
        {
-            return  new GZipVolume(file, ReaderOptions).AsAsyncEnumerable();
+            srcStream.LoadAllParts();
+            int idx = 0;
+            return srcStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, idx++));
+        }
+        public static bool IsGZipFile(string filePath)
+        {
+            return IsGZipFile(new FileInfo(filePath));
        }

-        public static ValueTask<bool> IsGZipFileAsync(string filePath, CancellationToken cancellationToken = default)
-        {
-            return IsGZipFileAsync(new FileInfo(filePath), cancellationToken);
-        }
-
-        public static async ValueTask<bool> IsGZipFileAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+        public static bool IsGZipFile(FileInfo fileInfo)
        {
            if (!fileInfo.Exists)
            {
                return false;
            }

-            await using Stream stream = fileInfo.OpenRead();
-            return await IsGZipFileAsync(stream, cancellationToken);
+            using Stream stream = fileInfo.OpenRead();
+            return IsGZipFile(stream);
        }

-        public Task SaveToAsync(string filePath, CancellationToken cancellationToken = default)
+        public void SaveTo(string filePath)
        {
-            return SaveToAsync(new FileInfo(filePath), cancellationToken);
+            SaveTo(new FileInfo(filePath));
        }

-        public async Task SaveToAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+        public void SaveTo(FileInfo fileInfo)
        {
-            await using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-            await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken);
+            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
+            {
+                SaveTo(stream, new WriterOptions(CompressionType.GZip));
+            }
        }

-        public static async ValueTask<bool> IsGZipFileAsync(Stream stream, CancellationToken cancellationToken = default)
+        public static bool IsGZipFile(Stream stream)
        {
            // read the header on the first read
-            using var header = MemoryPool<byte>.Shared.Rent(10);
-            var slice = header.Memory.Slice(0, 10);
+            Span<byte> header = stackalloc byte[10];

            // workitem 8501: handle edge case (decompress empty stream)
-            if (await stream.ReadAsync(slice, cancellationToken) != 10)
+            if (!stream.ReadFully(header))
            {
                return false;
            }

-            if (slice.Span[0] != 0x1F || slice.Span[1] != 0x8B || slice.Span[2] != 8)
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
            {
                return false;
            }
@@ -121,70 +140,51 @@ namespace SharpCompress.Archives.GZip
            return true;
        }

-        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        internal GZipArchive(Stream stream, ReaderOptions options,
-                             CancellationToken cancellationToken)
-            : base(ArchiveType.GZip, stream, options, cancellationToken)
-        {
-        }
-
        internal GZipArchive()
            : base(ArchiveType.GZip)
        {
        }

-        protected override async ValueTask<GZipArchiveEntry> CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                                bool closeStream, CancellationToken cancellationToken = default)
+        protected override GZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
+                                                                bool closeStream)
        {
-            if (await Entries.AnyAsync(cancellationToken: cancellationToken))
+            if (Entries.Any())
            {
                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
            }
            return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
        }

-        protected override async ValueTask SaveToAsync(Stream stream, WriterOptions options,
-                                            IAsyncEnumerable<GZipArchiveEntry> oldEntries,
-                                            IAsyncEnumerable<GZipArchiveEntry> newEntries, 
-                                            CancellationToken cancellationToken = default)
+        protected override void SaveTo(Stream stream, WriterOptions options,
+                                       IEnumerable<GZipArchiveEntry> oldEntries,
+                                       IEnumerable<GZipArchiveEntry> newEntries)
        {
-            if (await Entries.CountAsync(cancellationToken: cancellationToken) > 1)
+            if (Entries.Count > 1)
            {
                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
            }
-
-            await using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
-            await foreach (var entry in oldEntries.Concat(newEntries)
-                                                  .Where(x => !x.IsDirectory)
-                                                  .WithCancellation(cancellationToken))
+            using (var writer = new GZipWriter(stream, new GZipWriterOptions(options)))
            {
-                await using var entryStream = await entry.OpenEntryStreamAsync(cancellationToken);
-                await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, cancellationToken);
+                foreach (var entry in oldEntries.Concat(newEntries)
+                                                .Where(x => !x.IsDirectory))
+                {
+                    using (var entryStream = entry.OpenEntryStream())
+                    {
+                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+                    }
+                }
            }
        }

-        protected override async IAsyncEnumerable<GZipVolume> LoadVolumes(IAsyncEnumerable<Stream> streams,
-                                                                          [EnumeratorCancellation]CancellationToken cancellationToken)
+        protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
        {
-            yield return new GZipVolume(await streams.FirstAsync(cancellationToken: cancellationToken), ReaderOptions);
+            Stream stream = volumes.Single().Stream;
+            yield return new GZipArchiveEntry(this, new GZipFilePart(stream, ReaderOptions.ArchiveEncoding));
        }

-        protected override async IAsyncEnumerable<GZipArchiveEntry> LoadEntries(IAsyncEnumerable<GZipVolume> volumes,
-                                                                                [EnumeratorCancellation]CancellationToken cancellationToken)
+        protected override IReader CreateReaderForSolidExtraction()
        {
-            Stream stream = (await volumes.SingleAsync(cancellationToken: cancellationToken)).Stream;
-            var part = new GZipFilePart(ReaderOptions.ArchiveEncoding);
-            await part.Initialize(stream, cancellationToken);
-            yield return new GZipArchiveEntry(this, part);
-        }
-
-        protected override async ValueTask<IReader> CreateReaderForSolidExtraction()
-        {
-            var stream = (await Volumes.SingleAsync()).Stream;
+            var stream = Volumes.Single().Stream;
            stream.Position = 0;
            return GZipReader.Open(stream);
        }
--- a/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.GZip;

 namespace SharpCompress.Archives.GZip
@@ -14,7 +12,7 @@ namespace SharpCompress.Archives.GZip
            Archive = archive;
        }

-        public virtual async ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        public virtual Stream OpenEntryStream()
        {
            //this is to reset the stream to be read multiple times
            var part = (GZipFilePart)Parts.Single();
@@ -22,7 +20,7 @@ namespace SharpCompress.Archives.GZip
            {
                part.GetRawStream().Position = part.EntryStartPosition;
            }
-            return await Parts.Single().GetCompressedStreamAsync(cancellationToken);
+            return Parts.Single().GetCompressedStream();
        }

        #region IArchiveEntry Members
--- a/src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs
@@ -1,10 +1,8 @@
-#nullable disable
+#nullable disable

 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

@@ -52,19 +50,19 @@ namespace SharpCompress.Archives.GZip

        Stream IWritableArchiveEntry.Stream => stream;

-        public override ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        public override Stream OpenEntryStream()
        {
            //ensure new stream is at the start, this could be reset
            stream.Seek(0, SeekOrigin.Begin);
-            return new(new NonDisposingStream(stream));
+            return NonDisposingStream.Create(stream);
        }

-        internal override async ValueTask CloseAsync()
+        internal override void Close()
        {
            if (closeStream)
            {
-                await stream.DisposeAsync();
+                stream.Dispose();
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/IArchive.cs
+++ b/src/SharpCompress/Archives/IArchive.cs
@@ -1,44 +1,49 @@
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;

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

        ArchiveType Type { get; }
-        ValueTask EnsureEntriesLoaded();
+
        /// <summary>
        /// Use this method to extract all entries in an archive in order.
        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be 
        /// extracted sequentially for the best performance.
        /// </summary>
-        ValueTask<IReader> ExtractAllEntries();
+        IReader ExtractAllEntries();

        /// <summary>
        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
        /// Rar Archives can be SOLID while all 7Zip archives are considered SOLID.
        /// </summary>
-        ValueTask<bool> IsSolidAsync();
+        bool IsSolid { get; }

        /// <summary>
        /// This checks to see if all the known entries have IsComplete = true
        /// </summary>
-        ValueTask<bool> IsCompleteAsync();
+        bool IsComplete { get; }

        /// <summary>
        /// The total size of the files compressed in the archive.
        /// </summary>
-        ValueTask<long> TotalSizeAsync();
+        long TotalSize { get; }

        /// <summary>
        /// The total size of the files as uncompressed in the archive.
        /// </summary>
-        ValueTask<long> TotalUncompressedSizeAsync();
+        long TotalUncompressSize { get; }
    }
 }
--- a/src/SharpCompress/Archives/IArchiveEntry.cs
+++ b/src/SharpCompress/Archives/IArchiveEntry.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;

 namespace SharpCompress.Archives
@@ -11,7 +9,7 @@ namespace SharpCompress.Archives
        /// Opens the current entry as a stream that will decompress as it is read.
        /// Read the entire stream or use SkipEntry on EntryStream.
        /// </summary>
-        ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
+        Stream OpenEntryStream();

        /// <summary>
        /// The archive can find all the parts of the archive needed to extract this entry.
--- a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs
+++ b/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;

@@ -8,53 +6,58 @@ namespace SharpCompress.Archives
 {
    public static class IArchiveEntryExtensions
    {
-        public static async ValueTask WriteToAsync(this IArchiveEntry archiveEntry, Stream streamToWriteTo, CancellationToken cancellationToken = default)
+        public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
        {
            if (archiveEntry.IsDirectory)
            {
                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
            }

-            var archive = archiveEntry.Archive;
-            await archive.EnsureEntriesLoaded();
-            var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
+            var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+            streamListener.EnsureEntriesLoaded();
+            streamListener.FireEntryExtractionBegin(archiveEntry);
+            streamListener.FireFilePartExtractionBegin(archiveEntry.Key, archiveEntry.Size, archiveEntry.CompressedSize);
+            var entryStream = archiveEntry.OpenEntryStream();
            if (entryStream is null)
            {
                return;
            }
-            await using (entryStream)
+            using (entryStream)
            {
-                await entryStream.TransferToAsync(streamToWriteTo, cancellationToken);
+                using (Stream s = new ListeningStream(streamListener, entryStream))
+                {
+                    s.TransferTo(streamToWriteTo);
+                }
            }
+            streamListener.FireEntryExtractionEnd(archiveEntry);
        }

        /// <summary>
        /// Extract to specific directory, retaining filename
        /// </summary>
-        public static ValueTask WriteEntryToDirectoryAsync(this IArchiveEntry entry, 
-                                                           string destinationDirectory,
-                                                           ExtractionOptions? options = null, 
-                                                           CancellationToken cancellationToken = default)
+        public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory,
+                                            ExtractionOptions? options = null)
        {
-            return ExtractionMethods.WriteEntryToDirectoryAsync(entry, destinationDirectory, options,
-                                              entry.WriteToFileAsync, cancellationToken);
+            ExtractionMethods.WriteEntryToDirectory(entry, destinationDirectory, options,
+                                              entry.WriteToFile);
        }

        /// <summary>
        /// Extract to specific file
        /// </summary>
-        public static ValueTask WriteToFileAsync(this IArchiveEntry entry,
+        public static void WriteToFile(this IArchiveEntry entry,
                                       string destinationFileName,
-                                       ExtractionOptions? options = null, 
-                                       CancellationToken cancellationToken = default)
+                                       ExtractionOptions? options = null)
        {

-            return ExtractionMethods.WriteEntryToFileAsync(entry, destinationFileName, options,
-                                               async (x, fm, ct) =>
+            ExtractionMethods.WriteEntryToFile(entry, destinationFileName, options,
+                                               (x, fm) =>
                                               {
-                                                   await using FileStream fs = File.Open(x, fm);
-                                                   await entry.WriteToAsync(fs, ct);
-                                               }, cancellationToken);
+                                                   using (FileStream fs = File.Open(destinationFileName, fm))
+                                                   {
+                                                       entry.WriteTo(fs);
+                                                   }
+                                               });
        }
    }
 }
--- a/src/SharpCompress/Archives/IArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IArchiveExtensions.cs
@@ -1,6 +1,4 @@
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;

 namespace SharpCompress.Archives
@@ -10,14 +8,12 @@ namespace SharpCompress.Archives
        /// <summary>
        /// Extract to specific directory, retaining filename
        /// </summary>
-        public static async ValueTask WriteToDirectoryAsync(this IArchive archive, 
-                                            string destinationDirectory,
-                                            ExtractionOptions? options = null,
-                                            CancellationToken cancellationToken = default)
+        public static void WriteToDirectory(this IArchive archive, string destinationDirectory,
+                                            ExtractionOptions? options = null)
        {
-            await foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory).WithCancellation(cancellationToken))
+            foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory))
            {
-                await entry.WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken);
+                entry.WriteToDirectory(destinationDirectory, options);
            }
        }
    }
--- a/src/SharpCompress/Archives/IArchiveExtractionListener.cs
+++ b/src/SharpCompress/Archives/IArchiveExtractionListener.cs
@@ -0,0 +1,11 @@
+using SharpCompress.Common;
+
+namespace SharpCompress.Archives
+{
+    internal interface IArchiveExtractionListener : IExtractionListener
+    {
+        void EnsureEntriesLoaded();
+        void FireEntryExtractionBegin(IArchiveEntry entry);
+        void FireEntryExtractionEnd(IArchiveEntry entry);
+    }
+}
--- a/src/SharpCompress/Archives/IWritableArchive.cs
+++ b/src/SharpCompress/Archives/IWritableArchive.cs
@@ -1,23 +1,21 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Writers;

 namespace SharpCompress.Archives
 {
    public interface IWritableArchive : IArchive
    {
-        ValueTask RemoveEntryAsync(IArchiveEntry entry, CancellationToken cancellationToken = default);
+        void RemoveEntry(IArchiveEntry entry);

-        ValueTask<IArchiveEntry> AddEntryAsync(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null, CancellationToken cancellationToken = default);
+        IArchiveEntry AddEntry(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null);

-        ValueTask SaveToAsync(Stream stream, WriterOptions options, CancellationToken cancellationToken = default);
+        void SaveTo(Stream stream, WriterOptions options);

        /// <summary>
        /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
        /// </summary>
        /// <returns>IDisposeable to resume entry rebuilding</returns>
-        IAsyncDisposable PauseEntryRebuilding();
+        IDisposable PauseEntryRebuilding();
    }
 }
--- a/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
@@ -1,62 +1,57 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Writers;

 namespace SharpCompress.Archives
 {
    public static class IWritableArchiveExtensions
    {
-        public static async ValueTask AddEntryAsync(this IWritableArchive writableArchive,
-                                         string entryPath, string filePath, 
-                                         CancellationToken cancellationToken = default)
+        public static void AddEntry(this IWritableArchive writableArchive,
+                                                     string entryPath, string filePath)
        {
            var fileInfo = new FileInfo(filePath);
            if (!fileInfo.Exists)
            {
                throw new FileNotFoundException("Could not AddEntry: " + filePath);
            }
-            await writableArchive.AddEntryAsync(entryPath, new FileInfo(filePath).OpenRead(), true, fileInfo.Length,
-                                     fileInfo.LastWriteTime, cancellationToken);
+            writableArchive.AddEntry(entryPath, new FileInfo(filePath).OpenRead(), true, fileInfo.Length,
+                                     fileInfo.LastWriteTime);
        }

-        public static Task SaveToAsync(this IWritableArchive writableArchive, string filePath, WriterOptions options, CancellationToken cancellationToken = default)
+        public static void SaveTo(this IWritableArchive writableArchive, string filePath, WriterOptions options)
        {
-            return writableArchive.SaveToAsync(new FileInfo(filePath), options, cancellationToken);
+            writableArchive.SaveTo(new FileInfo(filePath), options);
        }

-        public static async Task SaveToAsync(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options, CancellationToken cancellationToken = default)
+        public static void SaveTo(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options)
        {
-            await using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-            await writableArchive.SaveToAsync(stream, options, cancellationToken);
+            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
+            {
+                writableArchive.SaveTo(stream, options);
+            }
        }

-        public static async ValueTask AddAllFromDirectoryAsync(
+        public static void AddAllFromDirectory(
            this IWritableArchive writableArchive,
-            string filePath, string searchPattern = "*.*", 
-            SearchOption searchOption = SearchOption.AllDirectories,
-            CancellationToken cancellationToken = default)
+            string filePath, string searchPattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories)
        {
-            await using (writableArchive.PauseEntryRebuilding())
+            using (writableArchive.PauseEntryRebuilding())
            {
                foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
                {
                    var fileInfo = new FileInfo(path);
-                    await writableArchive.AddEntryAsync(path.Substring(filePath.Length), fileInfo.OpenRead(), true, fileInfo.Length,
-                                            fileInfo.LastWriteTime,
-                                            cancellationToken);
+                    writableArchive.AddEntry(path.Substring(filePath.Length), fileInfo.OpenRead(), true, fileInfo.Length,
+                                            fileInfo.LastWriteTime);
                }
            }
        }
-        public static ValueTask<IArchiveEntry> AddEntryAsync(this IWritableArchive writableArchive, string key, FileInfo fileInfo,
-                                                  CancellationToken cancellationToken = default)
+        public static IArchiveEntry AddEntry(this IWritableArchive writableArchive, string key, FileInfo fileInfo)
        {
            if (!fileInfo.Exists)
            {
                throw new ArgumentException("FileInfo does not exist.");
            }
-            return writableArchive.AddEntryAsync(key, fileInfo.OpenRead(), true, fileInfo.Length, fileInfo.LastWriteTime, cancellationToken);
+            return writableArchive.AddEntry(key, fileInfo.OpenRead(), true, fileInfo.Length, fileInfo.LastWriteTime);
        }
    }
 }
--- a/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Rar;
@@ -13,8 +13,8 @@ namespace SharpCompress.Archives.Rar
    /// </summary>
    internal class FileInfoRarArchiveVolume : RarVolume
    {
-        internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options)
-            : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options))
+        internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index = 0)
+            : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options), index)
        {
            FileInfo = fileInfo;
            FileParts = GetVolumeFileParts().ToArray().ToReadOnly();
--- a/src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs
+++ b/src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar.Headers;

 namespace SharpCompress.Archives.Rar
@@ -6,7 +6,7 @@ namespace SharpCompress.Archives.Rar
    internal sealed class FileInfoRarFilePart : SeekableFilePart
    {
        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string? password, MarkHeader mh, FileHeader fh, FileInfo fi)
-            : base(mh, fh, volume.Stream, password)
+            : base(mh, fh, volume.Index, volume.Stream, password)
        {
            FileInfo = fi;
        }
--- a/src/SharpCompress/Archives/Rar/RarArchive.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchive.cs
@@ -5,39 +5,26 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Rar;

 namespace SharpCompress.Archives.Rar
 {
-    public class 
+    public class
        RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    {
        internal Lazy<IRarUnpack> UnpackV2017 { get; } = new Lazy<IRarUnpack>(() => new SharpCompress.Compressors.Rar.UnpackV2017.Unpack());
        internal Lazy<IRarUnpack> UnpackV1 { get; } = new Lazy<IRarUnpack>(() => new SharpCompress.Compressors.Rar.UnpackV1.Unpack());

-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        internal RarArchive(FileInfo fileInfo, ReaderOptions options)
-            : base(ArchiveType.Rar, fileInfo, options)
-        {
-        }
-
-        protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file)
-        {
-            return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
-        }

        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
+        /// Constructor with a SourceStream able to handle FileInfo and Streams.
        /// </summary>
-        /// <param name="streams"></param>
+        /// <param name="srcStream"></param>
        /// <param name="options"></param>
-        internal RarArchive(IEnumerable<Stream> streams, ReaderOptions options)
-            : base(ArchiveType.Rar, streams, options)
+        internal RarArchive(SourceStream srcStream)
+            : base(ArchiveType.Rar, srcStream)
        {
        }

@@ -46,9 +33,21 @@ namespace SharpCompress.Archives.Rar
            return RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
        }

-        protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams)
+        protected override IEnumerable<RarVolume> LoadVolumes(SourceStream srcStream)
        {
-            return RarArchiveVolumeFactory.GetParts(streams, ReaderOptions);
+            base.SrcStream.LoadAllParts(); //request all streams
+            Stream[] streams = base.SrcStream.Streams.ToArray();
+            int idx = 0;
+            if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
+            {
+                base.SrcStream.IsVolumes = true;
+                streams[1].Position = 0;
+                base.SrcStream.Position = 0;
+
+                return srcStream.Streams.Select(a => new StreamRarArchiveVolume(a, ReaderOptions, idx++));
+            }
+            else //split mode or single file
+                return new StreamRarArchiveVolume(base.SrcStream, ReaderOptions, idx++).AsEnumerable();
        }

        protected override IReader CreateReaderForSolidExtraction()
@@ -60,6 +59,9 @@ namespace SharpCompress.Archives.Rar

        public override bool IsSolid => Volumes.First().IsSolidArchive;

+        public virtual int MinVersion => Volumes.First().MinVersion;
+        public virtual int MaxVersion => Volumes.First().MaxVersion;
+
        #region Creation
        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
@@ -69,7 +71,8 @@ namespace SharpCompress.Archives.Rar
        public static RarArchive Open(string filePath, ReaderOptions? options = null)
        {
            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return new RarArchive(new FileInfo(filePath), options ?? new ReaderOptions());
+            FileInfo fileInfo = new FileInfo(filePath);
+            return new RarArchive(new SourceStream(fileInfo, i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo), options ?? new ReaderOptions()));
        }

        /// <summary>
@@ -80,7 +83,7 @@ namespace SharpCompress.Archives.Rar
        public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new RarArchive(fileInfo, options ?? new ReaderOptions());
+            return new RarArchive(new SourceStream(fileInfo, i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo), options ?? new ReaderOptions()));
        }

        /// <summary>
@@ -91,20 +94,34 @@ namespace SharpCompress.Archives.Rar
        public static RarArchive Open(Stream stream, ReaderOptions? options = null)
        {
            stream.CheckNotNull(nameof(stream));
-            return Open(stream.AsEnumerable(), options ?? new ReaderOptions());
+            return new RarArchive(new SourceStream(stream, i => null, options ?? new ReaderOptions()));
        }

        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
+        /// Constructor with all file parts passed in
+        /// </summary>
+        /// <param name="fileInfos"></param>
+        /// <param name="readerOptions"></param>
+        public static RarArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? readerOptions = null)
+        {
+            fileInfos.CheckNotNull(nameof(fileInfos));
+            FileInfo[] files = fileInfos.ToArray();
+            return new RarArchive(new SourceStream(files[0], i => i < files.Length ? files[i] : null, readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all stream parts passed in
        /// </summary>
        /// <param name="streams"></param>
-        /// <param name="options"></param>
-        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
+        /// <param name="readerOptions"></param>
+        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
        {
            streams.CheckNotNull(nameof(streams));
-            return new RarArchive(streams, options ?? new ReaderOptions());
+            Stream[] strms = streams.ToArray();
+            return new RarArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
        }

+
        public static bool IsRarFile(string filePath)
        {
            return IsRarFile(new FileInfo(filePath));
--- a/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
@@ -21,6 +21,7 @@ namespace SharpCompress.Archives.Rar
            this.parts = parts.ToList();
            this.archive = archive;
            this.readerOptions = readerOptions;
+            this.IsSolid = this.FileHeader.IsSolid;
        }

        public override CompressionType CompressionType => CompressionType.Rar;
@@ -85,4 +86,4 @@ namespace SharpCompress.Archives.Rar
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Rar;
@@ -6,135 +6,35 @@ using SharpCompress.Readers;
 using System.Linq;
 using System.Text;
 using SharpCompress.Common.Rar.Headers;
+using System.Text.RegularExpressions;

 namespace SharpCompress.Archives.Rar
 {
    internal static class RarArchiveVolumeFactory
    {
-        internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, ReaderOptions options)
+        internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
        {
-            foreach (Stream s in streams)
-            {
-                if (!s.CanRead || !s.CanSeek)
-                {
-                    throw new ArgumentException("Stream is not readable and seekable");
-                }
-                StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, options);
-                yield return part;
-            }
-        }
+            FileInfo? item = null;

-        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
-        {
-            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
-            yield return part;
-
-            ArchiveHeader ah = part.ArchiveHeader;
-            if (!ah.IsVolume)
-            {
-                yield break; //if file isn't volume then there is no reason to look
-            }
-            fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
-            //we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
-            while (fileInfo != null && fileInfo.Exists)
-            {
-                part = new FileInfoRarArchiveVolume(fileInfo, options);
-
-                fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
-                yield return part;
-            }
-        }
-
-        private static FileInfo? GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart? currentFilePart)
-        {
-            if (currentFilePart is null)
-            {
-                return null;
-            }
-            bool oldNumbering = ah.OldNumberingFormat
-                                || currentFilePart.MarkHeader.OldNumberingFormat;
-            if (oldNumbering)
-            {
-                return FindNextFileWithOldNumbering(currentFilePart.FileInfo);
-            }
+            //new style rar - ..part1 | /part01 | part001 ....
+            Match m = Regex.Match(part1.Name, @"^(.*\.part)([0-9]+)(\.rar)$", RegexOptions.IgnoreCase);
+            if (m.Success)
+                item = new FileInfo(Path.Combine(part1.DirectoryName!, String.Concat(m.Groups[1].Value, (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0'), m.Groups[3].Value)));
            else
            {
-                return FindNextFileWithNewNumbering(currentFilePart.FileInfo);
+                //old style - ...rar, .r00, .r01 ...
+                m = Regex.Match(part1.Name, @"^(.*\.r)(ar|[0-9]+)$", RegexOptions.IgnoreCase);
+                if (m.Success)
+                    item = new FileInfo(Path.Combine(part1.DirectoryName!, String.Concat(m.Groups[1].Value, index == 0 ? "ar" : (index - 1).ToString().PadLeft(m.Groups[2].Value.Length, '0'))));
+                else //split .001, .002 ....
+                    return ArchiveVolumeFactory.GetFilePart(index, part1);
            }
+
+            if (item != null && item.Exists)
+                return item;
+
+            return null; //no more items
        }

-        private static FileInfo FindNextFileWithOldNumbering(FileInfo currentFileInfo)
-        {
-            // .rar, .r00, .r01, ...
-            string extension = currentFileInfo.Extension;
-
-            var buffer = new StringBuilder(currentFileInfo.FullName.Length);
-            buffer.Append(currentFileInfo.FullName.Substring(0,
-                                                             currentFileInfo.FullName.Length - extension.Length));
-            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) == 0)
-            {
-                buffer.Append(".r00");
-            }
-            else
-            {
-                if (int.TryParse(extension.Substring(2, 2), out int num))
-                {
-                    num++;
-                    buffer.Append(".r");
-                    if (num < 10)
-                    {
-                        buffer.Append('0');
-                    }
-                    buffer.Append(num);
-                }
-                else
-                {
-                    ThrowInvalidFileName(currentFileInfo);
-                }
-            }
-            return new FileInfo(buffer.ToString());
-        }
-
-        private static FileInfo FindNextFileWithNewNumbering(FileInfo currentFileInfo)
-        {
-            // part1.rar, part2.rar, ...
-            string extension = currentFileInfo.Extension;
-            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) != 0)
-            {
-                throw new ArgumentException("Invalid extension, expected 'rar': " + currentFileInfo.FullName);
-            }
-            int startIndex = currentFileInfo.FullName.LastIndexOf(".part");
-            if (startIndex < 0)
-            {
-                ThrowInvalidFileName(currentFileInfo);
-            }
-            StringBuilder buffer = new StringBuilder(currentFileInfo.FullName.Length);
-            buffer.Append(currentFileInfo.FullName, 0, startIndex);
-            string numString = currentFileInfo.FullName.Substring(startIndex + 5,
-                                                                  currentFileInfo.FullName.IndexOf('.', startIndex + 5) -
-                                                                  startIndex - 5);
-            buffer.Append(".part");
-            if (int.TryParse(numString, out int num))
-            {
-                num++;
-                for (int i = 0; i < numString.Length - num.ToString().Length; i++)
-                {
-                    buffer.Append('0');
-                }
-                buffer.Append(num);
-            }
-            else
-            {
-                ThrowInvalidFileName(currentFileInfo);
-            }
-            buffer.Append(".rar");
-            return new FileInfo(buffer.ToString());
-        }
-
-        private static void ThrowInvalidFileName(FileInfo fileInfo)
-        {
-            throw new ArgumentException("Filename invalid or next archive could not be found:"
-                                        + fileInfo.FullName);
-        }
    }
-}
+}
--- a/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
+++ b/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;

@@ -9,8 +9,8 @@ namespace SharpCompress.Archives.Rar
        private readonly Stream stream;
        private readonly string? password;

-        internal SeekableFilePart(MarkHeader mh, FileHeader fh, Stream stream, string? password)
-            : base(mh, fh)
+        internal SeekableFilePart(MarkHeader mh, FileHeader fh, int index, Stream stream, string? password)
+            : base(mh, fh, index)
        {
            this.stream = stream;
            this.password = password;
@@ -28,4 +28,4 @@ namespace SharpCompress.Archives.Rar

        internal override string FilePartName => "Unknown Stream - File Entry: " + FileHeader.FileName;
    }
-}
+}
--- a/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
@@ -9,8 +9,8 @@ namespace SharpCompress.Archives.Rar
 {
    internal class StreamRarArchiveVolume : RarVolume
    {
-        internal StreamRarArchiveVolume(Stream stream, ReaderOptions options)
-            : base(StreamingMode.Seekable, stream, options)
+        internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index = 0)
+            : base(StreamingMode.Seekable, stream, options, index)
        {
        }

@@ -21,7 +21,7 @@ namespace SharpCompress.Archives.Rar

        internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader)
        {
-            return new SeekableFilePart(markHeader, fileHeader, Stream, ReaderOptions.Password);
+            return new SeekableFilePart(markHeader, fileHeader, this.Index, Stream, ReaderOptions.Password);
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
+++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable

 using System;
 using System.Collections.Generic;
@@ -34,8 +34,33 @@ namespace SharpCompress.Archives.SevenZip
        public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
        {
            fileInfo.CheckNotNull("fileInfo");
-            return new SevenZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
+            return new SevenZipArchive(new SourceStream(fileInfo, i => ArchiveVolumeFactory.GetFilePart(i, fileInfo), readerOptions ?? new ReaderOptions()));
        }
+
+        /// <summary>
+        /// Constructor with all file parts passed in
+        /// </summary>
+        /// <param name="fileInfos"></param>
+        /// <param name="readerOptions"></param>
+        public static SevenZipArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions readerOptions = null)
+        {
+            fileInfos.CheckNotNull(nameof(fileInfos));
+            FileInfo[] files = fileInfos.ToArray();
+            return new SevenZipArchive(new SourceStream(files[0], i => i < files.Length ? files[i] : null, readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all stream parts passed in
+        /// </summary>
+        /// <param name="streams"></param>
+        /// <param name="readerOptions"></param>
+        public static SevenZipArchive Open(IEnumerable<Stream> streams, ReaderOptions readerOptions = null)
+        {
+            streams.CheckNotNull(nameof(streams));
+            Stream[] strms = streams.ToArray();
+            return new SevenZipArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
+        }
+
        /// <summary>
        /// Takes a seekable Stream as a source
        /// </summary>
@@ -44,17 +69,24 @@ namespace SharpCompress.Archives.SevenZip
        public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
            stream.CheckNotNull("stream");
-            return new SevenZipArchive(stream, readerOptions ?? new ReaderOptions());
+            return new SevenZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
        }

-        internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
-            : base(ArchiveType.SevenZip, fileInfo, readerOptions)
+        /// <summary>
+        /// Constructor with a SourceStream able to handle FileInfo and Streams.
+        /// </summary>
+        /// <param name="srcStream"></param>
+        /// <param name="options"></param>
+        internal SevenZipArchive(SourceStream srcStream)
+            : base(ArchiveType.SevenZip, srcStream)
        {
        }

-        protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file)
+        protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream srcStream)
        {
-            return new SevenZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
+            base.SrcStream.LoadAllParts(); //request all streams
+            int idx = 0;
+            return new SevenZipVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
        }

        public static bool IsSevenZipFile(string filePath)
@@ -74,38 +106,32 @@ namespace SharpCompress.Archives.SevenZip
            }
        }

-        internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
-            : base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
-        {
-        }
-
        internal SevenZipArchive()
            : base(ArchiveType.SevenZip)
        {
        }

-        protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            foreach (Stream s in streams)
-            {
-                if (!s.CanRead || !s.CanSeek)
-                {
-                    throw new ArgumentException("Stream is not readable and seekable");
-                }
-                SevenZipVolume volume = new SevenZipVolume(s, ReaderOptions);
-                yield return volume;
-            }
-        }
-
        protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(IEnumerable<SevenZipVolume> volumes)
        {
            var stream = volumes.Single().Stream;
            LoadFactory(stream);
+            var entries = new SevenZipArchiveEntry[database._files.Count];
            for (int i = 0; i < database._files.Count; i++)
            {
                var file = database._files[i];
-                yield return new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file, ReaderOptions.ArchiveEncoding));
+                entries[i] = new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file, ReaderOptions.ArchiveEncoding));
            }
+            foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+            {
+                var isSolid = false;
+                foreach (var entry in group)
+                {
+                    entry.IsSolid = isSolid;
+                    isSolid = true; //mark others in this group as solid - same as rar behaviour.
+                }
+            }
+
+            return entries;
        }

        private void LoadFactory(Stream stream)
--- a/src/SharpCompress/Archives/Tar/TarArchive.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchive.cs
@@ -1,10 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
@@ -34,11 +31,34 @@ namespace SharpCompress.Archives.Tar
        /// </summary>
        /// <param name="fileInfo"></param>
        /// <param name="readerOptions"></param>
-        public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null,
-                                      CancellationToken cancellationToken = default)
+        public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions(), cancellationToken);
+            return new TarArchive(new SourceStream(fileInfo, i => ArchiveVolumeFactory.GetFilePart(i, fileInfo), readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all file parts passed in
+        /// </summary>
+        /// <param name="fileInfos"></param>
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? readerOptions = null)
+        {
+            fileInfos.CheckNotNull(nameof(fileInfos));
+            FileInfo[] files = fileInfos.ToArray();
+            return new TarArchive(new SourceStream(files[0], i => i < files.Length ? files[i] : null, readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all stream parts passed in
+        /// </summary>
+        /// <param name="streams"></param>
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+        {
+            streams.CheckNotNull(nameof(streams));
+            Stream[] strms = streams.ToArray();
+            return new TarArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
        }

        /// <summary>
@@ -46,35 +66,35 @@ namespace SharpCompress.Archives.Tar
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="readerOptions"></param>
-        public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null,
-                    CancellationToken cancellationToken = default)
+        public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
-            return new TarArchive(stream, readerOptions ?? new ReaderOptions(), cancellationToken);
+            return new TarArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
        }

-        public static ValueTask<bool> IsTarFileAsync(string filePath, CancellationToken cancellationToken = default)
+        public static bool IsTarFile(string filePath)
        {
-            return IsTarFileAsync(new FileInfo(filePath), cancellationToken);
+            return IsTarFile(new FileInfo(filePath));
        }

-        public static async ValueTask<bool> IsTarFileAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+        public static bool IsTarFile(FileInfo fileInfo)
        {
            if (!fileInfo.Exists)
            {
                return false;
            }
-
-            await using Stream stream = fileInfo.OpenRead();
-            return await IsTarFileAsync(stream, cancellationToken);
+            using (Stream stream = fileInfo.OpenRead())
+            {
+                return IsTarFile(stream);
+            }
        }

-        public static async ValueTask<bool> IsTarFileAsync(Stream stream, CancellationToken cancellationToken = default)
+        public static bool IsTarFile(Stream stream)
        {
            try
            {
-                TarHeader tarHeader = new(new ArchiveEncoding());
-                bool readSucceeded = await tarHeader.Read(stream, cancellationToken);
+                TarHeader tarHeader = new TarHeader(new ArchiveEncoding());
+                bool readSucceeded = tarHeader.Read(new BinaryReader(stream));
                bool isEmptyArchive = tarHeader.Name.Length == 0 && tarHeader.Size == 0 && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
                return readSucceeded || isEmptyArchive;
            }
@@ -84,30 +104,20 @@ namespace SharpCompress.Archives.Tar
            return false;
        }

-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        internal TarArchive(FileInfo fileInfo, ReaderOptions readerOptions,
-                            CancellationToken cancellationToken)
-            : base(ArchiveType.Tar, fileInfo, readerOptions, cancellationToken)
+        protected override IEnumerable<TarVolume> LoadVolumes(SourceStream srcStream)
        {
-        }
-
-        protected override IAsyncEnumerable<TarVolume> LoadVolumes(FileInfo file, CancellationToken cancellationToken)
-        {
-            return new TarVolume(file.OpenRead(), ReaderOptions).AsAsyncEnumerable();
+            base.SrcStream.LoadAllParts(); //request all streams
+            int idx = 0;
+            return new TarVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
        }

        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
+        /// Constructor with a SourceStream able to handle FileInfo and Streams.
        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        internal TarArchive(Stream stream, ReaderOptions readerOptions,
-                            CancellationToken cancellationToken)
-            : base(ArchiveType.Tar, stream, readerOptions, cancellationToken)
+        /// <param name="srcStream"></param>
+        /// <param name="options"></param>
+        internal TarArchive(SourceStream srcStream)
+            : base(ArchiveType.Tar, srcStream)
        {
        }

@@ -116,18 +126,11 @@ namespace SharpCompress.Archives.Tar
        {
        }

-        protected override async IAsyncEnumerable<TarVolume> LoadVolumes(IAsyncEnumerable<Stream> streams, 
-                                                                         [EnumeratorCancellation]CancellationToken cancellationToken)
+        protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
        {
-            yield return new TarVolume(await streams.FirstAsync(cancellationToken: cancellationToken), ReaderOptions);
-        }
-
-        protected override async IAsyncEnumerable<TarArchiveEntry> LoadEntries(IAsyncEnumerable<TarVolume> volumes, 
-                                                                               [EnumeratorCancellation]CancellationToken cancellationToken)
-        {
-            Stream stream = (await volumes.SingleAsync(cancellationToken: cancellationToken)).Stream;
+            Stream stream = volumes.Single().Stream;
            TarHeader? previousHeader = null;
-            await foreach (TarHeader? header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding, cancellationToken))
+            foreach (TarHeader? header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding))
            {
                if (header != null)
                {
@@ -144,11 +147,11 @@ namespace SharpCompress.Archives.Tar

                            var oldStreamPos = stream.Position;

-                            await using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+                            using (var entryStream = entry.OpenEntryStream())
                            {
-                                await using (var memoryStream = new MemoryStream())
+                                using (var memoryStream = new MemoryStream())
                                {
-                                    await entryStream.TransferToAsync(memoryStream, cancellationToken);
+                                    entryStream.TransferTo(memoryStream);
                                    memoryStream.Position = 0;
                                    var bytes = memoryStream.ToArray();

@@ -168,37 +171,38 @@ namespace SharpCompress.Archives.Tar

        public static TarArchive Create()
        {
-            return new();
+            return new TarArchive();
        }

-        protected override ValueTask<TarArchiveEntry> CreateEntryInternal(string filePath, Stream source,
-                                                               long size, DateTime? modified, bool closeStream,
-                                                               CancellationToken cancellationToken)
+        protected override TarArchiveEntry CreateEntryInternal(string filePath, Stream source,
+                                                               long size, DateTime? modified, bool closeStream)
        {
-            return new (new TarWritableArchiveEntry(this, source, CompressionType.Unknown, filePath, size, modified,
-                                               closeStream));
+            return new TarWritableArchiveEntry(this, source, CompressionType.Unknown, filePath, size, modified,
+                                               closeStream);
        }

-        protected override async ValueTask SaveToAsync(Stream stream, WriterOptions options,
-                                                       IAsyncEnumerable<TarArchiveEntry> oldEntries,
-                                                       IAsyncEnumerable<TarArchiveEntry> newEntries,
-                                                       CancellationToken cancellationToken = default)
+        protected override void SaveTo(Stream stream, WriterOptions options,
+                                       IEnumerable<TarArchiveEntry> oldEntries,
+                                       IEnumerable<TarArchiveEntry> newEntries)
        {
-            await using var writer = await TarWriter.CreateAsync(stream, new TarWriterOptions(options), cancellationToken);
-            await foreach (var entry in oldEntries.Concat(newEntries)
-                                                  .Where(x => !x.IsDirectory)
-                                                  .WithCancellation(cancellationToken))
+            using (var writer = new TarWriter(stream, new TarWriterOptions(options)))
            {
-                await using var entryStream = await entry.OpenEntryStreamAsync(cancellationToken);
-                await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, entry.Size, cancellationToken);
+                foreach (var entry in oldEntries.Concat(newEntries)
+                                                .Where(x => !x.IsDirectory))
+                {
+                    using (var entryStream = entry.OpenEntryStream())
+                    {
+                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
+                    }
+                }
            }
        }

-        protected override async ValueTask<IReader> CreateReaderForSolidExtraction()
+        protected override IReader CreateReaderForSolidExtraction()
        {
-            var stream = (await Volumes.SingleAsync()).Stream;
+            var stream = Volumes.Single().Stream;
            stream.Position = 0;
-            return await TarReader.OpenAsync(stream);
+            return TarReader.Open(stream);
        }
    }
 }
--- a/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;

@@ -15,9 +13,9 @@ namespace SharpCompress.Archives.Tar
            Archive = archive;
        }

-        public virtual async ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        public virtual Stream OpenEntryStream()
        {
-            return await Parts.Single().GetCompressedStreamAsync(cancellationToken);
+            return Parts.Single().GetCompressedStream();
        }

        #region IArchiveEntry Members
--- a/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
@@ -1,10 +1,8 @@
-#nullable disable
+#nullable disable

 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

@@ -51,19 +49,19 @@ namespace SharpCompress.Archives.Tar
        internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
        Stream IWritableArchiveEntry.Stream => stream;

-        public override ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        public override Stream OpenEntryStream()
        {
            //ensure new stream is at the start, this could be reset
            stream.Seek(0, SeekOrigin.Begin);
-            return new(new NonDisposingStream(stream));
+            return NonDisposingStream.Create(stream);
        }

-        internal override async ValueTask CloseAsync()
+        internal override void Close()
        {
            if (closeStream)
            {
-                await stream.DisposeAsync();
+                stream.Dispose();
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/Zip/ZipArchive.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchive.cs
@@ -1,10 +1,7 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
@@ -29,6 +26,17 @@ namespace SharpCompress.Archives.Zip
        /// </summary>
        public CompressionLevel DeflateCompressionLevel { get; set; }

+        /// <summary>
+        /// Constructor with a SourceStream able to handle FileInfo and Streams.
+        /// </summary>
+        /// <param name="srcStream"></param>
+        /// <param name="options"></param>
+        internal ZipArchive(SourceStream srcStream)
+            : base(ArchiveType.Zip, srcStream)
+        {
+            headerFactory = new SeekableZipHeaderFactory(srcStream.ReaderOptions.Password, srcStream.ReaderOptions.ArchiveEncoding);
+        }
+
        /// <summary>
        /// Constructor expects a filepath to an existing file.
        /// </summary>
@@ -45,11 +53,34 @@ namespace SharpCompress.Archives.Zip
        /// </summary>
        /// <param name="fileInfo"></param>
        /// <param name="readerOptions"></param>
-        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null,
-                                      CancellationToken cancellationToken = default)
+        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions(), cancellationToken);
+            return new ZipArchive(new SourceStream(fileInfo, i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo), readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all file parts passed in
+        /// </summary>
+        /// <param name="fileInfos"></param>
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? readerOptions = null)
+        {
+            fileInfos.CheckNotNull(nameof(fileInfos));
+            FileInfo[] files = fileInfos.ToArray();
+            return new ZipArchive(new SourceStream(files[0], i => i < files.Length ? files[i] : null, readerOptions ?? new ReaderOptions()));
+        }
+
+        /// <summary>
+        /// Constructor with all stream parts passed in
+        /// </summary>
+        /// <param name="streams"></param>
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+        {
+            streams.CheckNotNull(nameof(streams));
+            Stream[] strms = streams.ToArray();
+            return new ZipArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
        }

        /// <summary>
@@ -57,45 +88,35 @@ namespace SharpCompress.Archives.Zip
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="readerOptions"></param>
-        public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null,
-                                      CancellationToken cancellationToken = default)
+        public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
-            return new ZipArchive(stream, readerOptions ?? new ReaderOptions(), cancellationToken);
+            return new ZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
        }

-        public static ValueTask<bool> IsZipFile(string filePath, string? password = null)
+        public static bool IsZipFile(string filePath, string? password = null)
        {
-            return IsZipFileAsync(new FileInfo(filePath), password);
+            return IsZipFile(new FileInfo(filePath), password);
        }

-        public static async ValueTask<bool> IsZipFileAsync(FileInfo fileInfo, string? password = null)
+        public static bool IsZipFile(FileInfo fileInfo, string? password = null)
        {
            if (!fileInfo.Exists)
            {
                return false;
            }
-
-            await using Stream stream = fileInfo.OpenRead();
-            return await IsZipFileAsync(stream, password);
+            using (Stream stream = fileInfo.OpenRead())
+            {
+                return IsZipFile(stream, password);
+            }
        }

-        public static async ValueTask<bool> IsZipFileAsync(Stream stream, string? password = null, CancellationToken cancellationToken = default)
+        public static bool IsZipFile(Stream stream, string? password = null)
        {
-            StreamingZipHeaderFactory headerFactory = new(password, new ArchiveEncoding());
+            StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
            try
            {
-                RewindableStream rewindableStream;
-                if (stream is RewindableStream rs)
-                {
-                    rewindableStream = rs;
-                }
-                else
-                {
-                    rewindableStream = new RewindableStream(stream);
-                }
-                ZipHeader? header = await headerFactory.ReadStreamHeader(rewindableStream, cancellationToken)
-                                                       .FirstOrDefaultAsync(x => x.ZipHeaderType != ZipHeaderType.Split, cancellationToken: cancellationToken);
+                ZipHeader? header = headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
                if (header is null)
                {
                    return false;
@@ -112,22 +133,62 @@ namespace SharpCompress.Archives.Zip
            }
        }

-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        internal ZipArchive(FileInfo fileInfo, ReaderOptions readerOptions,
-                            CancellationToken cancellationToken)
-            : base(ArchiveType.Zip, fileInfo, readerOptions, cancellationToken)
+        public static bool IsZipMulti(Stream stream, string? password = null)
        {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
+            StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
+            try
+            {
+                ZipHeader? header = headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+                if (header is null)
+                {
+                    if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
+                    {
+                        SeekableZipHeaderFactory z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                        var x = z.ReadSeekableHeader(stream).FirstOrDefault();
+                        return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                    }
+                    else
+                        return false;
+                }
+                return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+            }
+            catch (CryptographicException)
+            {
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
        }

-        protected override IAsyncEnumerable<ZipVolume> LoadVolumes(FileInfo file,
-                                                                   CancellationToken cancellationToken)
+        protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream srcStream)
        {
-            return new ZipVolume(file.OpenRead(), ReaderOptions).AsAsyncEnumerable();
+            base.SrcStream.LoadAllParts(); //request all streams
+            base.SrcStream.Position = 0;
+
+            List<Stream> streams = base.SrcStream.Streams.ToList();
+            int idx = 0;
+            if (streams.Count > 1) //test part 2 - true = multipart not split
+            {
+                streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
+                bool isZip = IsZipFile(streams[1], ReaderOptions.Password);
+                streams[1].Position -= 4;
+                if (isZip)
+                {
+                    base.SrcStream.IsVolumes = true;
+
+                    var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
+                    streams.RemoveAt(0);
+                    streams.Add(tmp);
+
+                    //streams[0].Position = 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
+                    return streams.Select(a => new ZipVolume(a, ReaderOptions, idx++));
+                }
+            }
+
+            //split mode or single file
+            return new ZipVolume(base.SrcStream, ReaderOptions, idx++).AsEnumerable();
        }

        internal ZipArchive()
@@ -135,31 +196,10 @@ namespace SharpCompress.Archives.Zip
        {
        }

-        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        internal ZipArchive(Stream stream, ReaderOptions readerOptions,
-                            CancellationToken cancellationToken)
-            : base(ArchiveType.Zip, stream, readerOptions, cancellationToken)
+        protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
        {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
-        }
-
-        protected override async IAsyncEnumerable<ZipVolume> LoadVolumes(IAsyncEnumerable<Stream> streams,
-                                                                         [EnumeratorCancellation]CancellationToken cancellationToken)
-        {
-            yield return new ZipVolume(await streams.FirstAsync(cancellationToken: cancellationToken), ReaderOptions);
-        }
-
-        protected override async IAsyncEnumerable<ZipArchiveEntry> LoadEntries(IAsyncEnumerable<ZipVolume> volumes,
-                                                                               [EnumeratorCancellation]CancellationToken cancellationToken)
-        {
-            await Task.CompletedTask;
-            var volume = await volumes.SingleAsync(cancellationToken: cancellationToken);
-            Stream stream = volume.Stream;
-            await foreach (ZipHeader h in headerFactory.ReadSeekableHeader(stream, cancellationToken))
+            var vols = volumes.ToArray();
+            foreach (ZipHeader h in headerFactory.ReadSeekableHeader(vols.Last().Stream))
            {
                if (h != null)
                {
@@ -167,16 +207,22 @@ namespace SharpCompress.Archives.Zip
                    {
                        case ZipHeaderType.DirectoryEntry:
                        {
-                            yield return new ZipArchiveEntry(this,
-                                                             new SeekableZipFilePart(headerFactory,
-                                                                                     (DirectoryEntryHeader)h,
-                                                                                     stream));
+                            DirectoryEntryHeader deh = (DirectoryEntryHeader)h;
+                            Stream s;
+                            if (deh.RelativeOffsetOfEntryHeader + deh.CompressedSize > vols[deh.DiskNumberStart].Stream.Length)
+                            {
+                                var v = vols.Skip(deh.DiskNumberStart).ToArray();
+                                s = new SourceStream(v[0].Stream, i => i < v.Length ? v[i].Stream : null, new ReaderOptions() { LeaveStreamOpen = true });
+                            }
+                            else
+                                s = vols[deh.DiskNumberStart].Stream;
+                            yield return new ZipArchiveEntry(this, new SeekableZipFilePart(headerFactory, deh, s));
                        }
-                            break;
+                        break;
                        case ZipHeaderType.DirectoryEnd:
                        {
                            byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                            volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                            volumes.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
                            yield break;
                        }
                    }
@@ -184,42 +230,42 @@ namespace SharpCompress.Archives.Zip
            }
        }

-        public ValueTask SaveToAsync(Stream stream, CancellationToken cancellationToken = default)
+        public void SaveTo(Stream stream)
        {
-            return SaveToAsync(stream, new WriterOptions(CompressionType.Deflate), cancellationToken);
+            SaveTo(stream, new WriterOptions(CompressionType.Deflate));
        }

-        protected override async ValueTask SaveToAsync(Stream stream, WriterOptions options, 
-                                                       IAsyncEnumerable<ZipArchiveEntry> oldEntries, 
-                                                       IAsyncEnumerable<ZipArchiveEntry> newEntries, 
-                                                       CancellationToken cancellationToken = default)
+        protected override void SaveTo(Stream stream, WriterOptions options,
+                                       IEnumerable<ZipArchiveEntry> oldEntries,
+                                       IEnumerable<ZipArchiveEntry> newEntries)
        {
-            await using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-            await foreach (var entry in oldEntries.Concat(newEntries)
-                                                  .Where(x => !x.IsDirectory)
-                                                  .WithCancellation(cancellationToken))
+            using (var writer = new ZipWriter(stream, new ZipWriterOptions(options)))
            {
-                await using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+                foreach (var entry in oldEntries.Concat(newEntries)
+                                                .Where(x => !x.IsDirectory))
                {
-                    await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, cancellationToken);
+                    using (var entryStream = entry.OpenEntryStream())
+                    {
+                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+                    }
                }
            }
        }

-        protected override ValueTask<ZipArchiveEntry> CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                               bool closeStream, CancellationToken cancellationToken = default)
+        protected override ZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
+                                                               bool closeStream)
        {
-            return new(new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream));
+            return new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
        }

        public static ZipArchive Create()
        {
-            return new();
+            return new ZipArchive();
        }

-        protected override async ValueTask<IReader> CreateReaderForSolidExtraction()
+        protected override IReader CreateReaderForSolidExtraction()
        {
-            var stream = (await Volumes.SingleAsync()).Stream;
+            var stream = Volumes.Single().Stream;
            stream.Position = 0;
            return ZipReader.Open(stream, ReaderOptions);
        }
--- a/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip;

 namespace SharpCompress.Archives.Zip
@@ -14,9 +12,9 @@ namespace SharpCompress.Archives.Zip
            Archive = archive;
        }

-        public virtual ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        public virtual Stream OpenEntryStream()
        {
-            return Parts.Single().GetCompressedStreamAsync(cancellationToken);
+            return Parts.Single().GetCompressedStream();
        }

        #region IArchiveEntry Members
--- a/src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Common.Rar;
+using SharpCompress.Readers;
+using System.Linq;
+using System.Text;
+using SharpCompress.Common.Rar.Headers;
+using System.Text.RegularExpressions;
+
+namespace SharpCompress.Archives.Zip
+{
+    internal static class ZipArchiveVolumeFactory
+    {
+        internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
+        {
+            FileInfo? item = null;
+
+            //load files with zip/zipx first. Swapped to end once loaded in ZipArchive
+            //new style .zip, z01.. | .zipx, zx01 - if the numbers go beyond 99 then they use 100 ...1000 etc
+            Match m = Regex.Match(part1.Name, @"^(.*\.)(zipx?|zx?[0-9]+)$", RegexOptions.IgnoreCase);
+            if (m.Success)
+                item = new FileInfo(Path.Combine(part1.DirectoryName!, String.Concat(m.Groups[1].Value, Regex.Replace(m.Groups[2].Value, @"[^xz]", ""), index.ToString().PadLeft(2, '0'))));
+            else //split - 001, 002 ...
+                return ArchiveVolumeFactory.GetFilePart(index, part1);
+
+            if (item != null && item.Exists)
+                return item;
+
+            return null; //no more items
+        }
+
+    }
+}
--- a/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
@@ -1,8 +1,6 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

@@ -51,20 +49,20 @@ namespace SharpCompress.Archives.Zip

        Stream IWritableArchiveEntry.Stream => stream;

-        public override ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        public override Stream OpenEntryStream()
        {
            //ensure new stream is at the start, this could be reset
            stream.Seek(0, SeekOrigin.Begin);
-            return new(new NonDisposingStream(stream));
+            return NonDisposingStream.Create(stream);
        }

-        internal override async ValueTask CloseAsync()
+        internal override void Close()
        {
            if (closeStream && !isDisposed)
            {
-                await stream.DisposeAsync();
+                stream.Dispose();
                isDisposed = true;
            }
        }
    }
-}
+}
--- a/src/SharpCompress/AsyncEnumerable.cs
+++ b/src/SharpCompress/AsyncEnumerable.cs
@@ -1,25 +0,0 @@
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace SharpCompress
-{
-    public static class AsyncEnumerable
-    {
-        public static IAsyncEnumerable<T> Empty<T>() => EmptyAsyncEnumerable<T>.Instance;
-        
-
-        private class EmptyAsyncEnumerable<T> : IAsyncEnumerator<T>, IAsyncEnumerable<T>
-        {
-            public static readonly EmptyAsyncEnumerable<T> Instance = 
-                new();
-            public T Current => default!;
-            public ValueTask DisposeAsync() => default;
-            public ValueTask<bool> MoveNextAsync() => new(false);
-            public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = new CancellationToken())
-            {
-                return this;
-            }
-        }
-    }
-}
--- a/src/SharpCompress/Common/ArchiveEncoding.cs
+++ b/src/SharpCompress/Common/ArchiveEncoding.cs
@@ -24,7 +24,7 @@ namespace SharpCompress.Common
        /// Set this when you want to use a custom method for all decoding operations.
        /// </summary>
        /// <returns>string Func(bytes, index, length)</returns>
-        //public Func<byte[], int, int, string>? CustomDecoder { get; set; }
+        public Func<byte[], int, int, string>? CustomDecoder { get; set; }

        public ArchiveEncoding()
        : this(Encoding.Default, Encoding.Default)
@@ -36,7 +36,7 @@ namespace SharpCompress.Common
            Password = password;
        }

-#if !NET461
+#if !NETFRAMEWORK
        static ArchiveEncoding()
        {
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
@@ -50,12 +50,7 @@ namespace SharpCompress.Common

        public string Decode(byte[] bytes, int start, int length)
        {
-            return GetEncoding().GetString(bytes, start, length);
-        }
-        
-        public string Decode(ReadOnlySpan<byte> span)
-        {
-            return GetEncoding().GetString(span);
+            return GetDecoder().Invoke(bytes, start, length);
        }

        public string DecodeUTF8(byte[] bytes)
@@ -72,5 +67,10 @@ namespace SharpCompress.Common
        {
            return Forced ?? Default ?? Encoding.UTF8;
        }
+
+        public Func<byte[], int, int, string> GetDecoder()
+        {
+            return CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
+        }
    }
 }
--- a/src/SharpCompress/Common/Entry.cs
+++ b/src/SharpCompress/Common/Entry.cs
@@ -1,6 +1,6 @@
-using System;
+using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
+using System.Linq;

 namespace SharpCompress.Common
 {
@@ -71,16 +71,17 @@ namespace SharpCompress.Common
        /// </summary>
        public abstract bool IsSplitAfter { get; }

+        public int VolumeIndexFirst => this.Parts?.FirstOrDefault()?.Index ?? 0;
+        public int VolumeIndexLast => this.Parts?.LastOrDefault()?.Index ?? 0;
        /// <inheritdoc/>
        public override string ToString() => Key;

        internal abstract IEnumerable<FilePart> Parts { get; }

-        internal bool IsSolid { get; set; }
+        public bool IsSolid { get; set; }

-        internal virtual ValueTask CloseAsync()
+        internal virtual void Close()
        {
-            return new ();
        }

        /// <summary>
--- a/src/SharpCompress/Common/EntryStream.cs
+++ b/src/SharpCompress/Common/EntryStream.cs
@@ -1,13 +1,10 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Common
 {
-    public class EntryStream : AsyncStream
+    public class EntryStream : Stream
    {
        private readonly IReader _reader;
        private readonly Stream _stream;
@@ -23,24 +20,25 @@ namespace SharpCompress.Common
        /// <summary>
        /// When reading a stream from OpenEntryStream, the stream must be completed so use this to finish reading the entire entry.
        /// </summary>
-        public async ValueTask SkipEntryAsync(CancellationToken cancellationToken = default)
+        public void SkipEntry()
        {
-            await this.SkipAsync(cancellationToken);
+            this.Skip();
            _completed = true;
        }

-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
        {
            if (!(_completed || _reader.Cancelled))
            {
-                await SkipEntryAsync();
+                SkipEntry();
            }
            if (_isDisposed)
            {
                return;
            }
            _isDisposed = true;
-            await _stream.DisposeAsync();
+            base.Dispose(disposing);
+            _stream.Dispose();
        }

        public override bool CanRead => true;
@@ -48,13 +46,18 @@ namespace SharpCompress.Common
        public override bool CanSeek => false;

        public override bool CanWrite => false;
+
+        public override void Flush()
+        {
+        }
+
        public override long Length => _stream.Length;

        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }

-        public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        public override int Read(byte[] buffer, int offset, int count)
        {
-            int read = await _stream.ReadAsync(buffer, cancellationToken);
+            int read = _stream.Read(buffer, offset, count);
            if (read <= 0)
            {
                _completed = true;
@@ -62,14 +65,14 @@ namespace SharpCompress.Common
            return read;
        }

-        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        public override int ReadByte()
        {
-            throw new NotSupportedException();
-        }
-
-        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
-        {
-            throw new NotSupportedException();
+            int value = _stream.ReadByte();
+            if (value == -1)
+            {
+                _completed = true;
+            }
+            return value;
        }

        public override long Seek(long offset, SeekOrigin origin)
@@ -81,5 +84,10 @@ namespace SharpCompress.Common
        {
            throw new NotSupportedException();
        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
    }
 }
--- a/src/SharpCompress/Common/ExtractionMethods.cs
+++ b/src/SharpCompress/Common/ExtractionMethods.cs
@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common
 {
@@ -10,21 +8,31 @@ namespace SharpCompress.Common
        /// <summary>
        /// Extract to specific directory, retaining filename
        /// </summary>
-        public static async ValueTask WriteEntryToDirectoryAsync(IEntry entry,
+        public static void WriteEntryToDirectory(IEntry entry,
                                                 string destinationDirectory,
                                                 ExtractionOptions? options,
-                                                 Func<string, ExtractionOptions?, CancellationToken, ValueTask> write,
-                                                 CancellationToken cancellationToken = default)
+                                                 Action<string, ExtractionOptions?> write)
        {
            string destinationFileName;
-            string file = Path.GetFileName(entry.Key);
            string fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);

+            //check for trailing slash.
+            if (fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1] != Path.DirectorySeparatorChar)
+            {
+                fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
+            }
+
+            if (!Directory.Exists(fullDestinationDirectoryPath))
+            {
+                throw new ExtractionException($"Directory does not exist to extract to: {fullDestinationDirectoryPath}");
+            }
+
            options ??= new ExtractionOptions()
            {
                Overwrite = true
            };

+            string file = Path.GetFileName(entry.Key);
            if (options.ExtractFullPath)
            {
                string folder = Path.GetDirectoryName(entry.Key)!;
@@ -55,7 +63,7 @@ namespace SharpCompress.Common
                {
                    throw new ExtractionException("Entry is trying to write a file outside of the destination directory.");
                }
-                await write(destinationFileName, options, cancellationToken);
+                write(destinationFileName, options);
            }
            else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
            {
@@ -63,12 +71,11 @@ namespace SharpCompress.Common
            }
        }

-        public static async ValueTask WriteEntryToFileAsync(IEntry entry, string destinationFileName,
+        public static void WriteEntryToFile(IEntry entry, string destinationFileName,
                                            ExtractionOptions? options,
-                                            Func<string, FileMode, CancellationToken, ValueTask> openAndWrite,
-                                            CancellationToken cancellationToken = default)
+                                            Action<string, FileMode> openAndWrite)
        {
-            if (entry.LinkTarget is not null)
+            if (entry.LinkTarget != null)
            {
                if (options?.WriteSymbolicLink is null)
                {
@@ -89,7 +96,7 @@ namespace SharpCompress.Common
                    fm = FileMode.CreateNew;
                }

-                await openAndWrite(destinationFileName, fm, cancellationToken);
+                openAndWrite(destinationFileName, fm);
                entry.PreserveExtractionOptions(destinationFileName, options);
            }
        }
--- a/src/SharpCompress/Common/FilePart.cs
+++ b/src/SharpCompress/Common/FilePart.cs
@@ -1,6 +1,4 @@
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
+using System.IO;

 namespace SharpCompress.Common
 {
@@ -13,9 +11,10 @@ namespace SharpCompress.Common

        internal ArchiveEncoding ArchiveEncoding { get; }

-        internal abstract string? FilePartName { get; }
+        internal abstract string FilePartName { get; }
+        public int Index { get; set; }

-        internal abstract ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken);
+        internal abstract Stream GetCompressedStream();
        internal abstract Stream? GetRawStream();
        internal bool Skipped { get; set; }
    }
--- a/src/SharpCompress/Common/GZip/GZipEntry.cs
+++ b/src/SharpCompress/Common/GZip/GZipEntry.cs
@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Runtime.CompilerServices;
-using System.Threading;

 namespace SharpCompress.Common.GZip
 {
@@ -19,7 +17,7 @@ namespace SharpCompress.Common.GZip

        public override long Crc => _filePart.Crc ?? 0;

-        public override string Key => _filePart.FilePartName ?? string.Empty;
+        public override string Key => _filePart.FilePartName;

        public override string? LinkTarget => null;

@@ -43,12 +41,9 @@ namespace SharpCompress.Common.GZip

        internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();

-        internal static async IAsyncEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options,
-                                                                     [EnumeratorCancellation] CancellationToken cancellationToken)
+        internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
        {
-            var part = new GZipFilePart(options.ArchiveEncoding);
-            await part.Initialize(stream, cancellationToken);
-            yield return new GZipEntry(part);
+            yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
        }
    }
 }
--- a/src/SharpCompress/Common/GZip/GZipFilePart.cs
+++ b/src/SharpCompress/Common/GZip/GZipFilePart.cs
@@ -1,10 +1,7 @@
-using System;
-using System.Buffers;
+using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
@@ -14,44 +11,34 @@ namespace SharpCompress.Common.GZip
    internal sealed class GZipFilePart : FilePart
    {
        private string? _name;
-        //init only
-#nullable disable
-        private Stream _stream;
-#nullable enable
+        private readonly Stream _stream;

-        internal GZipFilePart(ArchiveEncoding archiveEncoding)
+        internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
            : base(archiveEncoding)
-        {
-        }
-
-        internal async ValueTask Initialize(Stream stream, CancellationToken cancellationToken)
        {
            _stream = stream;
+            ReadAndValidateGzipHeader();
            if (stream.CanSeek)
            {
                long position = stream.Position;
                stream.Position = stream.Length - 8;
-                await ReadTrailerAsync(cancellationToken);
+                ReadTrailer();
                stream.Position = position;
            }
            EntryStartPosition = stream.Position;
        }

-        internal long EntryStartPosition { get; private set; }
+        internal long EntryStartPosition { get; }

        internal DateTime? DateModified { get; private set; }
-        internal int? Crc { get; private set; }
-        internal int? UncompressedSize { get; private set; }
+        internal uint? Crc { get; private set; }
+        internal uint? UncompressedSize { get; private set; }

-        internal override string? FilePartName => _name;
+        internal override string FilePartName => _name!;

-        internal override async ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken)
+        internal override Stream GetCompressedStream()
        {
-            var stream = new GZipStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
-            await stream.ReadAsync(Array.Empty<byte>(), 0, 0, cancellationToken);
-            _name = stream.FileName;
-            DateModified = stream.LastModified;
-            return stream;
+            return new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
        }

        internal override Stream GetRawStream()
@@ -59,12 +46,93 @@ namespace SharpCompress.Common.GZip
            return _stream;
        }

-        private async ValueTask ReadTrailerAsync(CancellationToken cancellationToken)
+        private void ReadTrailer()
        {
            // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
+            Span<byte> trailer = stackalloc byte[8];
+            int n = _stream.Read(trailer);

-            Crc = await _stream.ReadInt32(cancellationToken);
-            UncompressedSize = await _stream.ReadInt32(cancellationToken);
+            Crc = BinaryPrimitives.ReadUInt32LittleEndian(trailer);
+            UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.Slice(4));
+        }
+
+        private void ReadAndValidateGzipHeader()
+        {
+            // read the header on the first read
+            Span<byte> header = stackalloc byte[10];
+            int n = _stream.Read(header);
+
+            // workitem 8501: handle edge case (decompress empty stream)
+            if (n == 0)
+            {
+                return;
+            }
+
+            if (n != 10)
+            {
+                throw new ZlibException("Not a valid GZIP stream.");
+            }
+
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+            {
+                throw new ZlibException("Bad GZIP header.");
+            }
+
+            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.Slice(4));
+            DateModified = TarHeader.EPOCH.AddSeconds(timet);
+            if ((header[3] & 0x04) == 0x04)
+            {
+                // read and discard extra field
+                n = _stream.Read(header.Slice(0, 2)); // 2-byte length field
+
+                short extraLength = (short)(header[0] + header[1] * 256);
+                byte[] extra = new byte[extraLength];
+
+                if (!_stream.ReadFully(extra))
+                {
+                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                }
+                n = extraLength;
+            }
+            if ((header[3] & 0x08) == 0x08)
+            {
+                _name = ReadZeroTerminatedString(_stream);
+            }
+            if ((header[3] & 0x10) == 0x010)
+            {
+                ReadZeroTerminatedString(_stream);
+            }
+            if ((header[3] & 0x02) == 0x02)
+            {
+                _stream.ReadByte(); // CRC16, ignore
+            }
+        }
+
+        private string ReadZeroTerminatedString(Stream stream)
+        {
+            Span<byte> buf1 = stackalloc byte[1];
+            var list = new List<byte>();
+            bool done = false;
+            do
+            {
+                // workitem 7740
+                int n = stream.Read(buf1);
+                if (n != 1)
+                {
+                    throw new ZlibException("Unexpected EOF reading GZIP header.");
+                }
+                if (buf1[0] == 0)
+                {
+                    done = true;
+                }
+                else
+                {
+                    list.Add(buf1[0]);
+                }
+            }
+            while (!done);
+            byte[] buffer = list.ToArray();
+            return ArchiveEncoding.Decode(buffer);
        }
    }
 }
--- a/src/SharpCompress/Common/GZip/GZipVolume.cs
+++ b/src/SharpCompress/Common/GZip/GZipVolume.cs
@@ -1,12 +1,12 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Common.GZip
 {
    public class GZipVolume : Volume
    {
-        public GZipVolume(Stream stream, ReaderOptions options)
-            : base(stream, options)
+        public GZipVolume(Stream stream, ReaderOptions options, int index = 0)
+            : base(stream, options, index)
        {
        }

@@ -20,4 +20,4 @@ namespace SharpCompress.Common.GZip

        public override bool IsMultiVolume => true;
    }
-}
+}
--- a/src/SharpCompress/Common/IEntry.cs
+++ b/src/SharpCompress/Common/IEntry.cs
@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Collections.Generic;

 namespace SharpCompress.Common
 {
@@ -14,9 +15,12 @@ namespace SharpCompress.Common
        bool IsDirectory { get; }
        bool IsEncrypted { get; }
        bool IsSplitAfter { get; }
+        bool IsSolid { get; }
+        int VolumeIndexFirst { get; }
+        int VolumeIndexLast { get; }
        DateTime? LastAccessedTime { get; }
        DateTime? LastModifiedTime { get; }
        long Size { get; }
        int? Attrib { get; }
    }
-}
+}
--- a/src/SharpCompress/Common/IVolume.cs
+++ b/src/SharpCompress/Common/IVolume.cs
@@ -1,8 +1,11 @@
-using System;
+using System;

 namespace SharpCompress.Common
 {
-    public interface IVolume : IAsyncDisposable
+    public interface IVolume : IDisposable
    {
+        int Index { get; }
+
+        string FileName { get; }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarEntry.cs
+++ b/src/SharpCompress/Common/Rar/RarEntry.cs
@@ -10,7 +10,7 @@ namespace SharpCompress.Common.Rar
        /// <summary>
        /// As the V2017 port isn't complete, add this check to use the legacy Rar code.
        /// </summary>
-        internal bool IsRarV3 => FileHeader.CompressionAlgorithm == 29 || FileHeader.CompressionAlgorithm == 36;
+        internal bool IsRarV3 => FileHeader.CompressionAlgorithm == 20 || FileHeader.CompressionAlgorithm == 26 || FileHeader.CompressionAlgorithm == 29 || FileHeader.CompressionAlgorithm == 36; //Nanook - Added 20+26 as Test arc from WinRar2.8 (algo 20) was failing with 2017 code

        /// <summary>
        /// The File's 32 bit CRC Hash
--- a/src/SharpCompress/Common/Rar/RarFilePart.cs
+++ b/src/SharpCompress/Common/Rar/RarFilePart.cs
@@ -1,4 +1,4 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar.Headers;

 namespace SharpCompress.Common.Rar
@@ -8,11 +8,12 @@ namespace SharpCompress.Common.Rar
    /// </summary>
    internal abstract class RarFilePart : FilePart
    {
-        internal RarFilePart(MarkHeader mh, FileHeader fh)
+        internal RarFilePart(MarkHeader mh, FileHeader fh, int index)
            : base(fh.ArchiveEncoding)
        {
            MarkHeader = mh;
            FileHeader = fh;
+            Index = index;
        }

        internal MarkHeader MarkHeader { get; }
@@ -24,4 +25,4 @@ namespace SharpCompress.Common.Rar
            return null;
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarVolume.cs
+++ b/src/SharpCompress/Common/Rar/RarVolume.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -14,9 +14,10 @@ namespace SharpCompress.Common.Rar
    public abstract class RarVolume : Volume
    {
        private readonly RarHeaderFactory _headerFactory;
+        internal int _maxCompressionAlgorithm;

-        internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options)
-            : base(stream, options)
+        internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options, int index = 0)
+            : base(stream, options, index)
        {
            _headerFactory = new RarHeaderFactory(mode, options);
        }
@@ -51,6 +52,8 @@ namespace SharpCompress.Common.Rar
                    case HeaderType.File:
                        {
                            var fh = (FileHeader)header;
+                            if (_maxCompressionAlgorithm < fh.CompressionAlgorithm)
+                                _maxCompressionAlgorithm = fh.CompressionAlgorithm;
                            yield return CreateFilePart(lastMarkHeader!, fh);
                        }
                        break;
@@ -110,5 +113,37 @@ namespace SharpCompress.Common.Rar
                return ArchiveHeader.IsSolid;
            }
        }
+
+        public int MinVersion
+        {
+            get
+            {
+                EnsureArchiveHeaderLoaded();
+                if (_maxCompressionAlgorithm >= 50)
+                    return 5; //5-6
+                else if (_maxCompressionAlgorithm >= 29)
+                    return 3; //3-4
+                else if (_maxCompressionAlgorithm >= 20)
+                    return 2; //2
+                else
+                    return 1;
+            }
+        }
+
+        public int MaxVersion
+        {
+            get
+            {
+                EnsureArchiveHeaderLoaded();
+                if (_maxCompressionAlgorithm >= 50)
+                    return 6; //5-6
+                else if (_maxCompressionAlgorithm >= 29)
+                    return 4; //3-4
+                else if (_maxCompressionAlgorithm >= 20)
+                    return 2; //2
+                else
+                    return 1;
+            }
+        }
    }
-}
+}
--- a/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
@@ -5,8 +5,6 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
@@ -785,7 +783,7 @@ namespace SharpCompress.Common.SevenZip
            }
        }

-        private async ValueTask<List<byte[]>> ReadAndDecodePackedStreams(long baseOffset, IPasswordProvider pass, CancellationToken cancellationToken)
+        private List<byte[]> ReadAndDecodePackedStreams(long baseOffset, IPasswordProvider pass)
        {
 #if DEBUG
            Log.WriteLine("-- ReadAndDecodePackedStreams --");
@@ -817,8 +815,8 @@ namespace SharpCompress.Common.SevenZip
                        dataStartPos += packSize;
                    }

-                    var outStream = await DecoderStreamHelper.CreateDecoderStream(_stream, oldDataStartPos, myPackSizes,
-                                                                            folder, pass, cancellationToken);
+                    var outStream = DecoderStreamHelper.CreateDecoderStream(_stream, oldDataStartPos, myPackSizes,
+                                                                            folder, pass);

                    int unpackSize = checked((int)folder.GetUnpackSize());
                    byte[] data = new byte[unpackSize];
@@ -847,7 +845,7 @@ namespace SharpCompress.Common.SevenZip
            }
        }

-        private async ValueTask ReadHeader(ArchiveDatabase db, IPasswordProvider getTextPassword, CancellationToken cancellationToken)
+        private void ReadHeader(ArchiveDatabase db, IPasswordProvider getTextPassword)
        {
 #if DEBUG
            Log.WriteLine("-- ReadHeader --");
@@ -866,7 +864,7 @@ namespace SharpCompress.Common.SevenZip
                List<byte[]> dataVector = null;
                if (type == BlockType.AdditionalStreamsInfo)
                {
-                    dataVector = await ReadAndDecodePackedStreams(db._startPositionAfterHeader, getTextPassword, cancellationToken);
+                    dataVector = ReadAndDecodePackedStreams(db._startPositionAfterHeader, getTextPassword);
                    type = ReadId();
                }

@@ -1250,7 +1248,7 @@ namespace SharpCompress.Common.SevenZip

            if (nextHeaderOffset > _streamEnding - db._startPositionAfterHeader)
            {
-                throw new IndexOutOfRangeException();
+                throw new InvalidOperationException("nextHeaderOffset is invalid");
            }

            _stream.Seek(nextHeaderOffset, SeekOrigin.Current);
--- a/src/SharpCompress/Common/SevenZip/CFolder.cs
+++ b/src/SharpCompress/Common/SevenZip/CFolder.cs
@@ -30,7 +30,7 @@ namespace SharpCompress.Common.SevenZip
                }
            }

-            throw new Exception();
+            throw new InvalidOperationException();
        }

        public int GetNumOutStreams()
@@ -185,4 +185,4 @@ namespace SharpCompress.Common.SevenZip
            return true;
        }
    }
-}
+}
--- a/src/SharpCompress/Common/SevenZip/SevenZipEntry.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipEntry.cs
@@ -32,7 +32,7 @@ namespace SharpCompress.Common.SevenZip

        public override DateTime? ArchivedTime => null;

-        public override bool IsEncrypted => false;
+        public override bool IsEncrypted => FilePart.IsEncrypted;

        public override bool IsDirectory => FilePart.Header.IsDir;

--- a/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
@@ -1,8 +1,6 @@
-using System;
+using System;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.IO;

 namespace SharpCompress.Common.SevenZip
@@ -28,7 +26,6 @@ namespace SharpCompress.Common.SevenZip

        internal CFileItem Header { get; }
        internal CFolder? Folder { get; }
-        internal int Index { get; }

        internal override string FilePartName => Header.Name;

@@ -37,11 +34,11 @@ namespace SharpCompress.Common.SevenZip
            return null;
        }

-        internal override async ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken)
+        internal override Stream GetCompressedStream()
        {
            if (!Header.HasStream)
            {
-                return Stream.Null;
+                return null!;
            }
            var folderStream = _database.GetFolderStream(_stream, Folder!, _database.PasswordProvider);

@@ -54,7 +51,7 @@ namespace SharpCompress.Common.SevenZip
            }
            if (skipSize > 0)
            {
-                await folderStream.SkipAsync(skipSize, cancellationToken);
+                folderStream.Skip(skipSize);
            }
            return new ReadOnlySubStream(folderStream, Header.Size);
        }
@@ -104,5 +101,7 @@ namespace SharpCompress.Common.SevenZip
                    throw new NotImplementedException();
            }
        }
+
+        internal bool IsEncrypted => Folder!._coders.FindIndex(c => c._methodId._id == CMethodId.K_AES_ID) != -1;
    }
-}
+}
--- a/src/SharpCompress/Common/SevenZip/SevenZipVolume.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipVolume.cs
@@ -1,13 +1,13 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Common.SevenZip
 {
    public class SevenZipVolume : Volume
    {
-        public SevenZipVolume(Stream stream, ReaderOptions readerFactoryOptions)
-            : base(stream, readerFactoryOptions)
+        public SevenZipVolume(Stream stream, ReaderOptions readerFactoryOptions, int index = 0)
+            : base(stream, readerFactoryOptions, index)
        {
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
+++ b/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
@@ -1,12 +1,9 @@
 #nullable disable

 using System;
-using System.Buffers;
 using System.Buffers.Binary;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Tar.Headers
 {
@@ -22,11 +19,9 @@ namespace SharpCompress.Common.Tar.Headers
        internal string Name { get; set; }
        internal string LinkName { get; set; }

-        //internal int Mode { get; set; }
-        //internal int UserId { get; set; }
-        //internal string UserName { get; set; }
-        //internal int GroupId { get; set; }
-        //internal string GroupName { get; set; }
+        internal long Mode { get; set; }
+        internal long UserId { get; set; }
+        internal long GroupId { get; set; }
        internal long Size { get; set; }
        internal DateTime LastModifiedTime { get; set; }
        internal EntryType EntryType { get; set; }
@@ -35,48 +30,48 @@ namespace SharpCompress.Common.Tar.Headers

        internal const int BLOCK_SIZE = 512;

-        internal async Task WriteAsync(Stream output)
+        internal void Write(Stream output)
        {
-            using var buffer = MemoryPool<byte>.Shared.Rent(BLOCK_SIZE);
+            byte[] buffer = new byte[BLOCK_SIZE];

-            WriteOctalBytes(511, buffer.Memory.Span, 100, 8); // file mode
-            WriteOctalBytes(0, buffer.Memory.Span, 108, 8); // owner ID
-            WriteOctalBytes(0, buffer.Memory.Span, 116, 8); // group ID
+            WriteOctalBytes(511, buffer, 100, 8); // file mode
+            WriteOctalBytes(0, buffer, 108, 8); // owner ID
+            WriteOctalBytes(0, buffer, 116, 8); // group ID

            //ArchiveEncoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
            var nameByteCount = ArchiveEncoding.GetEncoding().GetByteCount(Name);
            if (nameByteCount > 100)
            {
                // Set mock filename and filetype to indicate the next block is the actual name of the file
-                WriteStringBytes("././@LongLink", buffer.Memory.Span, 0, 100);
-                buffer.Memory.Span[156] = (byte)EntryType.LongName;
-                WriteOctalBytes(nameByteCount + 1, buffer.Memory.Span, 124, 12);
+                WriteStringBytes("././@LongLink", buffer, 0, 100);
+                buffer[156] = (byte)EntryType.LongName;
+                WriteOctalBytes(nameByteCount + 1, buffer, 124, 12);
            }
            else
            {
-                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer.Memory, 100);
-                WriteOctalBytes(Size, buffer.Memory.Span, 124, 12);
+                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 100);
+                WriteOctalBytes(Size, buffer, 124, 12);
                var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
-                WriteOctalBytes(time, buffer.Memory.Span, 136, 12);
-                buffer.Memory.Span[156] = (byte)EntryType;
+                WriteOctalBytes(time, buffer, 136, 12);
+                buffer[156] = (byte)EntryType;

                if (Size >= 0x1FFFFFFFF)
                {
-                    using var bytes12 = MemoryPool<byte>.Shared.Rent(12);
-                    BinaryPrimitives.WriteInt64BigEndian(bytes12.Memory.Span.Slice(4), Size);
-                    bytes12.Memory.Span[0] |= 0x80;
-                    bytes12.Memory.CopyTo(buffer.Memory.Slice(124));
+                    Span<byte> bytes12 = stackalloc byte[12];
+                    BinaryPrimitives.WriteInt64BigEndian(bytes12.Slice(4), Size);
+                    bytes12[0] |= 0x80;
+                    bytes12.CopyTo(buffer.AsSpan(124));
                }
            }

-            int crc = RecalculateChecksum(buffer.Memory);
-            WriteOctalBytes(crc, buffer.Memory.Span, 148, 8);
+            int crc = RecalculateChecksum(buffer);
+            WriteOctalBytes(crc, buffer, 148, 8);

-            await output.WriteAsync(buffer.Memory.Slice(0, BLOCK_SIZE));
+            output.Write(buffer, 0, buffer.Length);

            if (nameByteCount > 100)
            {
-                await WriteLongFilenameHeaderAsync(output);
+                WriteLongFilenameHeader(output);
                // update to short name lower than 100 - [max bytes of one character].
                // subtracting bytes is needed because preventing infinite loop(example code is here).
                //
@@ -85,14 +80,14 @@ namespace SharpCompress.Common.Tar.Headers
                //
                // and then infinite recursion is occured in WriteLongFilenameHeader because truncated.Length is 102.
                Name = ArchiveEncoding.Decode(ArchiveEncoding.Encode(Name), 0, 100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1));
-                await WriteAsync(output);
+                Write(output);
            }
        }

-        private async Task WriteLongFilenameHeaderAsync(Stream output)
+        private void WriteLongFilenameHeader(Stream output)
        {
            byte[] nameBytes = ArchiveEncoding.Encode(Name);
-            await output.WriteAsync(nameBytes.AsMemory());
+            output.Write(nameBytes, 0, nameBytes.Length);

            // pad to multiple of BlockSize bytes, and make sure a terminating null is added
            int numPaddingBytes = BLOCK_SIZE - (nameBytes.Length % BLOCK_SIZE);
@@ -100,56 +95,51 @@ namespace SharpCompress.Common.Tar.Headers
            {
                numPaddingBytes = BLOCK_SIZE;
            }
-
-            using var padding = MemoryPool<byte>.Shared.Rent(numPaddingBytes);
-            padding.Memory.Span.Clear();
-            await output.WriteAsync(padding.Memory.Slice(0, numPaddingBytes));
+            output.Write(stackalloc byte[numPaddingBytes]);
        }

-        internal async ValueTask<bool> Read(Stream stream, CancellationToken cancellationToken)
+        internal bool Read(BinaryReader reader)
        {
-            var block = MemoryPool<byte>.Shared.Rent(BLOCK_SIZE);
-            bool readFullyAsync = await stream.ReadAsync(block.Memory.Slice(0, BLOCK_SIZE), cancellationToken) == BLOCK_SIZE;
-            if (readFullyAsync is false)
+            var buffer = ReadBlock(reader);
+            if (buffer.Length == 0)
            {
                return false;
            }

            // for symlinks, additionally read the linkname
-            if (ReadEntryType(block.Memory.Span) == EntryType.SymLink)
+            if (ReadEntryType(buffer) == EntryType.SymLink)
            {
-                LinkName = ArchiveEncoding.Decode(block.Memory.Span.Slice(157, 100)).TrimNulls();
+                LinkName = ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
            }

-            if (ReadEntryType(block.Memory.Span) == EntryType.LongName)
+            if (ReadEntryType(buffer) == EntryType.LongName)
            {
-                Name = await ReadLongName(stream, block.Memory.Slice(0,BLOCK_SIZE), cancellationToken);
-                readFullyAsync = await stream.ReadAsync(block.Memory.Slice(0, BLOCK_SIZE), cancellationToken) == BLOCK_SIZE;
-                if (readFullyAsync is false)
-                {
-                    return false;
-                }
+                Name = ReadLongName(reader, buffer);
+                buffer = ReadBlock(reader);
            }
            else
            {
-                Name = ArchiveEncoding.Decode(block.Memory.Span.Slice( 0, 100)).TrimNulls();
+                Name = ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
            }

-            EntryType = ReadEntryType(block.Memory.Span);
-            Size = ReadSize(block.Memory.Slice(0, BLOCK_SIZE));
+            EntryType = ReadEntryType(buffer);
+            Size = ReadSize(buffer);

-            //Mode = ReadASCIIInt32Base8(buffer, 100, 7);
-            //UserId = ReadASCIIInt32Base8(buffer, 108, 7);
-            //GroupId = ReadASCIIInt32Base8(buffer, 116, 7);
-            long unixTimeStamp = ReadAsciiInt64Base8(block.Memory.Span.Slice(136, 11));
+            Mode = ReadAsciiInt64Base8(buffer, 100, 7);
+            if(EntryType == EntryType.Directory) 
+                Mode |= 0b1_000_000_000;
+
+            UserId = ReadAsciiInt64Base8(buffer, 108, 7);
+            GroupId = ReadAsciiInt64Base8(buffer, 116, 7);
+            long unixTimeStamp = ReadAsciiInt64Base8(buffer, 136, 11);
            LastModifiedTime = EPOCH.AddSeconds(unixTimeStamp).ToLocalTime();

-            Magic = ArchiveEncoding.Decode(block.Memory.Span.Slice( 257, 6)).TrimNulls();
+            Magic = ArchiveEncoding.Decode(buffer, 257, 6).TrimNulls();

            if (!string.IsNullOrEmpty(Magic)
                && "ustar".Equals(Magic))
            {
-                string namePrefix = ArchiveEncoding.Decode(block.Memory.Span.Slice( 345, 157));
+                string namePrefix = ArchiveEncoding.Decode(buffer, 345, 157);
                namePrefix = namePrefix.TrimNulls();
                if (!string.IsNullOrEmpty(namePrefix))
                {
@@ -164,46 +154,55 @@ namespace SharpCompress.Common.Tar.Headers
            return true;
        }

-        private async ValueTask<string> ReadLongName(Stream reader, ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
+        private string ReadLongName(BinaryReader reader, byte[] buffer)
        {
            var size = ReadSize(buffer);
            var nameLength = (int)size;
-            using var rented = MemoryPool<byte>.Shared.Rent(nameLength);
-            var nameBytes = rented.Memory.Slice(0, nameLength);
-            await reader.ReadAsync(nameBytes, cancellationToken);
+            var nameBytes = reader.ReadBytes(nameLength);
            var remainingBytesToRead = BLOCK_SIZE - (nameLength % BLOCK_SIZE);

            // Read the rest of the block and discard the data
            if (remainingBytesToRead < BLOCK_SIZE)
            {
-                using var remaining = MemoryPool<byte>.Shared.Rent(remainingBytesToRead);
-                await reader.ReadAsync(remaining.Memory.Slice(0, remainingBytesToRead), cancellationToken);
+                reader.ReadBytes(remainingBytesToRead);
            }
-            return ArchiveEncoding.Decode(nameBytes.Span).TrimNulls();
+            return ArchiveEncoding.Decode(nameBytes, 0, nameBytes.Length).TrimNulls();
        }

-        private static EntryType ReadEntryType(Span<byte> buffer)
+        private static EntryType ReadEntryType(byte[] buffer)
        {
            return (EntryType)buffer[156];
        }

-        private long ReadSize(ReadOnlyMemory<byte> buffer)
+        private long ReadSize(byte[] buffer)
        {
-            if ((buffer.Span[124] & 0x80) == 0x80) // if size in binary
+            if ((buffer[124] & 0x80) == 0x80) // if size in binary
            {
-                return BinaryPrimitives.ReadInt64BigEndian(buffer.Span.Slice(0x80));
+                return BinaryPrimitives.ReadInt64BigEndian(buffer.AsSpan(0x80));
            }

-            return ReadAsciiInt64Base8(buffer.Span.Slice(124, 11));
-        }
-        private static void WriteStringBytes(ReadOnlySpan<byte> name, Memory<byte> buffer, int length)
-        {
-            name.CopyTo(buffer.Span.Slice(0));
-            int i = Math.Min(length, name.Length);
-            buffer.Slice(i, length - i).Span.Clear();
+            return ReadAsciiInt64Base8(buffer, 124, 11);
        }

-        private static void WriteStringBytes(string name, Span<byte> buffer, int offset, int length)
+        private static byte[] ReadBlock(BinaryReader reader)
+        {
+            byte[] buffer = reader.ReadBytes(BLOCK_SIZE);
+
+            if (buffer.Length != 0 && buffer.Length < BLOCK_SIZE)
+            {
+                throw new InvalidOperationException("Buffer is invalid size");
+            }
+            return buffer;
+        }
+
+        private static void WriteStringBytes(ReadOnlySpan<byte> name, Span<byte> buffer, int length)
+        {
+            name.CopyTo(buffer);
+            int i = Math.Min(length, name.Length);
+            buffer.Slice(i, length - i).Clear();
+        }
+
+        private static void WriteStringBytes(string name, byte[] buffer, int offset, int length)
        {
            int i;

@@ -218,7 +217,7 @@ namespace SharpCompress.Common.Tar.Headers
            }
        }

-        private static void WriteOctalBytes(long value, Span<byte> buffer, int offset, int length)
+        private static void WriteOctalBytes(long value, byte[] buffer, int offset, int length)
        {
            string val = Convert.ToString(value, 8);
            int shift = length - val.Length - 1;
@@ -232,9 +231,19 @@ namespace SharpCompress.Common.Tar.Headers
            }
        }

-        private static long ReadAsciiInt64Base8(ReadOnlySpan<byte> buffer)
+        private static int ReadAsciiInt32Base8(byte[] buffer, int offset, int count)
        {
-            string s = Encoding.UTF8.GetString(buffer).TrimNulls();
+            string s = Encoding.UTF8.GetString(buffer, offset, count).TrimNulls();
+            if (string.IsNullOrEmpty(s))
+            {
+                return 0;
+            }
+            return Convert.ToInt32(s, 8);
+        }
+
+        private static long ReadAsciiInt64Base8(byte[] buffer, int offset, int count)
+        {
+            string s = Encoding.UTF8.GetString(buffer, offset, count).TrimNulls();
            if (string.IsNullOrEmpty(s))
            {
                return 0;
@@ -258,20 +267,38 @@ namespace SharpCompress.Common.Tar.Headers
            (byte)' ', (byte)' ', (byte)' ', (byte)' '
        };

-        private static int RecalculateChecksum(Memory<byte> buf)
+        internal static int RecalculateChecksum(byte[] buf)
        {
            // Set default value for checksum. That is 8 spaces.
-            eightSpaces.CopyTo(buf.Slice(148));
+            eightSpaces.CopyTo(buf, 148);

            // Calculate checksum
            int headerChecksum = 0;
-            foreach (byte b in buf.Span)
+            foreach (byte b in buf)
            {
                headerChecksum += b;
            }
            return headerChecksum;
        }

+        internal static int RecalculateAltChecksum(byte[] buf)
+        {
+            eightSpaces.CopyTo(buf, 148);
+            int headerChecksum = 0;
+            foreach (byte b in buf)
+            {
+                if ((b & 0x80) == 0x80)
+                {
+                    headerChecksum -= b ^ 0x80;
+                }
+                else
+                {
+                    headerChecksum += b;
+                }
+            }
+            return headerChecksum;
+        }
+
        public long? DataStartPosition { get; set; }

        public string Magic { get; set; }
--- a/src/SharpCompress/Common/Tar/TarEntry.cs
+++ b/src/SharpCompress/Common/Tar/TarEntry.cs
@@ -3,8 +3,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Runtime.CompilerServices;
-using System.Threading;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;

@@ -46,13 +44,18 @@ namespace SharpCompress.Common.Tar

        public override bool IsSplitAfter => false;

+        public long Mode => _filePart.Header.Mode;
+
+        public long UserID => _filePart.Header.UserId;
+        
+        public long GroupId => _filePart.Header.GroupId;
+
        internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();

-        internal static async IAsyncEnumerable<TarEntry> GetEntries(StreamingMode mode, Stream stream,
-                                                         CompressionType compressionType, ArchiveEncoding archiveEncoding,
-                                                         [EnumeratorCancellation]CancellationToken cancellationToken)
+        internal static IEnumerable<TarEntry> GetEntries(StreamingMode mode, Stream stream,
+                                                         CompressionType compressionType, ArchiveEncoding archiveEncoding)
        {
-            await foreach (TarHeader h in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding, cancellationToken))
+            foreach (TarHeader h in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))
            {
                if (h != null)
                {
--- a/src/SharpCompress/Common/Tar/TarFilePart.cs
+++ b/src/SharpCompress/Common/Tar/TarFilePart.cs
@@ -1,7 +1,6 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
+using SharpCompress.IO;

 namespace SharpCompress.Common.Tar
 {
@@ -20,14 +19,14 @@ namespace SharpCompress.Common.Tar

        internal override string FilePartName => Header.Name;

-        internal override ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken)
+        internal override Stream GetCompressedStream()
        {
            if (_seekableStream != null)
            {
                _seekableStream.Position = Header.DataStartPosition!.Value;
-                return new(new TarReadOnlySubStream(_seekableStream, Header.Size));
+                return new TarReadOnlySubStream(_seekableStream, Header.Size);
            }
-            return new(Header.PackedStream);
+            return Header.PackedStream;
        }

        internal override Stream? GetRawStream()
--- a/src/SharpCompress/Common/Tar/TarHeaderFactory.cs
+++ b/src/SharpCompress/Common/Tar/TarHeaderFactory.cs
@@ -1,7 +1,5 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Runtime.CompilerServices;
-using System.Threading;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;

@@ -9,17 +7,17 @@ namespace SharpCompress.Common.Tar
 {
    internal static class TarHeaderFactory
    {
-        internal static async IAsyncEnumerable<TarHeader?> ReadHeader(StreamingMode mode, Stream stream, ArchiveEncoding archiveEncoding, 
-                                                                      [EnumeratorCancellation]CancellationToken cancellationToken)
+        internal static IEnumerable<TarHeader?> ReadHeader(StreamingMode mode, Stream stream, ArchiveEncoding archiveEncoding)
        {
            while (true)
            {
                TarHeader? header = null;
                try
                {
+                    BinaryReader reader = new BinaryReader(stream);
                    header = new TarHeader(archiveEncoding);

-                    if (!await header.Read(stream, cancellationToken))
+                    if (!header.Read(reader))
                    {
                        yield break;
                    }
@@ -27,10 +25,10 @@ namespace SharpCompress.Common.Tar
                    {
                        case StreamingMode.Seekable:
                            {
-                                header.DataStartPosition = stream.Position;
+                                header.DataStartPosition = reader.BaseStream.Position;

                                //skip to nearest 512
-                                stream.Position += PadTo512(header.Size);
+                                reader.BaseStream.Position += PadTo512(header.Size);
                            }
                            break;
                        case StreamingMode.Streaming:
--- a/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs
+++ b/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs
@@ -1,8 +1,6 @@
 using SharpCompress.IO;
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Tar
 {
@@ -16,7 +14,7 @@ namespace SharpCompress.Common.Tar
            BytesLeftToRead = bytesToRead;
        }

-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
        {
            if (_isDisposed)
            {
@@ -25,17 +23,22 @@ namespace SharpCompress.Common.Tar

            _isDisposed = true;

-            // Ensure we read all remaining blocks for this entry.
-            await Stream.SkipAsync(BytesLeftToRead);
-            _amountRead += BytesLeftToRead;
-
-            // If the last block wasn't a full 512 bytes, skip the remaining padding bytes.
-            var bytesInLastBlock = _amountRead % 512;
-
-            if (bytesInLastBlock != 0)
+            if (disposing)
            {
-                await Stream.SkipAsync(512 - bytesInLastBlock);
+                // Ensure we read all remaining blocks for this entry.
+                Stream.Skip(BytesLeftToRead);
+                _amountRead += BytesLeftToRead;
+
+                // If the last block wasn't a full 512 bytes, skip the remaining padding bytes.
+                var bytesInLastBlock = _amountRead % 512;
+
+                if (bytesInLastBlock != 0)
+                {
+                    Stream.Skip(512 - bytesInLastBlock);
+                }
            }
+
+            base.Dispose(disposing);
        }

        private long BytesLeftToRead { get; set; }
@@ -46,18 +49,22 @@ namespace SharpCompress.Common.Tar

        public override bool CanWrite => false;

+        public override void Flush()
+        {
+            throw new NotSupportedException();
+        }
+
        public override long Length => throw new NotSupportedException();

        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }

-        public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        public override int Read(byte[] buffer, int offset, int count)
        {
-            var count = buffer.Length;
-            if (BytesLeftToRead < buffer.Length)
+            if (BytesLeftToRead < count)
            {
                count = (int)BytesLeftToRead;
            }
-            int read = await Stream.ReadAsync(buffer.Slice(0, count), cancellationToken);
+            int read = Stream.Read(buffer, offset, count);
            if (read > 0)
            {
                BytesLeftToRead -= read;
@@ -66,9 +73,20 @@ namespace SharpCompress.Common.Tar
            return read;
        }

-        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override int ReadByte()
        {
-            throw new NotSupportedException();
+            if (BytesLeftToRead <= 0)
+            {
+                return -1;
+            }
+            int value = Stream.ReadByte();
+            if (value != -1)
+            {
+                --BytesLeftToRead;
+                ++_amountRead;
+            }
+            return value;
+
        }

        public override long Seek(long offset, SeekOrigin origin)
@@ -80,5 +98,10 @@ namespace SharpCompress.Common.Tar
        {
            throw new NotSupportedException();
        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
    }
 }
--- a/src/SharpCompress/Common/Tar/TarVolume.cs
+++ b/src/SharpCompress/Common/Tar/TarVolume.cs
@@ -1,13 +1,13 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Common.Tar
 {
    public class TarVolume : Volume
    {
-        public TarVolume(Stream stream, ReaderOptions readerOptions)
-            : base(stream, readerOptions)
+        public TarVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+            : base(stream, readerOptions, index)
        {
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Volume.cs
+++ b/src/SharpCompress/Common/Volume.cs
@@ -1,5 +1,5 @@
-using System.IO;
-using System.Threading.Tasks;
+using System;
+using System.IO;
 using SharpCompress.IO;
 using SharpCompress.Readers;

@@ -9,12 +9,13 @@ namespace SharpCompress.Common
    {
        private readonly Stream _actualStream;

-        internal Volume(Stream stream, ReaderOptions readerOptions)
+        internal Volume(Stream stream, ReaderOptions readerOptions, int index = 0)
        {
+            Index = index;
            ReaderOptions = readerOptions;
            if (readerOptions.LeaveStreamOpen)
            {
-                stream = new NonDisposingStream(stream);
+                stream = NonDisposingStream.Create(stream);
            }
            _actualStream = stream;
        }
@@ -29,14 +30,27 @@ namespace SharpCompress.Common
        /// </summary>
        public virtual bool IsFirstVolume => true;

+        public virtual int Index { get; internal set; }
+
+        public string FileName { get { return (_actualStream as FileStream)?.Name!; } }
+
        /// <summary>
        /// RarArchive is part of a multi-part archive.
        /// </summary>
        public virtual bool IsMultiVolume => true;
-        
-        public ValueTask DisposeAsync()
+
+        protected virtual void Dispose(bool disposing)
        {
-            return _actualStream.DisposeAsync();
+            if (disposing)
+            {
+                _actualStream.Dispose();
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Zip/Headers/DirectoryEndHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/DirectoryEndHeader.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -11,29 +9,29 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override async ValueTask Read(Stream stream, CancellationToken cancellationToken)
+        internal override void Read(BinaryReader reader)
        {
-            VolumeNumber = await stream.ReadUInt16(cancellationToken);
-            FirstVolumeWithDirectory = await stream.ReadUInt16(cancellationToken);
-            TotalNumberOfEntriesInDisk = await stream.ReadUInt16(cancellationToken);
-            TotalNumberOfEntries = await stream.ReadUInt16(cancellationToken);
-            DirectorySize = await stream.ReadUInt32(cancellationToken);
-            DirectoryStartOffsetRelativeToDisk = await stream.ReadUInt32(cancellationToken);
-            CommentLength = await stream.ReadUInt16(cancellationToken);
-            Comment = await stream.ReadBytes(CommentLength ?? 0, cancellationToken);
+            VolumeNumber = reader.ReadUInt16();
+            FirstVolumeWithDirectory = reader.ReadUInt16();
+            TotalNumberOfEntriesInDisk = reader.ReadUInt16();
+            TotalNumberOfEntries = reader.ReadUInt16();
+            DirectorySize = reader.ReadUInt32();
+            DirectoryStartOffsetRelativeToDisk = reader.ReadUInt32();
+            CommentLength = reader.ReadUInt16();
+            Comment = reader.ReadBytes(CommentLength);
        }

-        public ushort? VolumeNumber { get; private set; }
+        public ushort VolumeNumber { get; private set; }

-        public ushort? FirstVolumeWithDirectory { get; private set; }
+        public ushort FirstVolumeWithDirectory { get; private set; }

-        public ushort? TotalNumberOfEntriesInDisk { get; private set; }
+        public ushort TotalNumberOfEntriesInDisk { get; private set; }

-        public uint? DirectorySize { get; private set; }
+        public uint DirectorySize { get; private set; }

-        public uint? DirectoryStartOffsetRelativeToDisk { get; private set; }
+        public uint DirectoryStartOffsetRelativeToDisk { get; private set; }

-        public ushort? CommentLength { get; private set; }
+        public ushort CommentLength { get; private set; }

        public byte[]? Comment { get; private set; }

--- a/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs
@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -12,28 +10,28 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override async ValueTask Read(Stream stream, CancellationToken cancellationToken)
+        internal override void Read(BinaryReader reader)
        {
-            Version = await stream.ReadUInt16(cancellationToken);
-            VersionNeededToExtract = await stream.ReadUInt16(cancellationToken);
-            Flags = (HeaderFlags)await stream.ReadUInt16(cancellationToken);
-            CompressionMethod = (ZipCompressionMethod)await stream.ReadUInt16(cancellationToken);
-            LastModifiedTime = await stream.ReadUInt16(cancellationToken);
-            LastModifiedDate = await stream.ReadUInt16(cancellationToken);
-            Crc = await stream.ReadUInt32(cancellationToken);
-            CompressedSize = await stream.ReadUInt32(cancellationToken);
-            UncompressedSize = await stream.ReadUInt32(cancellationToken);
-            ushort nameLength = await stream.ReadUInt16(cancellationToken);
-            ushort extraLength = await stream.ReadUInt16(cancellationToken);
-            ushort commentLength = await stream.ReadUInt16(cancellationToken);
-            DiskNumberStart = await stream.ReadUInt16(cancellationToken);
-            InternalFileAttributes = await stream.ReadUInt16(cancellationToken);
-            ExternalFileAttributes = await stream.ReadUInt32(cancellationToken);
-            RelativeOffsetOfEntryHeader = await stream.ReadUInt32(cancellationToken);
+            Version = reader.ReadUInt16();
+            VersionNeededToExtract = reader.ReadUInt16();
+            Flags = (HeaderFlags)reader.ReadUInt16();
+            CompressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
+            LastModifiedTime = reader.ReadUInt16();
+            LastModifiedDate = reader.ReadUInt16();
+            Crc = reader.ReadUInt32();
+            CompressedSize = reader.ReadUInt32();
+            UncompressedSize = reader.ReadUInt32();
+            ushort nameLength = reader.ReadUInt16();
+            ushort extraLength = reader.ReadUInt16();
+            ushort commentLength = reader.ReadUInt16();
+            DiskNumberStart = reader.ReadUInt16();
+            InternalFileAttributes = reader.ReadUInt16();
+            ExternalFileAttributes = reader.ReadUInt32();
+            RelativeOffsetOfEntryHeader = reader.ReadUInt32();

-            byte[] name = await stream.ReadBytes(nameLength, cancellationToken);
-            byte[] extra = await stream.ReadBytes(extraLength, cancellationToken);
-            byte[] comment = await stream.ReadBytes(commentLength, cancellationToken);
+            byte[] name = reader.ReadBytes(nameLength);
+            byte[] extra = reader.ReadBytes(extraLength);
+            byte[] comment = reader.ReadBytes(commentLength);

            // According to .ZIP File Format Specification
            //
@@ -65,6 +63,8 @@ namespace SharpCompress.Common.Zip.Headers
            var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
            if (zip64ExtraData != null)
            {
+                zip64ExtraData.Process(UncompressedSize, CompressedSize, RelativeOffsetOfEntryHeader, DiskNumberStart);
+
                if (CompressedSize == uint.MaxValue)
                {
                    CompressedSize = zip64ExtraData.CompressedSize;
--- a/src/SharpCompress/Common/Zip/Headers/IgnoreHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/IgnoreHeader.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -11,9 +9,8 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override ValueTask Read(Stream stream, CancellationToken cancellationToken)
+        internal override void Read(BinaryReader reader)
        {
-            return new();
        }
    }
 }
--- a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs
@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -12,20 +10,20 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override async ValueTask Read(Stream stream, CancellationToken cancellationToken)
+        internal override void Read(BinaryReader reader)
        {
-            Version = await stream.ReadUInt16(cancellationToken);
-            Flags = (HeaderFlags)await stream.ReadUInt16(cancellationToken);
-            CompressionMethod = (ZipCompressionMethod)await stream.ReadUInt16(cancellationToken);
-            LastModifiedTime = await stream.ReadUInt16(cancellationToken);
-            LastModifiedDate = await stream.ReadUInt16(cancellationToken);
-            Crc = await stream.ReadUInt32(cancellationToken);
-            CompressedSize = await stream.ReadUInt32(cancellationToken);
-            UncompressedSize = await stream.ReadUInt32(cancellationToken);
-            ushort nameLength = await stream.ReadUInt16(cancellationToken);
-            ushort extraLength = await stream.ReadUInt16(cancellationToken);
-            byte[] name = await stream.ReadBytes(nameLength, cancellationToken);
-            byte[] extra = await stream.ReadBytes(extraLength, cancellationToken);
+            Version = reader.ReadUInt16();
+            Flags = (HeaderFlags)reader.ReadUInt16();
+            CompressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
+            LastModifiedTime = reader.ReadUInt16();
+            LastModifiedDate = reader.ReadUInt16();
+            Crc = reader.ReadUInt32();
+            CompressedSize = reader.ReadUInt32();
+            UncompressedSize = reader.ReadUInt32();
+            ushort nameLength = reader.ReadUInt16();
+            ushort extraLength = reader.ReadUInt16();
+            byte[] name = reader.ReadBytes(nameLength);
+            byte[] extra = reader.ReadBytes(extraLength);

            // According to .ZIP File Format Specification
            //
@@ -55,6 +53,8 @@ namespace SharpCompress.Common.Zip.Headers
            var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
            if (zip64ExtraData != null)
            {
+                zip64ExtraData.Process(UncompressedSize, CompressedSize, 0, 0);
+
                if (CompressedSize == uint.MaxValue)
                {
                    CompressedSize = zip64ExtraData.CompressedSize;
--- a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs
+++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs
@@ -66,46 +66,74 @@ namespace SharpCompress.Common.Zip.Headers
        public Zip64ExtendedInformationExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
            : base(type, length, dataBytes)
        {
-            Process();
        }

-        private void Process()
+        // From the spec, values are only in the extradata if the standard
+        // value is set to 0xFFFFFFFF (or 0xFFFF for the Disk Start Number).
+        // Values, if present, must appear in the following order:
+        // - Original Size
+        // - Compressed Size
+        // - Relative Header Offset
+        // - Disk Start Number
+        public void Process(long uncompressedFileSize, long compressedFileSize, long relativeHeaderOffset, ushort diskNumber)
        {
-            if (DataBytes.Length >= 8)
+            var bytesRequired = ((uncompressedFileSize == uint.MaxValue) ? 8 : 0)
+                + ((compressedFileSize == uint.MaxValue) ? 8 : 0)
+                + ((relativeHeaderOffset == uint.MaxValue) ? 8 : 0)
+                + ((diskNumber == ushort.MaxValue) ? 4 : 0);
+            var currentIndex = 0;
+
+            if (bytesRequired > DataBytes.Length)
            {
-                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                throw new ArchiveException("Zip64 extended information extra field is not large enough for the required information");
            }

-            if (DataBytes.Length >= 16)
+            if (uncompressedFileSize == uint.MaxValue)
            {
-                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
            }

-            if (DataBytes.Length >= 24)
+            if (compressedFileSize == uint.MaxValue)
            {
-                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
+                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
            }

-            if (DataBytes.Length >= 28)
+            if (relativeHeaderOffset == uint.MaxValue)
            {
-                VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(24));
+                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
            }

-            switch (DataBytes.Length)
+            if (diskNumber == ushort.MaxValue)
            {
-                case 8:
-                case 16:
-                case 24:
-                case 28:
-                    break;
-                default:
-                    throw new ArchiveException($"Unexpected size of of Zip64 extended information extra field: {DataBytes.Length}");
+                VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(currentIndex));
            }
        }

+        /// <summary>
+        /// Uncompressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
        public long UncompressedSize { get; private set; }
+
+        /// <summary>
+        /// Compressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
        public long CompressedSize { get; private set; }
+
+        /// <summary>
+        /// Relative offset of the entry header. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFFFFFF value.
+        /// </summary>
        public long RelativeOffsetOfEntryHeader { get; private set; }
+
+        /// <summary>
+        /// Volume number. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
+        /// original entry header had a corresponding 0xFFFF value.
+        /// </summary>
        public uint VolumeNumber { get; private set; }
    }

--- a/src/SharpCompress/Common/Zip/Headers/SplitHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/SplitHeader.cs
@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -12,7 +10,7 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override ValueTask Read(Stream stream, CancellationToken cancellationToken)
+        internal override void Read(BinaryReader reader)
        {
            throw new NotImplementedException();
        }
--- a/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -11,18 +9,18 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override async ValueTask Read(Stream stream, CancellationToken cancellationToken)
+        internal override void Read(BinaryReader reader)
        {
-            SizeOfDirectoryEndRecord = (long)await stream.ReadUInt64(cancellationToken);
-            VersionMadeBy = await stream.ReadUInt16(cancellationToken);
-            VersionNeededToExtract = await stream.ReadUInt16(cancellationToken);
-            VolumeNumber = await stream.ReadUInt32(cancellationToken);
-            FirstVolumeWithDirectory = await stream.ReadUInt32(cancellationToken);
-            TotalNumberOfEntriesInDisk = (long)await stream.ReadUInt64(cancellationToken);
-            TotalNumberOfEntries = (long)await stream.ReadUInt64(cancellationToken);
-            DirectorySize = (long)await stream.ReadUInt64(cancellationToken);
-            DirectoryStartOffsetRelativeToDisk = (long)await stream.ReadUInt64(cancellationToken);
-            DataSector = await stream.ReadBytes((int)(SizeOfDirectoryEndRecord - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS), cancellationToken);
+            SizeOfDirectoryEndRecord = (long)reader.ReadUInt64();
+            VersionMadeBy = reader.ReadUInt16();
+            VersionNeededToExtract = reader.ReadUInt16();
+            VolumeNumber = reader.ReadUInt32();
+            FirstVolumeWithDirectory = reader.ReadUInt32();
+            TotalNumberOfEntriesInDisk = (long)reader.ReadUInt64();
+            TotalNumberOfEntries = (long)reader.ReadUInt64();
+            DirectorySize = (long)reader.ReadUInt64();
+            DirectoryStartOffsetRelativeToDisk = (long)reader.ReadUInt64();
+            DataSector = reader.ReadBytes((int)(SizeOfDirectoryEndRecord - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS));
        }

        private const int SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS = 44;
--- a/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndLocatorHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndLocatorHeader.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -11,11 +9,11 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override async ValueTask Read(Stream stream, CancellationToken cancellationToken)
+        internal override void Read(BinaryReader reader)
        {
-            FirstVolumeWithDirectory = await stream.ReadUInt32(cancellationToken);
-            RelativeOffsetOfTheEndOfDirectoryRecord = (long)await stream.ReadUInt64(cancellationToken);
-            TotalNumberOfVolumes = await stream.ReadUInt32(cancellationToken);
+            FirstVolumeWithDirectory = reader.ReadUInt32();
+            RelativeOffsetOfTheEndOfDirectoryRecord = (long)reader.ReadUInt64();
+            TotalNumberOfVolumes = reader.ReadUInt32();
        }

        public uint FirstVolumeWithDirectory { get; private set; }
--- a/src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs
+++ b/src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs
@@ -105,6 +105,6 @@ namespace SharpCompress.Common.Zip.Headers

        internal ZipFilePart Part { get; set; }

-        internal bool IsZip64 => CompressedSize == uint.MaxValue;
+        internal bool IsZip64 => CompressedSize >= uint.MaxValue;
    }
 }
--- a/src/SharpCompress/Common/Zip/Headers/ZipHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/ZipHeader.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -14,7 +12,7 @@ namespace SharpCompress.Common.Zip.Headers

        internal ZipHeaderType ZipHeaderType { get; }

-        internal abstract ValueTask Read(Stream stream, CancellationToken cancellationToken);
+        internal abstract void Read(BinaryReader reader);

        internal bool HasData { get; set; }
    }
--- a/src/SharpCompress/Common/Zip/SeekableZipFilePart.cs
+++ b/src/SharpCompress/Common/Zip/SeekableZipFilePart.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;

@@ -19,22 +17,22 @@ namespace SharpCompress.Common.Zip
            _directoryEntryHeader = header;
        }

-        internal override async ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken)
+        internal override Stream GetCompressedStream()
        {
            if (!_isLocalHeaderLoaded)
            {
-                await LoadLocalHeader(cancellationToken);
+                LoadLocalHeader();
                _isLocalHeaderLoaded = true;
            }
-            return await base.GetCompressedStreamAsync(cancellationToken);
+            return base.GetCompressedStream();
        }

        internal string? Comment => ((DirectoryEntryHeader)Header).Comment;

-        private async ValueTask LoadLocalHeader(CancellationToken cancellationToken)
+        private void LoadLocalHeader()
        {
            bool hasData = Header.HasData;
-            Header = await _headerFactory.GetLocalHeader(BaseStream, (DirectoryEntryHeader)Header, cancellationToken);
+            Header = _headerFactory.GetLocalHeader(BaseStream, ((DirectoryEntryHeader)Header));
            Header.HasData = hasData;
        }

--- a/src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs
+++ b/src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs
@@ -1,12 +1,7 @@
 using System;
-using System.Buffers;
 using System.Collections.Generic;
 using System.IO;
-using System.Runtime.CompilerServices;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
-using SharpCompress.Compressors.Xz;
 using SharpCompress.IO;

 namespace SharpCompress.Common.Zip
@@ -24,13 +19,15 @@ namespace SharpCompress.Common.Zip
        {
        }

-        internal async IAsyncEnumerable<ZipHeader> ReadSeekableHeader(Stream stream, [EnumeratorCancellation]CancellationToken cancellationToken)
+        internal IEnumerable<ZipHeader> ReadSeekableHeader(Stream stream)
        {
-            await SeekBackToHeaderAsync(stream);
+            var reader = new BinaryReader(stream);
+
+            SeekBackToHeader(stream, reader);

            var eocd_location = stream.Position;
            var entry = new DirectoryEndHeader();
-            await entry.Read(stream, cancellationToken);
+            entry.Read(reader);

            if (entry.IsZip64)
            {
@@ -38,37 +35,37 @@ namespace SharpCompress.Common.Zip

                // ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR should be before the EOCD
                stream.Seek(eocd_location - ZIP64_EOCD_LENGTH - 4, SeekOrigin.Begin);
-                uint zip64_locator = await stream.ReadUInt32(cancellationToken);
-                if( zip64_locator != ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR )
+                uint zip64_locator = reader.ReadUInt32();
+                if (zip64_locator != ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR)
                {
                    throw new ArchiveException("Failed to locate the Zip64 Directory Locator");
                }

                var zip64Locator = new Zip64DirectoryEndLocatorHeader();
-                await zip64Locator.Read(stream, cancellationToken);
+                zip64Locator.Read(reader);

                stream.Seek(zip64Locator.RelativeOffsetOfTheEndOfDirectoryRecord, SeekOrigin.Begin);
-                uint zip64Signature = await stream.ReadUInt32(cancellationToken);
+                uint zip64Signature = reader.ReadUInt32();
                if (zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
                {
                    throw new ArchiveException("Failed to locate the Zip64 Header");
                }

                var zip64Entry = new Zip64DirectoryEndHeader();
-                await zip64Entry.Read(stream, cancellationToken);
+                zip64Entry.Read(reader);
                stream.Seek(zip64Entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
            }
            else
            {
-                stream.Seek(entry.DirectoryStartOffsetRelativeToDisk ?? 0, SeekOrigin.Begin);
+                stream.Seek(entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
            }

            long position = stream.Position;
            while (true)
            {
                stream.Position = position;
-                uint signature = await stream.ReadUInt32(cancellationToken);
-                var nextHeader = await ReadHeader(signature, stream, cancellationToken, _zip64);
+                uint signature = reader.ReadUInt32();
+                var nextHeader = ReadHeader(signature, reader, _zip64);
                position = stream.Position;

                if (nextHeader is null)
@@ -89,11 +86,11 @@ namespace SharpCompress.Common.Zip
            }
        }

-        private static bool IsMatch (Span<byte> haystack, int position, byte[] needle)
+        private static bool IsMatch(byte[] haystack, int position, byte[] needle)
        {
-            for( int i = 0; i < needle.Length; i++ )
+            for (int i = 0; i < needle.Length; i++)
            {
-                if( haystack[ position + i ] != needle[ i ] )
+                if (haystack[position + i] != needle[i])
                {
                    return false;
                }
@@ -101,7 +98,7 @@ namespace SharpCompress.Common.Zip

            return true;
        }
-        private static async ValueTask SeekBackToHeaderAsync(Stream stream)
+        private static void SeekBackToHeader(Stream stream, BinaryReader reader)
        {
            // Minimum EOCD length
            if (stream.Length < MINIMUM_EOCD_LENGTH)
@@ -115,18 +112,17 @@ namespace SharpCompress.Common.Zip

            stream.Seek(-len, SeekOrigin.End);

-            using var rented = MemoryPool<byte>.Shared.Rent(len);
-            var buffer = rented.Memory.Slice(0, len);
-            await stream.ReadAsync(buffer);
+            byte[] seek = reader.ReadBytes(len);

            // Search in reverse
-            buffer.Span.Reverse();
+            Array.Reverse(seek);

-            var max_search_area = len - MINIMUM_EOCD_LENGTH;
+            // don't exclude the minimum eocd region, otherwise you fail to locate the header in empty zip files
+            var max_search_area = len; // - MINIMUM_EOCD_LENGTH;

-            for( int pos_from_end = 0; pos_from_end < max_search_area; ++pos_from_end)
+            for (int pos_from_end = 0; pos_from_end < max_search_area; ++pos_from_end)
            {
-                if( IsMatch( buffer.Span, pos_from_end, needle) )
+                if (IsMatch(seek, pos_from_end, needle))
                {
                    stream.Seek(-pos_from_end, SeekOrigin.End);
                    return;
@@ -136,11 +132,12 @@ namespace SharpCompress.Common.Zip
            throw new ArchiveException("Failed to locate the Zip Header");
        }

-        internal async ValueTask<LocalEntryHeader> GetLocalHeader(Stream stream, DirectoryEntryHeader directoryEntryHeader, CancellationToken cancellationToken)
+        internal LocalEntryHeader GetLocalHeader(Stream stream, DirectoryEntryHeader directoryEntryHeader)
        {
            stream.Seek(directoryEntryHeader.RelativeOffsetOfEntryHeader, SeekOrigin.Begin);
-            uint signature = await stream.ReadUInt32(cancellationToken);
-            var localEntryHeader = await ReadHeader(signature, stream, cancellationToken, _zip64) as LocalEntryHeader;
+            BinaryReader reader = new BinaryReader(stream);
+            uint signature = reader.ReadUInt32();
+            var localEntryHeader = ReadHeader(signature, reader, _zip64) as LocalEntryHeader;
            if (localEntryHeader is null)
            {
                throw new InvalidOperationException();
--- a/src/SharpCompress/Common/Zip/StreamingZipFilePart.cs
+++ b/src/SharpCompress/Common/Zip/StreamingZipFilePart.cs
@@ -1,6 +1,4 @@
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
+using System.IO;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
@@ -21,39 +19,67 @@ namespace SharpCompress.Common.Zip
            return Header.PackedStream;
        }

-        internal override async ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken)
+        internal override Stream GetCompressedStream()
        {
            if (!Header.HasData)
            {
                return Stream.Null;
            }
-            _decompressionStream = await CreateDecompressionStream(GetCryptoStream(CreateBaseStream()), Header.CompressionMethod, cancellationToken);
+            _decompressionStream = CreateDecompressionStream(GetCryptoStream(CreateBaseStream()), Header.CompressionMethod);
            if (LeaveStreamOpen)
            {
-                return new NonDisposingStream(_decompressionStream);
+                return NonDisposingStream.Create(_decompressionStream);
            }
            return _decompressionStream;
        }

-        internal async ValueTask FixStreamedFileLocation(RewindableStream rewindableStream, CancellationToken cancellationToken)
+        internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream)
        {
            if (Header.IsDirectory)
            {
-                return;
+                return new BinaryReader(rewindableStream);
            }
            if (Header.HasData && !Skipped)
            {
-                _decompressionStream ??= await GetCompressedStreamAsync(cancellationToken);
+                _decompressionStream ??= GetCompressedStream();

-                await _decompressionStream.SkipAsync(cancellationToken);
-
-                if (_decompressionStream is DeflateStream deflateStream)
+                if( Header.CompressionMethod != ZipCompressionMethod.None )
                {
-                    rewindableStream.Rewind(deflateStream.InputBuffer);
+                    _decompressionStream.Skip();
+
+                    if (_decompressionStream is DeflateStream deflateStream)
+                    {
+                        rewindableStream.Rewind(deflateStream.InputBuffer);
+                    }
                }
+                else
+                {
+                    // We would need to search for the magic word
+                    rewindableStream.Position -= 4;
+                    var pos = rewindableStream.Position;
+                    while( Utility.Find(rewindableStream, new byte[] { 0x50,0x4b,0x07,0x08 } ) )
+                    {
+                        // We should probably check CRC32 for positive matching as well
+                        var size = rewindableStream.Position - pos;
+                        var br = new BinaryReader(rewindableStream);
+                        br.ReadUInt32();
+                        br.ReadUInt32(); // CRC32
+                        var compressed_size = br.ReadUInt32();
+                        var uncompressed_size = br.ReadUInt32();
+                        if (compressed_size == size && compressed_size == uncompressed_size )
+                        {
+                            rewindableStream.Position -= 16;
+                            break;
+                        }
+                        rewindableStream.Position -= 12;
+                    }
+                }
+
                Skipped = true;
            }
+            var reader = new BinaryReader(rewindableStream);
            _decompressionStream = null;
+            return reader;
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs
+++ b/src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs
@@ -1,6 +1,5 @@
 using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-using System.Threading;
+using System.IO;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;

@@ -13,36 +12,43 @@ namespace SharpCompress.Common.Zip
        {
        }

-        internal async IAsyncEnumerable<ZipHeader> ReadStreamHeader(RewindableStream rewindableStream, [EnumeratorCancellation] CancellationToken cancellationToken)
+        internal IEnumerable<ZipHeader> ReadStreamHeader(Stream stream)
        {
+            RewindableStream rewindableStream;
+
+            if (stream is RewindableStream rs)
+            {
+                rewindableStream = rs;
+            }
+            else
+            {
+                rewindableStream = new RewindableStream(stream);
+            }
            while (true)
            {
                ZipHeader? header;
+                BinaryReader reader = new BinaryReader(rewindableStream);
                if (_lastEntryHeader != null &&
                    (FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || _lastEntryHeader.IsZip64))
                {
-                    await ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(rewindableStream, cancellationToken);
+                    reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(ref rewindableStream);
                    long? pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
-                    uint crc = await rewindableStream.ReadUInt32(cancellationToken);
+                    uint crc = reader.ReadUInt32();
                    if (crc == POST_DATA_DESCRIPTOR)
                    {
-                        crc = await rewindableStream.ReadUInt32(cancellationToken);
+                        crc = reader.ReadUInt32();
                    }
                    _lastEntryHeader.Crc = crc;
-                    _lastEntryHeader.CompressedSize = await rewindableStream.ReadUInt32(cancellationToken);
-                    _lastEntryHeader.UncompressedSize = await rewindableStream.ReadUInt32(cancellationToken);
+                    _lastEntryHeader.CompressedSize = reader.ReadUInt32();
+                    _lastEntryHeader.UncompressedSize = reader.ReadUInt32();
                    if (pos.HasValue)
                    {
                        _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
                    }
                }
                _lastEntryHeader = null;
-                var headerBytes = await rewindableStream.ReadUInt32OrNull(cancellationToken);
-                if (headerBytes is null)
-                {
-                    yield break;
-                }
-                header = await ReadHeader(headerBytes.Value, rewindableStream, cancellationToken);
+                uint headerBytes = reader.ReadUInt32();
+                header = ReadHeader(headerBytes, reader);
                if (header is null)
                {
                    yield break;
@@ -65,10 +71,10 @@ namespace SharpCompress.Common.Zip
                        {
                            rewindableStream.StartRecording();
                        }
-                        uint nextHeaderBytes = await rewindableStream.ReadUInt32(cancellationToken);
+                        uint nextHeaderBytes = reader.ReadUInt32();

                        // Check if next data is PostDataDescriptor, streamed file with 0 length
-                        header.HasData = nextHeaderBytes != POST_DATA_DESCRIPTOR;
+                        header.HasData = !IsHeader(nextHeaderBytes);
                        rewindableStream.Rewind(!isRecording);
                    }
                    else // We are not streaming and compressed size is 0, we have no data
--- a/src/SharpCompress/Common/Zip/ZipFilePart.cs
+++ b/src/SharpCompress/Common/Zip/ZipFilePart.cs
@@ -1,16 +1,14 @@
-using System;
+using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.BZip2;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.Compressors.Deflate64;
 using SharpCompress.Compressors.LZMA;
-//using SharpCompress.Compressors.PPMd;
+using SharpCompress.Compressors.PPMd;
 using SharpCompress.IO;

 namespace SharpCompress.Common.Zip
@@ -30,16 +28,16 @@ namespace SharpCompress.Common.Zip

        internal override string FilePartName => Header.Name;

-        internal override async ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken)
+        internal override Stream GetCompressedStream()
        {
            if (!Header.HasData)
            {
                return Stream.Null;
            }
-            Stream decompressionStream = await CreateDecompressionStream(GetCryptoStream(CreateBaseStream()), Header.CompressionMethod, cancellationToken);
+            Stream decompressionStream = CreateDecompressionStream(GetCryptoStream(CreateBaseStream()), Header.CompressionMethod);
            if (LeaveStreamOpen)
            {
-                return new NonDisposingStream(decompressionStream);
+                return NonDisposingStream.Create(decompressionStream);
            }
            return decompressionStream;
        }
@@ -57,7 +55,7 @@ namespace SharpCompress.Common.Zip

        protected bool LeaveStreamOpen => FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor) || Header.IsZip64;

-        protected async ValueTask<Stream> CreateDecompressionStream(Stream stream, ZipCompressionMethod method, CancellationToken cancellationToken)
+        protected Stream CreateDecompressionStream(Stream stream, ZipCompressionMethod method)
        {
            switch (method)
            {
@@ -75,29 +73,30 @@ namespace SharpCompress.Common.Zip
                    }
                case ZipCompressionMethod.BZip2:
                    {
-                        return await BZip2Stream.CreateAsync(stream, CompressionMode.Decompress, false, cancellationToken);
-                    }                                                                                          
+                        return new BZip2Stream(stream, CompressionMode.Decompress, false);
+                    }
                case ZipCompressionMethod.LZMA:
                    {
                        if (FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted))
                        {
                            throw new NotSupportedException("LZMA with pkware encryption.");
                        }
-                        await stream.ReadUInt16(cancellationToken); //LZMA version
-                        var props = new byte[await stream.ReadUInt16(cancellationToken)];
-                        await stream.ReadAsync(props, 0, props.Length, cancellationToken);
-                        return await LzmaStream.CreateAsync(props, stream,
+                        var reader = new BinaryReader(stream);
+                        reader.ReadUInt16(); //LZMA version
+                        var props = new byte[reader.ReadUInt16()];
+                        reader.Read(props, 0, props.Length);
+                        return new LzmaStream(props, stream,
                                              Header.CompressedSize > 0 ? Header.CompressedSize - 4 - props.Length : -1,
                                              FlagUtility.HasFlag(Header.Flags, HeaderFlags.Bit1)
                                                  ? -1
-                                                  : (long)Header.UncompressedSize,
-                                              cancellationToken: cancellationToken);
+                                                  : (long)Header.UncompressedSize);
                    }
-              /*  case ZipCompressionMethod.PPMd:
-                {
-                    var props = await stream.ReadBytes(2, cancellationToken);
+                case ZipCompressionMethod.PPMd:
+                    {
+                        Span<byte> props = stackalloc byte[2];
+                        stream.ReadFully(props);
                        return new PpmdStream(new PpmdProperties(props), stream, false);
-                    }  */
+                    }
                case ZipCompressionMethod.WinzipAes:
                    {
                        ExtraData? data = Header.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
@@ -121,7 +120,7 @@ namespace SharpCompress.Common.Zip
                        {
                            throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata");
                        }
-                        return await CreateDecompressionStream(stream, (ZipCompressionMethod)BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(5)), cancellationToken);
+                        return CreateDecompressionStream(stream, (ZipCompressionMethod)BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(5)));
                    }
                default:
                    {
@@ -143,7 +142,7 @@ namespace SharpCompress.Common.Zip
                && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
                || Header.IsZip64)
            {
-                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close
+                plainStream = NonDisposingStream.Create(plainStream); //make sure AES doesn't close
            }
            else
            {
@@ -175,7 +174,7 @@ namespace SharpCompress.Common.Zip

                    default:
                        {
-                            throw new ArgumentOutOfRangeException();
+                            throw new InvalidOperationException("Header.CompressionMethod is invalid");
                        }

                }
--- a/src/SharpCompress/Common/Zip/ZipHeaderFactory.cs
+++ b/src/SharpCompress/Common/Zip/ZipHeaderFactory.cs
@@ -1,8 +1,6 @@
 using System;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;

@@ -32,15 +30,15 @@ namespace SharpCompress.Common.Zip
            this._archiveEncoding = archiveEncoding;
        }

-        protected async ValueTask<ZipHeader?> ReadHeader(uint headerBytes, Stream stream, CancellationToken cancellationToken, bool zip64 = false)
+        protected ZipHeader? ReadHeader(uint headerBytes, BinaryReader reader, bool zip64 = false)
        {
            switch (headerBytes)
            {
                case ENTRY_HEADER_BYTES:
                    {
                        var entryHeader = new LocalEntryHeader(_archiveEncoding);
-                        await entryHeader.Read(stream, cancellationToken);
-                        await LoadHeader(entryHeader, stream, cancellationToken);
+                        entryHeader.Read(reader);
+                        LoadHeader(entryHeader, reader.BaseStream);

                        _lastEntryHeader = entryHeader;
                        return entryHeader;
@@ -48,20 +46,20 @@ namespace SharpCompress.Common.Zip
                case DIRECTORY_START_HEADER_BYTES:
                    {
                        var entry = new DirectoryEntryHeader(_archiveEncoding);
-                        await entry.Read(stream, cancellationToken);
+                        entry.Read(reader);
                        return entry;
                    }
                case POST_DATA_DESCRIPTOR:
                    {
                        if (FlagUtility.HasFlag(_lastEntryHeader!.Flags, HeaderFlags.UsePostDataDescriptor))
                        {
-                            _lastEntryHeader.Crc = await stream.ReadUInt32(cancellationToken);
-                            _lastEntryHeader.CompressedSize = zip64 ? (long)await stream.ReadUInt64(cancellationToken) : await stream.ReadUInt32(cancellationToken);
-                            _lastEntryHeader.UncompressedSize = zip64 ? (long)await stream.ReadUInt64(cancellationToken) : await stream.ReadUInt32(cancellationToken);
+                            _lastEntryHeader.Crc = reader.ReadUInt32();
+                            _lastEntryHeader.CompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
+                            _lastEntryHeader.UncompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
                        }
                        else
                        {
-                            await stream.ReadBytes(zip64 ? 20 : 12, cancellationToken);
+                            reader.ReadBytes(zip64 ? 20 : 12);
                        }
                        return null;
                    }
@@ -70,7 +68,7 @@ namespace SharpCompress.Common.Zip
                case DIRECTORY_END_HEADER_BYTES:
                    {
                        var entry = new DirectoryEndHeader();
-                        await entry.Read(stream, cancellationToken);
+                        entry.Read(reader);
                        return entry;
                    }
                case SPLIT_ARCHIVE_HEADER_BYTES:
@@ -80,13 +78,13 @@ namespace SharpCompress.Common.Zip
                case ZIP64_END_OF_CENTRAL_DIRECTORY:
                    {
                        var entry = new Zip64DirectoryEndHeader();
-                        await entry.Read(stream, cancellationToken);
+                        entry.Read(reader);
                        return entry;
                    }
                case ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR:
                    {
                        var entry = new Zip64DirectoryEndLocatorHeader();
-                        await entry.Read(stream, cancellationToken);
+                        entry.Read(reader);
                        return entry;
                    }
                default:
@@ -112,7 +110,7 @@ namespace SharpCompress.Common.Zip
            }
        }

-        private async ValueTask LoadHeader(ZipFileEntry entryHeader, Stream stream, CancellationToken cancellationToken)
+        private void LoadHeader(ZipFileEntry entryHeader, Stream stream)
        {
            if (FlagUtility.HasFlag(entryHeader.Flags, HeaderFlags.Encrypted))
            {
@@ -136,8 +134,10 @@ namespace SharpCompress.Common.Zip
                    {
                        var keySize = (WinzipAesKeySize)data.DataBytes[4];

-                        var salt = await stream.ReadBytes(WinzipAesEncryptionData.KeyLengthInBytes(keySize) / 2, cancellationToken);
-                        var passwordVerifyValue = await stream.ReadBytes(2, cancellationToken);
+                        var salt = new byte[WinzipAesEncryptionData.KeyLengthInBytes(keySize) / 2];
+                        var passwordVerifyValue = new byte[2];
+                        stream.Read(salt, 0, salt.Length);
+                        stream.Read(passwordVerifyValue, 0, 2);
                        entryHeader.WinzipAesEncryptionData =
                            new WinzipAesEncryptionData(keySize, salt, passwordVerifyValue, _password);

--- a/src/SharpCompress/Common/Zip/ZipVolume.cs
+++ b/src/SharpCompress/Common/Zip/ZipVolume.cs
@@ -1,15 +1,15 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Common.Zip
 {
    public class ZipVolume : Volume
    {
-        public ZipVolume(Stream stream, ReaderOptions readerOptions)
-            : base(stream, readerOptions)
+        public ZipVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+            : base(stream, readerOptions, index)
        {
        }

        public string? Comment { get; internal set; }
    }
-}
+}
--- a/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs
+++ b/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs
@@ -1,13 +1,9 @@
 using System;
-using System.Buffers;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;

 namespace SharpCompress.Compressors.BZip2
 {
-    public sealed class BZip2Stream : AsyncStream
+    public sealed class BZip2Stream : Stream
    {
        private readonly Stream stream;
        private bool isDisposed;
@@ -37,14 +33,17 @@ namespace SharpCompress.Compressors.BZip2
            (stream as CBZip2OutputStream)?.Finish();
        }

-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
        {
            if (isDisposed)
            {
                return;
            }
            isDisposed = true;
-            await stream.DisposeAsync();
+            if (disposing)
+            {
+                stream.Dispose();
+            }
        }

        public CompressionMode Mode { get; }
@@ -55,18 +54,23 @@ namespace SharpCompress.Compressors.BZip2

        public override bool CanWrite => stream.CanWrite;

-        public override Task FlushAsync(CancellationToken cancellationToken)
+        public override void Flush()
        {
-            return stream.FlushAsync(cancellationToken);
+            stream.Flush();
        }

        public override long Length => stream.Length;

        public override long Position { get => stream.Position; set => stream.Position = value; }

-        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        public override int Read(byte[] buffer, int offset, int count)
        {
-            return stream.ReadAsync(buffer, cancellationToken);
+            return stream.Read(buffer, offset, count);
+        }
+
+        public override int ReadByte()
+        {
+            return stream.ReadByte();
        }

        public override long Seek(long offset, SeekOrigin origin)
@@ -79,14 +83,28 @@ namespace SharpCompress.Compressors.BZip2
            stream.SetLength(value);
        }

-        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+
+        public override int Read(Span<byte> buffer)
        {
-            return stream.WriteAsync(buffer, offset, count, cancellationToken);
+            return stream.Read(buffer);
        }

-        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = new CancellationToken())
+        public override void Write(ReadOnlySpan<byte> buffer)
        {
-            return stream.WriteAsync(buffer, cancellationToken);
+            stream.Write(buffer);
+        }
+
+#endif
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            stream.Write(buffer, offset, count);
+        }
+
+        public override void WriteByte(byte value)
+        {
+            stream.WriteByte(value);
        }

        /// <summary>
@@ -94,16 +112,15 @@ namespace SharpCompress.Compressors.BZip2
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
-        public static async ValueTask<bool> IsBZip2Async(Stream stream, CancellationToken cancellationToken)
+        public static bool IsBZip2(Stream stream)
        {
-            using var rented = MemoryPool<byte>.Shared.Rent(2);
-            var chars = rented.Memory.Slice(0, 2);
-            await stream.ReadAsync(chars, cancellationToken);
-            if (chars.Length < 2 || chars.Span[0] != 'B' || chars.Span[1] != 'Z')
+            BinaryReader br = new BinaryReader(stream);
+            byte[] chars = br.ReadBytes(2);
+            if (chars.Length < 2 || chars[0] != 'B' || chars[1] != 'Z')
            {
                return false;
            }
            return true;
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/Deflate/DeflateStream.cs
+++ b/src/SharpCompress/Compressors/Deflate/DeflateStream.cs
@@ -27,13 +27,10 @@
 using System;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;

 namespace SharpCompress.Compressors.Deflate
 {
-    public class DeflateStream : AsyncStream
+    public class DeflateStream : Stream
    {
        private readonly ZlibBaseStream _baseStream;
        private bool _disposed;
@@ -219,25 +216,35 @@ namespace SharpCompress.Compressors.Deflate
        /// <remarks>
        /// This may or may not result in a <c>Close()</c> call on the captive stream.
        /// </remarks>
-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
        {
-            if (!_disposed)
+            try
            {
-                await _baseStream.DisposeAsync();
-                _disposed = true;
+                if (!_disposed)
+                {
+                    if (disposing)
+                    {
+                        _baseStream?.Dispose();
+                    }
+                    _disposed = true;
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
            }
        }

        /// <summary>
        /// Flush the stream.
        /// </summary>
-        public override async Task FlushAsync(CancellationToken cancellationToken)
+        public override void Flush()
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("DeflateStream");
            }
-            await _baseStream.FlushAsync(cancellationToken);
+            _baseStream.Flush();
        }

        /// <summary>
@@ -266,14 +273,24 @@ namespace SharpCompress.Compressors.Deflate
        /// <param name="offset">the offset within that data array to put the first byte read.</param>
        /// <param name="count">the number of bytes to read.</param>
        /// <returns>the number of bytes actually read</returns>
-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override int Read(byte[] buffer, int offset, int count)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("DeflateStream");
            }
-            return await _baseStream.ReadAsync(buffer, offset, count, cancellationToken);
+            return _baseStream.Read(buffer, offset, count);
        }
+
+        public override int ReadByte()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException("DeflateStream");
+            }
+            return _baseStream.ReadByte();
+        }
+
        /// <summary>
        /// Calling this method always throws a <see cref="NotImplementedException"/>.
        /// </summary>
@@ -323,13 +340,22 @@ namespace SharpCompress.Compressors.Deflate
        /// <param name="buffer">The buffer holding data to write to the stream.</param>
        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
        /// <param name="count">the number of bytes to write.</param>
-        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override void Write(byte[] buffer, int offset, int count)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("DeflateStream");
            }
-            await _baseStream.WriteAsync(buffer, offset, count, cancellationToken);
+            _baseStream.Write(buffer, offset, count);
+        }
+
+        public override void WriteByte(byte value)
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException("DeflateStream");
+            }
+            _baseStream.WriteByte(value);
        }

        #endregion
--- a/src/SharpCompress/Compressors/Deflate/GZipStream.cs
+++ b/src/SharpCompress/Compressors/Deflate/GZipStream.cs
@@ -27,25 +27,21 @@
 // ------------------------------------------------------------------

 using System;
-using System.Buffers;
 using System.Buffers.Binary;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;

 namespace SharpCompress.Compressors.Deflate
 {
-    public class GZipStream : AsyncStream
+    public class GZipStream : Stream
    {
-        private static readonly DateTime UNIX_EPOCH = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        internal static readonly DateTime UNIX_EPOCH = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

        private string? _comment;
        private string? _fileName;
        private DateTime? _lastModified;

-        private readonly ZlibBaseStream _baseStream;
+        internal ZlibBaseStream BaseStream;
        private bool _disposed;
        private bool _firstReadDone;
        private int _headerByteCount;
@@ -64,7 +60,7 @@ namespace SharpCompress.Compressors.Deflate

        public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, Encoding encoding)
        {
-            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, encoding);
+            BaseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, encoding);
            _encoding = encoding;
        }

@@ -72,27 +68,27 @@ namespace SharpCompress.Compressors.Deflate

        public virtual FlushType FlushMode
        {
-            get => (_baseStream._flushMode);
+            get => (BaseStream._flushMode);
            set
            {
                if (_disposed)
                {
                    throw new ObjectDisposedException("GZipStream");
                }
-                _baseStream._flushMode = value;
+                BaseStream._flushMode = value;
            }
        }

        public int BufferSize
        {
-            get => _baseStream._bufferSize;
+            get => BaseStream._bufferSize;
            set
            {
                if (_disposed)
                {
                    throw new ObjectDisposedException("GZipStream");
                }
-                if (_baseStream._workingBuffer != null)
+                if (BaseStream._workingBuffer != null)
                {
                    throw new ZlibException("The working buffer is already set.");
                }
@@ -102,13 +98,13 @@ namespace SharpCompress.Compressors.Deflate
                                            String.Format("Don't be silly. {0} bytes?? Use a bigger buffer, at least {1}.", value,
                                                          ZlibConstants.WorkingBufferSizeMin));
                }
-                _baseStream._bufferSize = value;
+                BaseStream._bufferSize = value;
            }
        }

-        internal virtual long TotalIn => _baseStream._z.TotalBytesIn;
+        internal virtual long TotalIn => BaseStream._z.TotalBytesIn;

-        internal virtual long TotalOut => _baseStream._z.TotalBytesOut;
+        internal virtual long TotalOut => BaseStream._z.TotalBytesOut;

        #endregion

@@ -128,7 +124,7 @@ namespace SharpCompress.Compressors.Deflate
                {
                    throw new ObjectDisposedException("GZipStream");
                }
-                return _baseStream._stream.CanRead;
+                return BaseStream._stream.CanRead;
            }
        }

@@ -154,7 +150,7 @@ namespace SharpCompress.Compressors.Deflate
                {
                    throw new ObjectDisposedException("GZipStream");
                }
-                return _baseStream._stream.CanWrite;
+                return BaseStream._stream.CanWrite;
            }
        }

@@ -178,13 +174,13 @@ namespace SharpCompress.Compressors.Deflate
        {
            get
            {
-                if (_baseStream._streamMode == ZlibBaseStream.StreamMode.Writer)
+                if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Writer)
                {
-                    return _baseStream._z.TotalBytesOut + _headerByteCount;
+                    return BaseStream._z.TotalBytesOut + _headerByteCount;
                }
-                if (_baseStream._streamMode == ZlibBaseStream.StreamMode.Reader)
+                if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Reader)
                {
-                    return _baseStream._z.TotalBytesIn + _baseStream._gzipHeaderByteCount;
+                    return BaseStream._z.TotalBytesIn + BaseStream._gzipHeaderByteCount;
                }
                return 0;
            }
@@ -198,29 +194,36 @@ namespace SharpCompress.Compressors.Deflate
        /// <remarks>
        /// This may or may not result in a <c>Close()</c> call on the captive stream.
        /// </remarks>
-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
+        {
+            try
            {
                if (!_disposed)
                {
-                    if (_baseStream is not null)
+                    if (disposing && (BaseStream != null))
                    {
-                        await _baseStream.DisposeAsync();
-                        Crc32 = _baseStream.Crc32;
+                        BaseStream.Dispose();
+                        Crc32 = BaseStream.Crc32;
                    }
                    _disposed = true;
                }
            }
+            finally
+            {
+                base.Dispose(disposing);
+            }
+        }

        /// <summary>
        /// Flush the stream.
        /// </summary>
-        public override Task FlushAsync(CancellationToken cancellationToken)
+        public override void Flush()
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("GZipStream");
            }
-            return _baseStream.FlushAsync(cancellationToken);
+            BaseStream.Flush();
        }

        /// <summary>
@@ -254,13 +257,13 @@ namespace SharpCompress.Compressors.Deflate
        /// <param name="offset">the offset within that data array to put the first byte read.</param>
        /// <param name="count">the number of bytes to read.</param>
        /// <returns>the number of bytes actually read</returns>
-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override int Read(byte[] buffer, int offset, int count)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("GZipStream");
            }
-            int n = await _baseStream.ReadAsync(buffer, offset, count, cancellationToken);
+            int n = BaseStream.Read(buffer, offset, count);

            // Console.WriteLine("GZipStream::Read(buffer, off({0}), c({1}) = {2}", offset, count, n);
            // Console.WriteLine( Util.FormatByteArray(buffer, offset, n) );
@@ -268,9 +271,9 @@ namespace SharpCompress.Compressors.Deflate
            if (!_firstReadDone)
            {
                _firstReadDone = true;
-                FileName = _baseStream._GzipFileName;
-                Comment = _baseStream._GzipComment;
-                LastModified = _baseStream._GzipMtime;
+                FileName = BaseStream._GzipFileName;
+                Comment = BaseStream._GzipComment;
+                LastModified = BaseStream._GzipMtime;
            }
            return n;
        }
@@ -317,19 +320,19 @@ namespace SharpCompress.Compressors.Deflate
        /// <param name="buffer">The buffer holding data to write to the stream.</param>
        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
        /// <param name="count">the number of bytes to write.</param>
-        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override void Write(byte[] buffer, int offset, int count)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("GZipStream");
            }
-            if (_baseStream._streamMode == ZlibBaseStream.StreamMode.Undefined)
+            if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Undefined)
            {
                //Console.WriteLine("GZipStream: First write");
-                if (_baseStream._wantCompress)
+                if (BaseStream._wantCompress)
                {
                    // first write in compression, therefore, emit the GZIP header
-                    _headerByteCount = await EmitHeaderAsync();
+                    _headerByteCount = EmitHeader();
                }
                else
                {
@@ -337,7 +340,7 @@ namespace SharpCompress.Compressors.Deflate
                }
            }

-            await _baseStream.WriteAsync(buffer, offset, count, cancellationToken);
+            BaseStream.Write(buffer, offset, count);
        }

        #endregion Stream methods
@@ -402,7 +405,7 @@ namespace SharpCompress.Compressors.Deflate

        public int Crc32 { get; private set; }

-        private async ValueTask<int> EmitHeaderAsync()
+        private int EmitHeader()
        {
            byte[]? commentBytes = (Comment is null) ? null
                : _encoding.GetBytes(Comment);
@@ -471,7 +474,7 @@ namespace SharpCompress.Compressors.Deflate
                header[i++] = 0; // terminate
            }

-            await _baseStream._stream.WriteAsync(header, 0, header.Length);
+            BaseStream._stream.Write(header, 0, header.Length);

            return header.Length; // bytes written
        }
--- a/src/SharpCompress/Compressors/Deflate/Zlib.cs
+++ b/src/SharpCompress/Compressors/Deflate/Zlib.cs
@@ -1,20 +1,20 @@
 // Zlib.cs
 // ------------------------------------------------------------------
 //
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
 // All rights reserved.
 //
 // This code module is part of DotNetZip, a zipfile class library.
 //
 // ------------------------------------------------------------------
 //
-// This code is licensed under the Microsoft Public License. 
+// This code is licensed under the Microsoft Public License.
 // See the file License.txt for the license details.
 // More info on: http://dotnetzip.codeplex.com
 //
 // ------------------------------------------------------------------
 //
-// last saved (in emacs): 
+// last saved (in emacs):
 // Time-stamp: <2009-November-07 05:26:55>
 //
 // ------------------------------------------------------------------
@@ -27,22 +27,22 @@
 // included below.
 //
 // ------------------------------------------------------------------
-// 
+//
 // Copyright (c) 2000,2001,2002,2003 ymnk, JCraft,Inc. All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are met:
-// 
+//
 // 1. Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
-// 
-// 2. Redistributions in binary form must reproduce the above copyright 
-// notice, this list of conditions and the following disclaimer in 
+//
+// 2. Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in
 // the documentation and/or other materials provided with the distribution.
-// 
+//
 // 3. The names of the authors may not be used to endorse or promote products
 // derived from this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 // FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
@@ -53,7 +53,7 @@
 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 // EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// 
+//
 // -----------------------------------------------------------------------
 //
 // This program is based on zlib-1.1.3; credit to authors
@@ -82,7 +82,7 @@ namespace SharpCompress.Compressors.Deflate
        /// <summary>
        /// Same as None.
        /// </summary>
-        Level0 = 0,
+        Level0 = None,

        /// <summary>
        /// The fastest but least effective compression.
@@ -92,7 +92,7 @@ namespace SharpCompress.Compressors.Deflate
        /// <summary>
        /// A synonym for BestSpeed.
        /// </summary>
-        Level1 = 1,
+        Level1 = BestSpeed,

        /// <summary>
        /// A little slower, but better, than level 1.
@@ -115,14 +115,14 @@ namespace SharpCompress.Compressors.Deflate
        Level5 = 5,

        /// <summary>
-        /// The default compression level, with a good balance of speed and compression efficiency.   
+        /// The default compression level, with a good balance of speed and compression efficiency.
        /// </summary>
        Default = 6,

        /// <summary>
        /// A synonym for Default.
        /// </summary>
-        Level6 = 6,
+        Level6 = Default,

        /// <summary>
        /// Pretty good compression!
@@ -135,7 +135,7 @@ namespace SharpCompress.Compressors.Deflate
        Level8 = 8,

        /// <summary>
-        /// The "best" compression, where best means greatest reduction in size of the input data stream. 
+        /// The "best" compression, where best means greatest reduction in size of the input data stream.
        /// This is also the slowest compression.
        /// </summary>
        BestCompression = 9,
@@ -143,7 +143,7 @@ namespace SharpCompress.Compressors.Deflate
        /// <summary>
        /// A synonym for BestCompression.
        /// </summary>
-        Level9 = 9
+        Level9 = BestCompression
    }

    /// <summary>
@@ -154,7 +154,7 @@ namespace SharpCompress.Compressors.Deflate
    public enum CompressionStrategy
    {
        /// <summary>
-        /// The default strategy is probably the best for normal data. 
+        /// The default strategy is probably the best for normal data.
        /// </summary>
        Default = 0,

@@ -181,7 +181,7 @@ namespace SharpCompress.Compressors.Deflate
    {
        /// <summary>
        /// The ZlibException class captures exception information generated
-        /// by the Zlib library. 
+        /// by the Zlib library.
        /// </summary>
        public ZlibException()
        {
@@ -233,7 +233,7 @@ namespace SharpCompress.Compressors.Deflate
        /// <param name="target">Contains the array of characteres read from the source TextReader.</param>
        /// <param name="start">The starting index of the target array.</param>
        /// <param name="count">The maximum number of characters to read from the source TextReader.</param>
-        /// 
+        ///
        /// <returns>
        ///   The number of characters read. The number will be less than or equal to
        ///   count depending on the data available in the source TextReader. Returns -1
@@ -405,4 +405,4 @@ namespace SharpCompress.Compressors.Deflate
            BitLengths = new StaticTree(null, extra_blbits, 0, InternalConstants.BL_CODES, InternalConstants.MAX_BL_BITS);
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs
+++ b/src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs
@@ -27,15 +27,11 @@
 // ------------------------------------------------------------------

 using System;
-using System.Buffers;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;

 namespace SharpCompress.Compressors.Deflate
 {
@@ -46,18 +42,18 @@ namespace SharpCompress.Compressors.Deflate
        GZIP = 1952
    }

-    internal class ZlibBaseStream : AsyncStream
+    internal class ZlibBaseStream : Stream
    {
        protected internal ZlibCodec _z; // deferred init... new ZlibCodec();

        protected internal StreamMode _streamMode = StreamMode.Undefined;
        protected internal FlushType _flushMode;
-        private readonly ZlibStreamFlavor _flavor;
-        private readonly CompressionMode _compressionMode;
-        private readonly CompressionLevel _level;
+        protected internal ZlibStreamFlavor _flavor;
+        protected internal CompressionMode _compressionMode;
+        protected internal CompressionLevel _level;
        protected internal byte[] _workingBuffer;
        protected internal int _bufferSize = ZlibConstants.WorkingBufferSizeDefault;
-        private readonly byte[] _buf1 = new byte[1];
+        protected internal byte[] _buf1 = new byte[1];

        protected internal Stream _stream;
        protected internal CompressionStrategy Strategy = CompressionStrategy.Default;
@@ -120,13 +116,19 @@ namespace SharpCompress.Compressors.Deflate
            }
        }

-        private byte[] workingBuffer => _workingBuffer ??= new byte[_bufferSize];
+        private byte[] workingBuffer
+        {
+            get => _workingBuffer ??= new byte[_bufferSize];
+        }

-        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override void Write(byte[] buffer, int offset, int count)
        {
            // workitem 7159
            // calculate the CRC on the unccompressed data  (before writing)
-            crc?.SlurpBlock(buffer, offset, count);
+            if (crc != null)
+            {
+                crc.SlurpBlock(buffer, offset, count);
+            }

            if (_streamMode == StreamMode.Undefined)
            {
@@ -146,7 +148,7 @@ namespace SharpCompress.Compressors.Deflate
            z.InputBuffer = buffer;
            _z.NextIn = offset;
            _z.AvailableBytesIn = count;
-            var done = false;
+            bool done = false;
            do
            {
                _z.OutputBuffer = workingBuffer;
@@ -161,7 +163,7 @@ namespace SharpCompress.Compressors.Deflate
                }

                //if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
-                await _stream.WriteAsync(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut, cancellationToken);
+                _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);

                done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;

@@ -174,7 +176,7 @@ namespace SharpCompress.Compressors.Deflate
            while (!done);
        }

-        private async Task FinishAsync()
+        private void finish()
        {
            if (_z is null)
            {
@@ -183,7 +185,7 @@ namespace SharpCompress.Compressors.Deflate

            if (_streamMode == StreamMode.Writer)
            {
-                var done = false;
+                bool done = false;
                do
                {
                    _z.OutputBuffer = workingBuffer;
@@ -198,14 +200,14 @@ namespace SharpCompress.Compressors.Deflate
                        string verb = (_wantCompress ? "de" : "in") + "flating";
                        if (_z.Message is null)
                        {
-                            throw new ZlibException($"{verb}: (rc = {rc})");
+                            throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
                        }
                        throw new ZlibException(verb + ": " + _z.Message);
                    }

                    if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
                    {
-                        await _stream.WriteAsync(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
+                        _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut);
                    }

                    done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
@@ -218,7 +220,7 @@ namespace SharpCompress.Compressors.Deflate
                }
                while (!done);

-                await FlushAsync();
+                Flush();

                // workitem 7159
                if (_flavor == ZlibStreamFlavor.GZIP)
@@ -226,13 +228,12 @@ namespace SharpCompress.Compressors.Deflate
                    if (_wantCompress)
                    {
                        // Emit the GZIP trailer: CRC32 and  size mod 2^32
-                        using var rented = MemoryPool<byte>.Shared.Rent(4);
-                        var intBuf = rented.Memory.Slice(0, 4);
-                        BinaryPrimitives.WriteInt32LittleEndian(intBuf.Span, crc.Crc32Result);
-                        await _stream.WriteAsync(intBuf, CancellationToken.None);
+                        Span<byte> intBuf = stackalloc byte[4];
+                        BinaryPrimitives.WriteInt32LittleEndian(intBuf, crc.Crc32Result);
+                        _stream.Write(intBuf);
                        int c2 = (int)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
-                        BinaryPrimitives.WriteInt32LittleEndian(intBuf.Span, c2);
-                        await _stream.WriteAsync(intBuf, CancellationToken.None);
+                        BinaryPrimitives.WriteInt32LittleEndian(intBuf, c2);
+                        _stream.Write(intBuf);
                    }
                    else
                    {
@@ -255,41 +256,44 @@ namespace SharpCompress.Compressors.Deflate
                        }

                        // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-                        using var rented = MemoryPool<byte>.Shared.Rent(8);
-                        var trailer = rented.Memory.Slice(0, 8);
+                        Span<byte> trailer = stackalloc byte[8];

                        // workitem 8679
                        if (_z.AvailableBytesIn != 8)
                        {
                            // Make sure we have read to the end of the stream
-                            _z.InputBuffer.AsSpan(_z.NextIn, _z.AvailableBytesIn).CopyTo(trailer.Span);
+                            _z.InputBuffer.AsSpan(_z.NextIn, _z.AvailableBytesIn).CopyTo(trailer);
                            int bytesNeeded = 8 - _z.AvailableBytesIn;
-                            int bytesRead = await _stream.ReadAsync(trailer.Slice(_z.AvailableBytesIn, bytesNeeded));
+                            int bytesRead = _stream.Read(trailer.Slice(_z.AvailableBytesIn, bytesNeeded));
                            if (bytesNeeded != bytesRead)
                            {
-                                throw new ZlibException($"Protocol error. AvailableBytesIn={_z.AvailableBytesIn + bytesRead}, expected 8");
+                                throw new ZlibException(String.Format(
+                                                                      "Protocol error. AvailableBytesIn={0}, expected 8",
+                                                                      _z.AvailableBytesIn + bytesRead));
                            }
                        }
                        else
                        {
-                            _z.InputBuffer.AsSpan(_z.NextIn, trailer.Length).CopyTo(trailer.Span);
+                            _z.InputBuffer.AsSpan(_z.NextIn, trailer.Length).CopyTo(trailer);
                        }

-                        Int32 crc32_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer.Span);
+                        Int32 crc32_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer);
                        Int32 crc32_actual = crc.Crc32Result;
-                        Int32 isize_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer.Span.Slice(4));
+                        Int32 isize_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer.Slice(4));
                        Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);

                        if (crc32_actual != crc32_expected)
                        {
                            throw new ZlibException(
-                                                    $"Bad CRC32 in GZIP stream. (actual({crc32_actual:X8})!=expected({crc32_expected:X8}))");
+                                                    String.Format("Bad CRC32 in GZIP stream. (actual({0:X8})!=expected({1:X8}))",
+                                                                  crc32_actual, crc32_expected));
                        }

                        if (isize_actual != isize_expected)
                        {
                            throw new ZlibException(
-                                                    $"Bad size in GZIP stream. (actual({isize_actual})!=expected({isize_expected}))");
+                                                    String.Format("Bad size in GZIP stream. (actual({0})!=expected({1}))", isize_actual,
+                                                                  isize_expected));
                        }
                    }
                    else
@@ -300,7 +304,7 @@ namespace SharpCompress.Compressors.Deflate
            }
        }

-        private void End()
+        private void end()
        {
            if (z is null)
            {
@@ -317,32 +321,36 @@ namespace SharpCompress.Compressors.Deflate
            _z = null;
        }

-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
        {
-            if (_isDisposed)
+            if (isDisposed)
            {
                return;
            }
-            _isDisposed = true;
+            isDisposed = true;
+            base.Dispose(disposing);
+            if (disposing)
+            {
                if (_stream is null)
                {
                    return;
                }
                try
                {
-                    await FinishAsync();
+                    finish();
                }
                finally
                {
-                    End();
-                    _stream?.DisposeAsync();
+                    end();
+                    _stream?.Dispose();
                    _stream = null;
                }
+            }
        }

-        public override Task FlushAsync(CancellationToken cancellationToken)
+        public override void Flush()
        {
-            return _stream.FlushAsync(cancellationToken);
+            _stream.Flush();
        }

        public override Int64 Seek(Int64 offset, SeekOrigin origin)
@@ -357,7 +365,7 @@ namespace SharpCompress.Compressors.Deflate
            _stream.SetLength(value);
        }

-/*
+#if NOT
        public int Read()
        {
            if (Read(_buf1, 0, 1) == 0)
@@ -367,19 +375,19 @@ namespace SharpCompress.Compressors.Deflate
                crc.SlurpBlock(_buf1,0,1);
            return (_buf1[0] & 0xFF);
        }
-*/
+#endif

-        private bool _nomoreinput;
-        private bool _isDisposed;
+        private bool nomoreinput;
+        private bool isDisposed;

-        private async Task<string> ReadZeroTerminatedStringAsync()
+        private string ReadZeroTerminatedString()
        {
            var list = new List<byte>();
-            var done = false;
+            bool done = false;
            do
            {
                // workitem 7740
-                int n = await _stream.ReadAsync(_buf1, 0, 1);
+                int n = _stream.Read(_buf1, 0, 1);
                if (n != 1)
                {
                    throw new ZlibException("Unexpected EOF reading GZIP header.");
@@ -398,14 +406,13 @@ namespace SharpCompress.Compressors.Deflate
            return _encoding.GetString(buffer, 0, buffer.Length);
        }

-        private async Task<int> ReadAndValidateGzipHeaderAsync(CancellationToken cancellationToken)
+        private int _ReadAndValidateGzipHeader()
        {
-            var totalBytesRead = 0;
+            int totalBytesRead = 0;

            // read the header on the first read
-            using var rented = MemoryPool<byte>.Shared.Rent(10);
-            var header = rented.Memory.Slice(0, 10);
-            int n = await _stream.ReadAsync(header, cancellationToken);
+            Span<byte> header = stackalloc byte[10];
+            int n = _stream.Read(header);

            // workitem 8501: handle edge case (decompress empty stream)
            if (n == 0)
@@ -418,46 +425,46 @@ namespace SharpCompress.Compressors.Deflate
                throw new ZlibException("Not a valid GZIP stream.");
            }

-            if (header.Span[0] != 0x1F || header.Span[1] != 0x8B || header.Span[2] != 8)
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
            {
                throw new ZlibException("Bad GZIP header.");
            }

-            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.Span.Slice(4));
+            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.Slice(4));
            _GzipMtime = TarHeader.EPOCH.AddSeconds(timet);
            totalBytesRead += n;
-            if ((header.Span[3] & 0x04) == 0x04)
+            if ((header[3] & 0x04) == 0x04)
            {
                // read and discard extra field
-                n = await _stream.ReadAsync(header.Slice(0, 2), cancellationToken); // 2-byte length field
+                n = _stream.Read(header.Slice(0, 2)); // 2-byte length field
                totalBytesRead += n;

-                short extraLength = (short)(header.Span[0] + header.Span[1] * 256);
+                short extraLength = (short)(header[0] + header[1] * 256);
                byte[] extra = new byte[extraLength];
-                n = await _stream.ReadAsync(extra, 0, extra.Length, cancellationToken);
+                n = _stream.Read(extra, 0, extra.Length);
                if (n != extraLength)
                {
                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
                }
                totalBytesRead += n;
            }
-            if ((header.Span[3] & 0x08) == 0x08)
+            if ((header[3] & 0x08) == 0x08)
            {
-                _GzipFileName = await ReadZeroTerminatedStringAsync();
+                _GzipFileName = ReadZeroTerminatedString();
            }
-            if ((header.Span[3] & 0x10) == 0x010)
+            if ((header[3] & 0x10) == 0x010)
            {
-                _GzipComment = await ReadZeroTerminatedStringAsync();
+                _GzipComment = ReadZeroTerminatedString();
            }
-            if ((header.Span[3] & 0x02) == 0x02)
+            if ((header[3] & 0x02) == 0x02)
            {
-                await ReadAsync(_buf1, 0, 1, cancellationToken); // CRC16, ignore
+                Read(_buf1, 0, 1); // CRC16, ignore
            }

            return totalBytesRead;
        }

-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override Int32 Read(Byte[] buffer, Int32 offset, Int32 count)
        {
            // According to MS documentation, any implementation of the IO.Stream.Read function must:
            // (a) throw an exception if offset & count reference an invalid part of the buffer,
@@ -480,7 +487,7 @@ namespace SharpCompress.Compressors.Deflate
                z.AvailableBytesIn = 0;
                if (_flavor == ZlibStreamFlavor.GZIP)
                {
-                    _gzipHeaderByteCount = await ReadAndValidateGzipHeaderAsync(cancellationToken);
+                    _gzipHeaderByteCount = _ReadAndValidateGzipHeader();

                    // workitem 8501: handle edge case (decompress empty stream)
                    if (_gzipHeaderByteCount == 0)
@@ -495,13 +502,37 @@ namespace SharpCompress.Compressors.Deflate
                throw new ZlibException("Cannot Read after Writing.");
            }

+            int rc = 0;
+
+            // set up the output of the deflate/inflate codec:
+            _z.OutputBuffer = buffer;
+            _z.NextOut = offset;
+            _z.AvailableBytesOut = count;
+
            if (count == 0)
            {
                return 0;
            }
-            if (_nomoreinput && _wantCompress)
+            if (nomoreinput && _wantCompress)
            {
-                return 0; // workitem 8557
+                // no more input data available; therefore we flush to
+                // try to complete the read
+                rc = _z.Deflate(FlushType.Finish);
+
+                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                {
+                    throw new ZlibException(String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message));
+                }
+
+                rc = (count - _z.AvailableBytesOut);
+
+                // calculate CRC after reading
+                if (crc != null)
+                {
+                    crc.SlurpBlock(buffer, offset, rc);
+                }
+
+                return rc;
            }
            if (buffer is null)
            {
@@ -520,13 +551,6 @@ namespace SharpCompress.Compressors.Deflate
                throw new ArgumentOutOfRangeException(nameof(count));
            }

-            var rc = 0;
-
-            // set up the output of the deflate/inflate codec:
-            _z.OutputBuffer = buffer;
-            _z.NextOut = offset;
-            _z.AvailableBytesOut = count;
-
            // This is necessary in case _workingBuffer has been resized. (new byte[])
            // (The first reference to _workingBuffer goes through the private accessor which
            // may initialize it.)
@@ -535,14 +559,14 @@ namespace SharpCompress.Compressors.Deflate
            do
            {
                // need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
-                if ((_z.AvailableBytesIn == 0) && (!_nomoreinput))
+                if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
                {
                    // No data available, so try to Read data from the captive stream.
                    _z.NextIn = 0;
-                    _z.AvailableBytesIn = await _stream.ReadAsync(_workingBuffer, 0, _workingBuffer.Length, cancellationToken);
+                    _z.AvailableBytesIn = _stream.Read(_workingBuffer, 0, _workingBuffer.Length);
                    if (_z.AvailableBytesIn == 0)
                    {
-                        _nomoreinput = true;
+                        nomoreinput = true;
                    }
                }

@@ -551,22 +575,23 @@ namespace SharpCompress.Compressors.Deflate
                         ? _z.Deflate(_flushMode)
                         : _z.Inflate(_flushMode);

-                if (_nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
+                if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
                {
                    return 0;
                }

                if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
                {
-                    throw new ZlibException($"{(_wantCompress ? "de" : "in")}flating:  rc={rc}  msg={_z.Message}");
+                    throw new ZlibException(String.Format("{0}flating:  rc={1}  msg={2}", (_wantCompress ? "de" : "in"),
+                                                          rc, _z.Message));
                }

-                if ((_nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
+                if ((nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count))
                {
                    break; // nothing more to read
                }
            } //while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
-            while (_z.AvailableBytesOut > 0 && !_nomoreinput && rc == ZlibConstants.Z_OK);
+            while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);

            // workitem 8557
            // is there more room in output?
@@ -578,7 +603,7 @@ namespace SharpCompress.Compressors.Deflate
                }

                // are we completely done reading?
-                if (_nomoreinput)
+                if (nomoreinput)
                {
                    // and in compression?
                    if (_wantCompress)
@@ -589,7 +614,7 @@ namespace SharpCompress.Compressors.Deflate

                        if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
                        {
-                            throw new ZlibException($"Deflating:  rc={rc}  msg={_z.Message}");
+                            throw new ZlibException(String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message));
                        }
                    }
                }
@@ -598,7 +623,10 @@ namespace SharpCompress.Compressors.Deflate
            rc = (count - _z.AvailableBytesOut);

            // calculate CRC after reading
-            crc?.SlurpBlock(buffer, offset, rc);
+            if (crc != null)
+            {
+                crc.SlurpBlock(buffer, offset, rc);
+            }

            return rc;
        }
--- a/src/SharpCompress/Compressors/Deflate/ZlibStream.cs
+++ b/src/SharpCompress/Compressors/Deflate/ZlibStream.cs
@@ -28,13 +28,10 @@
 using System;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;

 namespace SharpCompress.Compressors.Deflate
 {
-    public class ZlibStream : AsyncStream
+    public class ZlibStream : Stream
    {
        private readonly ZlibBaseStream _baseStream;
        private bool _disposed;
@@ -207,25 +204,35 @@ namespace SharpCompress.Compressors.Deflate
        /// <remarks>
        /// This may or may not result in a <c>Close()</c> call on the captive stream.
        /// </remarks>
-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
        {
-            if (!_disposed)
+            try
            {
-                await _baseStream.DisposeAsync();
-                _disposed = true;
+                if (!_disposed)
+                {
+                    if (disposing)
+                    {
+                        _baseStream?.Dispose();
+                    }
+                    _disposed = true;
+                }
+            }
+            finally
+            {
+                base.Dispose(disposing);
            }
        }

        /// <summary>
        /// Flush the stream.
        /// </summary>
-        public override Task FlushAsync(CancellationToken cancellationToken)
+        public override void Flush()
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("ZlibStream");
            }
-            return _baseStream.FlushAsync(cancellationToken);
+            _baseStream.Flush();
        }

        /// <summary>
@@ -254,13 +261,22 @@ namespace SharpCompress.Compressors.Deflate
        /// <param name="buffer">The buffer into which the read data should be placed.</param>
        /// <param name="offset">the offset within that data array to put the first byte read.</param>
        /// <param name="count">the number of bytes to read.</param>
-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override int Read(byte[] buffer, int offset, int count)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("ZlibStream");
            }
-            return await _baseStream.ReadAsync(buffer, offset, count, cancellationToken);
+            return _baseStream.Read(buffer, offset, count);
+        }
+
+        public override int ReadByte()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException("ZlibStream");
+            }
+            return _baseStream.ReadByte();
        }

        /// <summary>
@@ -305,14 +321,24 @@ namespace SharpCompress.Compressors.Deflate
        /// <param name="buffer">The buffer holding data to write to the stream.</param>
        /// <param name="offset">the offset within that data array to find the first byte to write.</param>
        /// <param name="count">the number of bytes to write.</param>
-        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override void Write(byte[] buffer, int offset, int count)
        {
            if (_disposed)
            {
                throw new ObjectDisposedException("ZlibStream");
            }
-            await _baseStream.WriteAsync(buffer, offset, count, cancellationToken);
+            _baseStream.Write(buffer, offset, count);
        }
+
+        public override void WriteByte(byte value)
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException("ZlibStream");
+            }
+            _baseStream.WriteByte(value);
+        }
+
        #endregion System.IO.Stream methods
    }
 }
--- a/src/SharpCompress/Compressors/Filters/BranchExecFilter.cs
+++ b/src/SharpCompress/Compressors/Filters/BranchExecFilter.cs
@@ -0,0 +1,297 @@
+/*
+ * BranchExecFilter.cs -- Converters for executable
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * @TODO Encoding
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Compressors.Filters
+{
+    [CLSCompliant(false)]
+    public sealed class BranchExecFilter
+    {
+        public enum Alignment : int
+        {
+            ARCH_x86_ALIGNMENT = 1,
+            ARCH_PowerPC_ALIGNMENT = 4,
+            ARCH_IA64_ALIGNMENT = 16,
+            ARCH_ARM_ALIGNMENT = 4,
+            ARCH_ARMTHUMB_ALIGNMENT = 2,
+            ARCH_SPARC_ALIGNMENT = 4,
+        }
+
+        public static void X86Converter(byte[] data, UInt32 ip, ref UInt32 state) {
+
+            long i = 0;
+            long size = data.Length;
+            UInt32 pos = 0;
+            UInt32 mask = state & 7;
+            if (size < 5)
+                return;
+            size -= 4;
+            ip += 5;
+            
+            for (;;)
+            {
+                i = pos;
+            
+                for (; i < size; i++)
+                {
+                    if ((data[i] & 0xFE) == 0xE8)
+                    {
+                        break;
+                    }
+                }
+
+                UInt32 d = (UInt32)(i) - pos;
+                pos = (UInt32)i;
+                if (i >= size)
+                {
+                    state = (d > 2 ? 0 : mask >> (int)d);
+                    return;
+                }
+                if (d > 2)
+                {
+                    mask = 0;
+                }
+                else
+                {
+                    mask >>= (int)d;
+                    if (mask != 0 && (mask > 4 || mask == 3 || (((((data[(UInt32)(mask >> 1) + 1])) + 1) & 0xFE) == 0) ))
+                    {
+                        mask = (mask >> 1) | 4;
+                        pos++;
+                        continue;
+                    }
+                }
+            
+                if ((((data[i + 4]) + 1) & 0xFE) == 0)
+                {
+                    UInt32 inst = ((UInt32)data[i + 4] << 24) | ((UInt32)data[i + 3] << 16) | ((UInt32)data[i + 2] << 8) | ((UInt32)data[i + 1]);
+                    UInt32 cur = ip + (UInt32)pos;
+                    pos += 5;
+
+                    inst -= cur;
+                    if (mask != 0)
+                    {
+                        UInt32 sh = (mask & 6) << 2;
+                        if (((((((Byte)(inst >> (int)sh))) + 1) & 0xFE) == 0))
+                        {
+                            inst ^= (((UInt32)0x100 << (int)sh) - 1);
+                            inst -= cur;
+                        }
+                        mask = 0;
+                    }
+                    data[i + 1] = (Byte)inst;
+                    data[i + 2] = (Byte)(inst >> 8);
+                    data[i + 3] = (Byte)(inst >> 16);
+                    data[i + 4] = (Byte)(0 - ((inst >> 24) & 1));
+                }
+                else
+                {
+                    mask = (mask >> 1) | 4;
+                    pos++;
+                }
+            }
+        }
+
+        public static void PowerPCConverter(byte[] data, UInt32 ip)
+        {
+            long i = 0;
+            long size = data.Length;
+            size &= ~(UInt32)3;
+            ip -= 4;
+
+            for (;; )          // infinite loop
+            {
+                for (;; )          // infinite loop
+                {
+                    if (i >= size)
+                        return;
+                    i += 4;
+
+                    if ((data[i - 4] & 0xFC) == 0x48 && (data[i - 1] & 3) == 1)
+                        break;
+                }
+                {
+                    UInt32 inst = BitConverter.ToUInt32(data, (int)i - 4);
+
+                    if (BitConverter.IsLittleEndian)
+                    {
+                        inst = Utility.SwapUINT32(inst);
+                    }
+
+                    inst -= (UInt32)(ip + i);
+                    inst &= 0x03FFFFFF;
+                    inst |= 0x48000000;
+
+                    Utility.SetBigUInt32(ref data, inst, (i - 4));
+                }
+            }
+        }
+
+        public static void ARMConverter(byte[] data, UInt32 ip)
+        {
+            long i = 0;
+            long size = data.Length;
+            size &= ~(UInt32)3;
+            ip += 4;
+
+            for (;;)          // infinite loop
+            {
+                for (;;)          // infinite loop
+                {
+                    if (i >= size)
+                    {
+                        return;
+                    }
+
+                    i += 4;
+                    if (data[i - 1] == 0xEB)
+                        break;
+                }
+
+                UInt32 inst = BitConverter.ToUInt32(data, (int)i - 4);
+                inst <<= 2;
+                inst -= (UInt32)(ip + i);
+                inst >>= 2;
+                inst &= 0x00FFFFFF;
+                inst |= 0xEB000000;
+
+                Utility.SetLittleUInt32(ref data, inst, i - 4);
+            }
+        }
+
+        public static void ARMTConverter(byte[] data, UInt32 ip)
+        {
+            long i = 0;
+            long size = data.Length;
+            size &= ~(UInt32)1;
+            long lim = size - 4;
+
+            for (;;)
+            {
+                UInt32 b1;
+                for (;;)
+                {
+                    UInt32 b3;
+                    if (i > lim)
+                        return;
+                    b1 = data[i + 1];
+                    b3 = data[i + 3];
+                    i += 2;
+                    b1 ^= 8;
+                    if ((b3 & b1) >= 0xF8)
+                        break;
+                }
+
+             UInt32 inst = ((UInt32)b1 << 19)
+                        + (((UInt32)data[i + 1] & 0x7) << 8)
+                        + (((UInt32)data[i - 2] << 11))
+                        + (data[i]);
+             
+            i += 2;
+
+            UInt32 cur = ((UInt32)(ip + i)) >> 1;
+            inst -= cur;
+
+            
+            data[i - 4] = (Byte)(inst >> 11);
+            data[i - 3] = (Byte)(0xF0 | ((inst >> 19) & 0x7));
+            data[i - 2] = (Byte)inst;
+            data[i - 1] = (Byte)(0xF8 | (inst >> 8));
+            }
+        }
+
+        public static void IA64Converter(byte[] data, UInt32 ip)
+        {
+            UInt32 i = 0;
+            long size = data.Length;
+            if (size < 16)
+                throw new InvalidDataException("Unexpected data size");
+            size -= 16;
+
+            do
+            {
+                UInt32 m = ((UInt32)0x334B0000 >> (data[i] & 0x1E)) & 3;
+                if (m != 0)
+                {
+                    m++;
+                    do
+                    {
+                        UInt32 iterator = (UInt32)( (i + (m * 5) - 8));
+                        if (((data[iterator + 3] >> (int)m) & 15) == 5
+                            && (((data[iterator - 1] | ((UInt32)data[iterator] << 8)) >> (int)m) & 0x70) == 0)
+                        {
+                            UInt32 raw = BitConverter.ToUInt32(data, (int)iterator);
+                            UInt32 inst = raw >> (int)m;
+                            inst = (inst & 0xFFFFF) | ((inst & (1 << 23)) >> 3);
+
+                            inst <<= 4;
+                            inst -= (ip + (UInt32)i);
+                            inst >>= 4;
+
+                            inst &= 0x1FFFFF;
+                            inst += 0x700000;
+                            inst &= 0x8FFFFF;
+                            raw &= ~((UInt32)0x8FFFFF << (int)m);
+                            raw |= (inst << (int)m);
+
+                            Utility.SetLittleUInt32(ref data, raw, iterator);
+                        }
+                    }
+                    while (++m <= 4);
+                }
+                i += 16;
+            }
+            while (i <= size);
+            return;
+        }
+
+        public static void SPARCConverter(byte[] data, UInt32 ip)
+        {
+            long i = 0;
+            long size = data.Length;
+            size &= ~(UInt32)3;
+            ip -= 4;
+
+            for (;;)          // infinite loop
+            {
+                for (;;)          // infinite loop
+                {
+                    if (i >= size)
+                        return;
+
+                    i += 4;
+                    if ((data[i - 4] == 0x40 && (data[i - 3] & 0xC0) == 0) ||
+                        (data[i - 4] == 0x7F && (data[i - 3] >= 0xC0)))
+                        break;
+                }
+                
+                UInt32 inst = BitConverter.ToUInt32(data, (int)i - 4);
+
+                if (BitConverter.IsLittleEndian)
+                {
+                    inst = Utility.SwapUINT32(inst);
+                }
+
+                inst <<= 2;
+                inst -= (UInt32)(ip + i);
+
+                inst &= 0x01FFFFFF;
+                inst -= (UInt32)1 << 24;
+                inst ^= 0xFF000000;
+                inst >>= 2;
+                inst |= 0x40000000;
+
+                Utility.SetBigUInt32(ref data, inst, (i - 4));
+            }
+        }
+    }
+}
--- a/src/SharpCompress/Compressors/LZMA/AesDecoderStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/AesDecoderStream.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Security.Cryptography;
 using System.Text;
@@ -20,6 +20,11 @@ namespace SharpCompress.Compressors.LZMA

        public AesDecoderStream(Stream input, byte[] info, IPasswordProvider pass, long limit)
        {
+            if (pass.CryptoGetTextPassword() == null)
+            {
+                throw new SharpCompress.Common.CryptographicException("Encrypted 7Zip archive has no password specified.");
+            }
+
            mStream = input;
            mLimit = limit;

@@ -143,8 +148,8 @@ namespace SharpCompress.Compressors.LZMA

            if ((bt & 0xC0) == 0)
            {
-                salt = new byte[0];
-                iv = new byte[0];
+                salt = Array.Empty<byte>();
+                iv = Array.Empty<byte>();
                return;
            }

--- a/src/SharpCompress/Compressors/LZMA/DecoderStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/DecoderStream.cs
@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.SevenZip;
 using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
@@ -93,9 +91,8 @@ namespace SharpCompress.Compressors.LZMA
            }
        }

-        private static async ValueTask<Stream> CreateDecoderStream(Stream[] packStreams, long[] packSizes, Stream[] outStreams,
-                                                                   CFolder folderInfo, int coderIndex, IPasswordProvider pass,
-                                                                   CancellationToken cancellationToken)
+        private static Stream CreateDecoderStream(Stream[] packStreams, long[] packSizes, Stream[] outStreams,
+                                                  CFolder folderInfo, int coderIndex, IPasswordProvider pass)
        {
            var coderInfo = folderInfo._coders[coderIndex];
            if (coderInfo._numOutStreams != 1)
@@ -130,8 +127,8 @@ namespace SharpCompress.Compressors.LZMA
                    }

                    int otherCoderIndex = FindCoderIndexForOutStreamIndex(folderInfo, pairedOutIndex);
-                    inStreams[i] = await CreateDecoderStream(packStreams, packSizes, outStreams, folderInfo, otherCoderIndex,
-                                                       pass, cancellationToken);
+                    inStreams[i] = CreateDecoderStream(packStreams, packSizes, outStreams, folderInfo, otherCoderIndex,
+                                                       pass);

                    //inStreamSizes[i] = folderInfo.UnpackSizes[pairedOutIndex];

@@ -157,11 +154,11 @@ namespace SharpCompress.Compressors.LZMA
            }

            long unpackSize = folderInfo._unpackSizes[outStreamId];
-            return await DecoderRegistry.CreateDecoderStream(coderInfo._methodId, inStreams, coderInfo._props, pass, unpackSize, cancellationToken);
+            return DecoderRegistry.CreateDecoderStream(coderInfo._methodId, inStreams, coderInfo._props, pass, unpackSize);
        }

-        internal static async ValueTask<Stream> CreateDecoderStream(Stream inStream, long startPos, long[] packSizes, CFolder folderInfo,
-                                                   IPasswordProvider pass, CancellationToken cancellationToken)
+        internal static Stream CreateDecoderStream(Stream inStream, long startPos, long[] packSizes, CFolder folderInfo,
+                                                   IPasswordProvider pass)
        {
            if (!folderInfo.CheckStructure())
            {
@@ -179,7 +176,7 @@ namespace SharpCompress.Compressors.LZMA

            int primaryCoderIndex, primaryOutStreamIndex;
            FindPrimaryOutStreamIndex(folderInfo, out primaryCoderIndex, out primaryOutStreamIndex);
-            return await CreateDecoderStream(inStreams, packSizes, outStreams, folderInfo, primaryCoderIndex, pass, cancellationToken);
+            return CreateDecoderStream(inStreams, packSizes, outStreams, folderInfo, primaryCoderIndex, pass);
        }
    }
 }
--- a/src/SharpCompress/Compressors/LZMA/ICoder.cs
+++ b/src/SharpCompress/Compressors/LZMA/ICoder.cs
@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Compressors.LZMA
 {
@@ -61,8 +59,8 @@ namespace SharpCompress.Compressors.LZMA
        /// <param name="progress">
        /// callback progress reference.
        /// </param>
-        ValueTask CodeAsync(Stream inStream, Stream outStream,
-                  Int64 inSize, Int64 outSize, ICodeProgress progress, CancellationToken cancellationToken);
+        void Code(Stream inStream, Stream outStream,
+                  Int64 inSize, Int64 outSize, ICodeProgress progress);
    }

    /*
--- a/src/SharpCompress/Compressors/LZMA/LZ/LzBinTree.cs
+++ b/src/SharpCompress/Compressors/LZMA/LZ/LzBinTree.cs
@@ -103,7 +103,7 @@ namespace SharpCompress.Compressors.LZMA.LZ
        {
            if (historySize > K_MAX_VAL_FOR_NORMALIZE - 256)
            {
-                throw new Exception();
+                throw new ArgumentOutOfRangeException(nameof(historySize));
            }
            _cutValue = 16 + (matchMaxLen >> 1);

@@ -423,4 +423,4 @@ namespace SharpCompress.Compressors.LZMA.LZ
            _cutValue = cutValue;
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/LZMA/LZipStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/LZipStream.cs
@@ -1,9 +1,6 @@
 using System;
-using System.Buffers;
 using System.Buffers.Binary;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Crypto;
 using SharpCompress.IO;

@@ -17,70 +14,61 @@ namespace SharpCompress.Compressors.LZMA
    /// <summary>
    /// Stream supporting the LZIP format, as documented at http://www.nongnu.org/lzip/manual/lzip_manual.html
    /// </summary>
-    public sealed class LZipStream : AsyncStream
+    public sealed class LZipStream : Stream
    {
-#nullable disable
-        private Stream _stream;
-#nullable enable
-        private CountingWritableSubStream? _countingWritableSubStream;
+        private readonly Stream _stream;
+        private readonly CountingWritableSubStream? _countingWritableSubStream;
        private bool _disposed;
        private bool _finished;

        private long _writeCount;

-        private LZipStream()
+        public LZipStream(Stream stream, CompressionMode mode)
        {
-            
-        }
-
-        public static async ValueTask<LZipStream> CreateAsync(Stream stream, CompressionMode mode)
-        {
-            var lzip = new LZipStream();
-            lzip.Mode = mode;
+            Mode = mode;

            if (mode == CompressionMode.Decompress)
            {
-                int dSize = await ValidateAndReadSize(stream);
+                int dSize = ValidateAndReadSize(stream);
                if (dSize == 0)
                {
                    throw new IOException("Not an LZip stream");
                }
                byte[] properties = GetProperties(dSize);
-                lzip._stream = await LzmaStream.CreateAsync(properties, stream);
+                _stream = new LzmaStream(properties, stream);
            }
            else
            {
                //default
                int dSize = 104 * 1024;
-                await WriteHeaderSizeAsync(stream);
+                WriteHeaderSize(stream);

-                lzip._countingWritableSubStream = new CountingWritableSubStream(stream);
-                lzip._stream = new Crc32Stream(new LzmaStream(new LzmaEncoderProperties(true, dSize), false, lzip._countingWritableSubStream));
+                _countingWritableSubStream = new CountingWritableSubStream(stream);
+                _stream = new Crc32Stream(new LzmaStream(new LzmaEncoderProperties(true, dSize), false, _countingWritableSubStream));
            }
-            return lzip;
        }

-        public async ValueTask FinishAsync()
+        public void Finish()
        {
            if (!_finished)
            {
                if (Mode == CompressionMode.Compress)
                {
                    var crc32Stream = (Crc32Stream)_stream;
-                    await crc32Stream.WrappedStream.DisposeAsync();
-                    await crc32Stream.DisposeAsync();
+                    crc32Stream.WrappedStream.Dispose();
+                    crc32Stream.Dispose();
                    var compressedCount = _countingWritableSubStream!.Count;

-                    byte[] intBuf = new byte[8];
+                    Span<byte> intBuf = stackalloc byte[8];
                    BinaryPrimitives.WriteUInt32LittleEndian(intBuf, crc32Stream.Crc);
-                    await _countingWritableSubStream.WriteAsync(intBuf, 0, 4);
+                    _countingWritableSubStream.Write(intBuf.Slice(0, 4));

                    BinaryPrimitives.WriteInt64LittleEndian(intBuf, _writeCount);
-                    await _countingWritableSubStream.WriteAsync(intBuf, 0, 8);
+                    _countingWritableSubStream.Write(intBuf);

                    //total with headers
                    BinaryPrimitives.WriteUInt64LittleEndian(intBuf, compressedCount + 6 + 20);
-                    await _countingWritableSubStream.WriteAsync(intBuf, 0, 8);
+                    _countingWritableSubStream.Write(intBuf);
                }
                _finished = true;
            }
@@ -88,18 +76,21 @@ namespace SharpCompress.Compressors.LZMA

        #region Stream methods

-        public override async ValueTask DisposeAsync()
+        protected override void Dispose(bool disposing)
        {
            if (_disposed)
            {
                return;
            }
            _disposed = true;
-                await FinishAsync();
-                await _stream.DisposeAsync();
+            if (disposing)
+            {
+                Finish();
+                _stream.Dispose();
+            }
        }

-        public CompressionMode Mode { get; private set; }
+        public CompressionMode Mode { get; }

        public override bool CanRead => Mode == CompressionMode.Decompress;

@@ -107,38 +98,54 @@ namespace SharpCompress.Compressors.LZMA

        public override bool CanWrite => Mode == CompressionMode.Compress;

-        public override Task FlushAsync(CancellationToken cancellationToken)
+        public override void Flush()
        {
-            return _stream.FlushAsync(cancellationToken);
+            _stream.Flush();
        }

        // TODO: Both Length and Position are sometimes feasible, but would require
        // reading the output length when we initialize.
-        public override long Length => throw new NotSupportedException();
+        public override long Length => throw new NotImplementedException();

-        public override long Position { get => throw new NotImplementedException(); set => throw new NotSupportedException(); }
+        public override long Position { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

-        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = new CancellationToken())
-        {
-            return _stream.ReadAsync(buffer, cancellationToken);
-        }
+        public override int Read(byte[] buffer, int offset, int count) => _stream.Read(buffer, offset, count);
+
+        public override int ReadByte() => _stream.ReadByte();

        public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();

-        public override void SetLength(long value) => throw new NotSupportedException();
+        public override void SetLength(long value) => throw new NotImplementedException();

-        public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = new CancellationToken())
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+
+        public override int Read(Span<byte> buffer)
        {
-            await _stream.WriteAsync(buffer, cancellationToken);
+            return _stream.Read(buffer);
+        }
+
+        public override void Write(ReadOnlySpan<byte> buffer)
+        {
+            _stream.Write(buffer);
+
            _writeCount += buffer.Length;
        }

-        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+#endif
+
+        public override void Write(byte[] buffer, int offset, int count)
        {
-            await _stream.WriteAsync(buffer, offset, count, cancellationToken);
+            _stream.Write(buffer, offset, count);
            _writeCount += count;
        }

+        public override void WriteByte(byte value)
+        {
+            _stream.WriteByte(value);
+            ++_writeCount;
+        }
+
        #endregion

        /// <summary>
@@ -148,14 +155,14 @@ namespace SharpCompress.Compressors.LZMA
        /// </summary>
        /// <param name="stream">The stream to read from. Must not be null.</param>
        /// <returns><c>true</c> if the given stream is an LZip file, <c>false</c> otherwise.</returns>
-        public static async ValueTask<bool> IsLZipFileAsync(Stream stream) => await ValidateAndReadSize(stream) != 0;
+        public static bool IsLZipFile(Stream stream) => ValidateAndReadSize(stream) != 0;

        /// <summary>
        /// Reads the 6-byte header of the stream, and returns 0 if either the header
        /// couldn't be read or it isn't a validate LZIP header, or the dictionary
        /// size if it *is* a valid LZIP file.
        /// </summary>
-        private static async ValueTask<int> ValidateAndReadSize(Stream stream)
+        public static int ValidateAndReadSize(Stream stream)
        {
            if (stream is null)
            {
@@ -163,9 +170,8 @@ namespace SharpCompress.Compressors.LZMA
            }

            // Read the header
-            using var buffer = MemoryPool<byte>.Shared.Rent(6);
-            var header = buffer.Memory.Slice(0,6);
-            int n = await stream.ReadAsync(header);
+            Span<byte> header = stackalloc byte[6];
+            int n = stream.Read(header);

            // TODO: Handle reading only part of the header?

@@ -174,18 +180,18 @@ namespace SharpCompress.Compressors.LZMA
                return 0;
            }

-            if (header.Span[0] != 'L' || header.Span[1] != 'Z' || header.Span[2] != 'I' || header.Span[3] != 'P' || header.Span[4] != 1 /* version 1 */)
+            if (header[0] != 'L' || header[1] != 'Z' || header[2] != 'I' || header[3] != 'P' || header[4] != 1 /* version 1 */)
            {
                return 0;
            }
-            int basePower = header.Span[5] & 0x1F;
-            int subtractionNumerator = (header.Span[5] & 0xE0) >> 5;
+            int basePower = header[5] & 0x1F;
+            int subtractionNumerator = (header[5] & 0xE0) >> 5;
            return (1 << basePower) - subtractionNumerator * (1 << (basePower - 4));
        }

        private static readonly byte[] headerBytes = new byte[6] { (byte)'L', (byte)'Z', (byte)'I', (byte)'P', 1, 113 };

-        public static async ValueTask WriteHeaderSizeAsync(Stream stream)
+        public static void WriteHeaderSize(Stream stream)
        {
            if (stream is null)
            {
@@ -193,7 +199,7 @@ namespace SharpCompress.Compressors.LZMA
            }

            // hard coding the dictionary size encoding
-            await stream.WriteAsync(headerBytes, 0, 6);
+            stream.Write(headerBytes, 0, 6);
        }

        /// <summary>
--- a/src/SharpCompress/Compressors/LZMA/LzmaDecoder.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaDecoder.cs
@@ -1,7 +1,7 @@
+#nullable disable
+
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.LZ;
 using SharpCompress.Compressors.LZMA.RangeCoder;

@@ -11,11 +11,11 @@ namespace SharpCompress.Compressors.LZMA
    {
        private class LenDecoder
        {
-            private BitDecoder _choice = new();
-            private BitDecoder _choice2 = new();
+            private BitDecoder _choice = new BitDecoder();
+            private BitDecoder _choice2 = new BitDecoder();
            private readonly BitTreeDecoder[] _lowCoder = new BitTreeDecoder[Base.K_NUM_POS_STATES_MAX];
            private readonly BitTreeDecoder[] _midCoder = new BitTreeDecoder[Base.K_NUM_POS_STATES_MAX];
-            private BitTreeDecoder _highCoder = new(Base.K_NUM_HIGH_LEN_BITS);
+            private BitTreeDecoder _highCoder = new BitTreeDecoder(Base.K_NUM_HIGH_LEN_BITS);
            private uint _numPosStates;

            public void Create(uint numPosStates)
@@ -40,21 +40,21 @@ namespace SharpCompress.Compressors.LZMA
                _highCoder.Init();
            }

-            public async ValueTask<uint> DecodeAsync(RangeCoder.Decoder rangeDecoder, uint posState, CancellationToken cancellationToken)
+            public uint Decode(RangeCoder.Decoder rangeDecoder, uint posState)
            {
-                if (await _choice.DecodeAsync(rangeDecoder, cancellationToken) == 0)
+                if (_choice.Decode(rangeDecoder) == 0)
                {
-                    return await _lowCoder[posState].DecodeAsync(rangeDecoder, cancellationToken);
+                    return _lowCoder[posState].Decode(rangeDecoder);
                }
                uint symbol = Base.K_NUM_LOW_LEN_SYMBOLS;
-                if (await _choice2.DecodeAsync(rangeDecoder, cancellationToken) == 0)
+                if (_choice2.Decode(rangeDecoder) == 0)
                {
-                    symbol += await _midCoder[posState].DecodeAsync(rangeDecoder, cancellationToken);
+                    symbol += _midCoder[posState].Decode(rangeDecoder);
                }
                else
                {
                    symbol += Base.K_NUM_MID_LEN_SYMBOLS;
-                    symbol += await _highCoder.DecodeAsync(rangeDecoder, cancellationToken);
+                    symbol += _highCoder.Decode(rangeDecoder);
                }
                return symbol;
            }
@@ -79,31 +79,31 @@ namespace SharpCompress.Compressors.LZMA
                    }
                }

-                public async ValueTask<byte> DecodeNormalAsync(RangeCoder.Decoder rangeDecoder, CancellationToken cancellationToken)
+                public byte DecodeNormal(RangeCoder.Decoder rangeDecoder)
                {
                    uint symbol = 1;
                    do
                    {
-                        symbol = (symbol << 1) | await _decoders[symbol].DecodeAsync(rangeDecoder, cancellationToken);
+                        symbol = (symbol << 1) | _decoders[symbol].Decode(rangeDecoder);
                    }
                    while (symbol < 0x100);
                    return (byte)symbol;
                }

-                public async ValueTask<byte> DecodeWithMatchByteAsync(RangeCoder.Decoder rangeDecoder, byte matchByte, CancellationToken cancellationToken)
+                public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, byte matchByte)
                {
                    uint symbol = 1;
                    do
                    {
                        uint matchBit = (uint)(matchByte >> 7) & 1;
                        matchByte <<= 1;
-                        uint bit = await _decoders[((1 + matchBit) << 8) + symbol].DecodeAsync(rangeDecoder, cancellationToken);
+                        uint bit = _decoders[((1 + matchBit) << 8) + symbol].Decode(rangeDecoder);
                        symbol = (symbol << 1) | bit;
                        if (matchBit != bit)
                        {
                            while (symbol < 0x100)
                            {
-                                symbol = (symbol << 1) | await _decoders[symbol].DecodeAsync(rangeDecoder, cancellationToken);
+                                symbol = (symbol << 1) | _decoders[symbol].Decode(rangeDecoder);
                            }
                            break;
                        }
@@ -113,12 +113,12 @@ namespace SharpCompress.Compressors.LZMA
                }
            }

-            private readonly Decoder2[]_coders;
-            private readonly int _numPrevBits;
-            private readonly int _numPosBits;
-            private readonly uint _posMask;
-            
-            public LiteralDecoder(int numPosBits, int numPrevBits)
+            private Decoder2[] _coders;
+            private int _numPrevBits;
+            private int _numPosBits;
+            private uint _posMask;
+
+            public void Create(int numPosBits, int numPrevBits)
            {
                if (_coders != null && _numPrevBits == numPrevBits &&
                    _numPosBits == numPosBits)
@@ -150,18 +150,18 @@ namespace SharpCompress.Compressors.LZMA
                return ((pos & _posMask) << _numPrevBits) + (uint)(prevByte >> (8 - _numPrevBits));
            }

-            public ValueTask<byte> DecodeNormalAsync(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, CancellationToken cancellationToken)
+            public byte DecodeNormal(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte)
            {
-                return _coders[GetState(pos, prevByte)].DecodeNormalAsync(rangeDecoder, cancellationToken);
+                return _coders[GetState(pos, prevByte)].DecodeNormal(rangeDecoder);
            }

-            public ValueTask<byte> DecodeWithMatchByteAsync(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte, CancellationToken cancellationToken)
+            public byte DecodeWithMatchByte(RangeCoder.Decoder rangeDecoder, uint pos, byte prevByte, byte matchByte)
            {
-                return _coders[GetState(pos, prevByte)].DecodeWithMatchByteAsync(rangeDecoder, matchByte, cancellationToken);
+                return _coders[GetState(pos, prevByte)].DecodeWithMatchByte(rangeDecoder, matchByte);
            }
        }

-        private OutWindow? _outWindow;
+        private OutWindow _outWindow;

        private readonly BitDecoder[] _isMatchDecoders = new BitDecoder[Base.K_NUM_STATES << Base.K_NUM_POS_STATES_BITS_MAX];
        private readonly BitDecoder[] _isRepDecoders = new BitDecoder[Base.K_NUM_STATES];
@@ -173,18 +173,18 @@ namespace SharpCompress.Compressors.LZMA
        private readonly BitTreeDecoder[] _posSlotDecoder = new BitTreeDecoder[Base.K_NUM_LEN_TO_POS_STATES];
        private readonly BitDecoder[] _posDecoders = new BitDecoder[Base.K_NUM_FULL_DISTANCES - Base.K_END_POS_MODEL_INDEX];

-        private BitTreeDecoder _posAlignDecoder = new(Base.K_NUM_ALIGN_BITS);
+        private BitTreeDecoder _posAlignDecoder = new BitTreeDecoder(Base.K_NUM_ALIGN_BITS);

-        private readonly LenDecoder _lenDecoder = new();
-        private readonly LenDecoder _repLenDecoder = new();
+        private readonly LenDecoder _lenDecoder = new LenDecoder();
+        private readonly LenDecoder _repLenDecoder = new LenDecoder();

-        private LiteralDecoder? _literalDecoder;
+        private readonly LiteralDecoder _literalDecoder = new LiteralDecoder();

        private int _dictionarySize;

        private uint _posStateMask;

-        private Base.State _state = new();
+        private Base.State _state = new Base.State();
        private uint _rep0, _rep1, _rep2, _rep3;

        public Decoder()
@@ -196,16 +196,15 @@ namespace SharpCompress.Compressors.LZMA
            }
        }

-        private OutWindow CreateDictionary()
+        private void CreateDictionary()
        {
            if (_dictionarySize < 0)
            {
                throw new InvalidParamException();
            }
-            var outWindow = new OutWindow();
+            _outWindow = new OutWindow();
            int blockSize = Math.Max(_dictionarySize, (1 << 12));
-            outWindow.Create(blockSize);
-            return outWindow;
+            _outWindow.Create(blockSize);
        }

        private void SetLiteralProperties(int lp, int lc)
@@ -218,7 +217,7 @@ namespace SharpCompress.Compressors.LZMA
            {
                throw new InvalidParamException();
            }
-            _literalDecoder = new(lp, lc);
+            _literalDecoder.Create(lp, lc);
        }

        private void SetPosBitsProperties(int pb)
@@ -250,7 +249,7 @@ namespace SharpCompress.Compressors.LZMA
                _isRepG2Decoders[i].Init();
            }

-            _literalDecoder!.Init();
+            _literalDecoder.Init();
            for (i = 0; i < Base.K_NUM_LEN_TO_POS_STATES; i++)
            {
                _posSlotDecoder[i].Init();
@@ -273,12 +272,12 @@ namespace SharpCompress.Compressors.LZMA
            _rep3 = 0;
        }

-        public async ValueTask CodeAsync(Stream inStream, Stream outStream,
-                         Int64 inSize, Int64 outSize, ICodeProgress progress, CancellationToken cancellationToken)
+        public void Code(Stream inStream, Stream outStream,
+                         Int64 inSize, Int64 outSize, ICodeProgress progress)
        {
            if (_outWindow is null)
            {
-                _outWindow = CreateDictionary();
+                CreateDictionary();
            }
            _outWindow.Init(outStream);
            if (outSize > 0)
@@ -291,27 +290,18 @@ namespace SharpCompress.Compressors.LZMA
            }

            RangeCoder.Decoder rangeDecoder = new RangeCoder.Decoder();
-            await rangeDecoder.InitAsync(inStream, cancellationToken);
+            rangeDecoder.Init(inStream);

-            await CodeAsync(_dictionarySize, _outWindow, rangeDecoder, cancellationToken);
+            Code(_dictionarySize, _outWindow, rangeDecoder);

            _outWindow.ReleaseStream();
            rangeDecoder.ReleaseStream();

-            if (!rangeDecoder.IsFinished || (inSize > 0 && rangeDecoder._total != inSize))
-            {
-                throw new DataErrorException();
-            }
-            if (_outWindow.HasPending)
-            {
-                throw new DataErrorException();
-            }
            _outWindow = null;
        }

-        internal async ValueTask<bool> CodeAsync(int dictionarySize, OutWindow outWindow, RangeCoder.Decoder rangeDecoder, CancellationToken cancellationToken)
+        internal bool Code(int dictionarySize, OutWindow outWindow, RangeCoder.Decoder rangeDecoder)
        {
-            _literalDecoder ??= _literalDecoder.CheckNotNull(nameof(_literalDecoder));
            int dictionarySizeCheck = Math.Max(dictionarySize, 1);

            outWindow.CopyPending();
@@ -319,19 +309,19 @@ namespace SharpCompress.Compressors.LZMA
            while (outWindow.HasSpace)
            {
                uint posState = (uint)outWindow._total & _posStateMask;
-                if (await _isMatchDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].DecodeAsync(rangeDecoder, cancellationToken) == 0)
+                if (_isMatchDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].Decode(rangeDecoder) == 0)
                {
                    byte b;
                    byte prevByte = outWindow.GetByte(0);
                    if (!_state.IsCharState())
                    {
-                        b = await _literalDecoder.DecodeWithMatchByteAsync(rangeDecoder,
+                        b = _literalDecoder.DecodeWithMatchByte(rangeDecoder,
                                                                 (uint)outWindow._total, prevByte,
-                                                                 outWindow.GetByte((int)_rep0), cancellationToken);
+                                                                 outWindow.GetByte((int)_rep0));
                    }
                    else
                    {
-                        b = await _literalDecoder.DecodeNormalAsync(rangeDecoder, (uint)outWindow._total, prevByte, cancellationToken);
+                        b = _literalDecoder.DecodeNormal(rangeDecoder, (uint)outWindow._total, prevByte);
                    }
                    outWindow.PutByte(b);
                    _state.UpdateChar();
@@ -339,13 +329,13 @@ namespace SharpCompress.Compressors.LZMA
                else
                {
                    uint len;
-                    if (await _isRepDecoders[_state._index].DecodeAsync(rangeDecoder, cancellationToken) == 1)
+                    if (_isRepDecoders[_state._index].Decode(rangeDecoder) == 1)
                    {
-                        if (await _isRepG0Decoders[_state._index].DecodeAsync(rangeDecoder, cancellationToken) == 0)
+                        if (_isRepG0Decoders[_state._index].Decode(rangeDecoder) == 0)
                        {
                            if (
-                                await _isRep0LongDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].DecodeAsync(
-                                                                                                                              rangeDecoder, cancellationToken) == 0)
+                                _isRep0LongDecoders[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].Decode(
+                                                                                                                   rangeDecoder) == 0)
                            {
                                _state.UpdateShortRep();
                                outWindow.PutByte(outWindow.GetByte((int)_rep0));
@@ -355,13 +345,13 @@ namespace SharpCompress.Compressors.LZMA
                        else
                        {
                            UInt32 distance;
-                            if (await _isRepG1Decoders[_state._index].DecodeAsync(rangeDecoder, cancellationToken) == 0)
+                            if (_isRepG1Decoders[_state._index].Decode(rangeDecoder) == 0)
                            {
                                distance = _rep1;
                            }
                            else
                            {
-                                if (await _isRepG2Decoders[_state._index].DecodeAsync(rangeDecoder, cancellationToken) == 0)
+                                if (_isRepG2Decoders[_state._index].Decode(rangeDecoder) == 0)
                                {
                                    distance = _rep2;
                                }
@@ -375,7 +365,7 @@ namespace SharpCompress.Compressors.LZMA
                            _rep1 = _rep0;
                            _rep0 = distance;
                        }
-                        len = await _repLenDecoder.DecodeAsync(rangeDecoder, posState, cancellationToken) + Base.K_MATCH_MIN_LEN;
+                        len = _repLenDecoder.Decode(rangeDecoder, posState) + Base.K_MATCH_MIN_LEN;
                        _state.UpdateRep();
                    }
                    else
@@ -383,22 +373,23 @@ namespace SharpCompress.Compressors.LZMA
                        _rep3 = _rep2;
                        _rep2 = _rep1;
                        _rep1 = _rep0;
-                        len = Base.K_MATCH_MIN_LEN + await _lenDecoder.DecodeAsync(rangeDecoder, posState, cancellationToken);
+                        len = Base.K_MATCH_MIN_LEN + _lenDecoder.Decode(rangeDecoder, posState);
                        _state.UpdateMatch();
-                        uint posSlot = await _posSlotDecoder[Base.GetLenToPosState(len)].DecodeAsync(rangeDecoder, cancellationToken);
+                        uint posSlot = _posSlotDecoder[Base.GetLenToPosState(len)].Decode(rangeDecoder);
                        if (posSlot >= Base.K_START_POS_MODEL_INDEX)
                        {
                            int numDirectBits = (int)((posSlot >> 1) - 1);
                            _rep0 = ((2 | (posSlot & 1)) << numDirectBits);
                            if (posSlot < Base.K_END_POS_MODEL_INDEX)
                            {
-                                _rep0 += await BitTreeDecoder.ReverseDecode(_posDecoders,
-                                                                     _rep0 - posSlot - 1, rangeDecoder, numDirectBits, cancellationToken);
+                                _rep0 += BitTreeDecoder.ReverseDecode(_posDecoders,
+                                                                     _rep0 - posSlot - 1, rangeDecoder, numDirectBits);
                            }
                            else
                            {
-                                _rep0 += (await rangeDecoder.DecodeDirectBitsAsync(numDirectBits - Base.K_NUM_ALIGN_BITS, cancellationToken) << Base.K_NUM_ALIGN_BITS);
-                                _rep0 += await _posAlignDecoder.ReverseDecode(rangeDecoder, cancellationToken);
+                                _rep0 += (rangeDecoder.DecodeDirectBits(
+                                                                       numDirectBits - Base.K_NUM_ALIGN_BITS) << Base.K_NUM_ALIGN_BITS);
+                                _rep0 += _posAlignDecoder.ReverseDecode(rangeDecoder);
                            }
                        }
                        else
@@ -451,7 +442,7 @@ namespace SharpCompress.Compressors.LZMA
        {
            if (_outWindow is null)
            {
-                _outWindow = CreateDictionary();
+                CreateDictionary();
            }
            _outWindow.Train(stream);
        }
@@ -481,4 +472,4 @@ namespace SharpCompress.Compressors.LZMA
        public override void SetLength(long value) {}
        */
    }
-}
+}
--- a/src/SharpCompress/Compressors/LZMA/LzmaEncoder.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaEncoder.cs
@@ -2,8 +2,6 @@

 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.LZ;
 using SharpCompress.Compressors.LZMA.RangeCoder;

@@ -63,7 +61,7 @@ namespace SharpCompress.Compressors.LZMA
            return (UInt32)(G_FAST_POS[pos >> 26] + 52);
        }

-        private Base.State _state = new();
+        private Base.State _state = new Base.State();
        private Byte _previousByte;
        private readonly UInt32[] _repDistances = new UInt32[Base.K_NUM_REP_DISTANCES];

@@ -99,18 +97,18 @@ namespace SharpCompress.Compressors.LZMA
                    }
                }

-                public async ValueTask EncodeAsync(RangeCoder.Encoder rangeEncoder, byte symbol)
+                public void Encode(RangeCoder.Encoder rangeEncoder, byte symbol)
                {
                    uint context = 1;
                    for (int i = 7; i >= 0; i--)
                    {
                        uint bit = (uint)((symbol >> i) & 1);
-                        await _encoders[context].EncodeAsync(rangeEncoder, bit);
+                        _encoders[context].Encode(rangeEncoder, bit);
                        context = (context << 1) | bit;
                    }
                }

-                public async ValueTask EncodeMatchedAsync(RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol)
+                public void EncodeMatched(RangeCoder.Encoder rangeEncoder, byte matchByte, byte symbol)
                {
                    uint context = 1;
                    bool same = true;
@@ -124,7 +122,7 @@ namespace SharpCompress.Compressors.LZMA
                            state += ((1 + matchBit) << 8);
                            same = (matchBit == bit);
                        }
-                        await _encoders[state].EncodeAsync(rangeEncoder, bit);
+                        _encoders[state].Encode(rangeEncoder, bit);
                        context = (context << 1) | bit;
                    }
                }
@@ -198,11 +196,11 @@ namespace SharpCompress.Compressors.LZMA

        private class LenEncoder
        {
-            private BitEncoder _choice = new();
-            private BitEncoder _choice2 = new();
+            private BitEncoder _choice = new BitEncoder();
+            private BitEncoder _choice2 = new BitEncoder();
            private readonly BitTreeEncoder[] _lowCoder = new BitTreeEncoder[Base.K_NUM_POS_STATES_ENCODING_MAX];
            private readonly BitTreeEncoder[] _midCoder = new BitTreeEncoder[Base.K_NUM_POS_STATES_ENCODING_MAX];
-            private BitTreeEncoder _highCoder = new(Base.K_NUM_HIGH_LEN_BITS);
+            private BitTreeEncoder _highCoder = new BitTreeEncoder(Base.K_NUM_HIGH_LEN_BITS);

            public LenEncoder()
            {
@@ -225,26 +223,26 @@ namespace SharpCompress.Compressors.LZMA
                _highCoder.Init();
            }

-            public async ValueTask EncodeAsync(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)
+            public void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)
            {
                if (symbol < Base.K_NUM_LOW_LEN_SYMBOLS)
                {
-                    await _choice.EncodeAsync(rangeEncoder, 0);
-                    await _lowCoder[posState].EncodeAsync(rangeEncoder, symbol);
+                    _choice.Encode(rangeEncoder, 0);
+                    _lowCoder[posState].Encode(rangeEncoder, symbol);
                }
                else
                {
                    symbol -= Base.K_NUM_LOW_LEN_SYMBOLS;
-                    await  _choice.EncodeAsync(rangeEncoder, 1);
+                    _choice.Encode(rangeEncoder, 1);
                    if (symbol < Base.K_NUM_MID_LEN_SYMBOLS)
                    {
-                        await    _choice2.EncodeAsync(rangeEncoder, 0);
-                       await _midCoder[posState].EncodeAsync(rangeEncoder, symbol);
+                        _choice2.Encode(rangeEncoder, 0);
+                        _midCoder[posState].Encode(rangeEncoder, symbol);
                    }
                    else
                    {
-                        await   _choice2.EncodeAsync(rangeEncoder, 1);
-                        await _highCoder.EncodeAsync(rangeEncoder, symbol - Base.K_NUM_MID_LEN_SYMBOLS);
+                        _choice2.Encode(rangeEncoder, 1);
+                        _highCoder.Encode(rangeEncoder, symbol - Base.K_NUM_MID_LEN_SYMBOLS);
                    }
                }
            }
@@ -311,9 +309,9 @@ namespace SharpCompress.Compressors.LZMA
                }
            }

-            public new async ValueTask EncodeAsync(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)
+            public new void Encode(RangeCoder.Encoder rangeEncoder, UInt32 symbol, UInt32 posState)
            {
-                await base.EncodeAsync(rangeEncoder, symbol, posState);
+                base.Encode(rangeEncoder, symbol, posState);
                if (--_counters[posState] == 0)
                {
                    UpdateTable(posState);
@@ -363,7 +361,7 @@ namespace SharpCompress.Compressors.LZMA

        private readonly Optimal[] _optimum = new Optimal[K_NUM_OPTS];
        private BinTree _matchFinder;
-        private readonly RangeCoder.Encoder _rangeEncoder = new();
+        private readonly RangeCoder.Encoder _rangeEncoder = new RangeCoder.Encoder();

        private readonly BitEncoder[] _isMatch =
            new BitEncoder[Base.K_NUM_STATES << Base.K_NUM_POS_STATES_BITS_MAX];
@@ -381,12 +379,12 @@ namespace SharpCompress.Compressors.LZMA
        private readonly BitEncoder[] _posEncoders =
            new BitEncoder[Base.K_NUM_FULL_DISTANCES - Base.K_END_POS_MODEL_INDEX];

-        private BitTreeEncoder _posAlignEncoder = new(Base.K_NUM_ALIGN_BITS);
+        private BitTreeEncoder _posAlignEncoder = new BitTreeEncoder(Base.K_NUM_ALIGN_BITS);

-        private readonly LenPriceTableEncoder _lenEncoder = new();
-        private readonly LenPriceTableEncoder _repMatchLenEncoder = new();
+        private readonly LenPriceTableEncoder _lenEncoder = new LenPriceTableEncoder();
+        private readonly LenPriceTableEncoder _repMatchLenEncoder = new LenPriceTableEncoder();

-        private readonly LiteralEncoder _literalEncoder = new();
+        private readonly LiteralEncoder _literalEncoder = new LiteralEncoder();

        private readonly UInt32[] _matchDistances = new UInt32[Base.K_MATCH_MAX_LEN * 2 + 2];

@@ -1191,40 +1189,40 @@ namespace SharpCompress.Compressors.LZMA
            return (smallDist < ((UInt32)(1) << (32 - kDif)) && bigDist >= (smallDist << kDif));
        }

-        private async ValueTask WriteEndMarkerAsync(UInt32 posState)
+        private void WriteEndMarker(UInt32 posState)
        {
            if (!_writeEndMark)
            {
                return;
            }

-            await _isMatch[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].EncodeAsync(_rangeEncoder, 1);
-            await _isRep[_state._index].EncodeAsync(_rangeEncoder, 0);
+            _isMatch[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].Encode(_rangeEncoder, 1);
+            _isRep[_state._index].Encode(_rangeEncoder, 0);
            _state.UpdateMatch();
            UInt32 len = Base.K_MATCH_MIN_LEN;
-            await _lenEncoder.EncodeAsync(_rangeEncoder, len - Base.K_MATCH_MIN_LEN, posState);
+            _lenEncoder.Encode(_rangeEncoder, len - Base.K_MATCH_MIN_LEN, posState);
            UInt32 posSlot = (1 << Base.K_NUM_POS_SLOT_BITS) - 1;
            UInt32 lenToPosState = Base.GetLenToPosState(len);
-            await _posSlotEncoder[lenToPosState].EncodeAsync(_rangeEncoder, posSlot);
+            _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);
            int footerBits = 30;
            UInt32 posReduced = (((UInt32)1) << footerBits) - 1;
-            await _rangeEncoder.EncodeDirectBits(posReduced >> Base.K_NUM_ALIGN_BITS, footerBits - Base.K_NUM_ALIGN_BITS);
-            await _posAlignEncoder.ReverseEncodeAsync(_rangeEncoder, posReduced & Base.K_ALIGN_MASK);
+            _rangeEncoder.EncodeDirectBits(posReduced >> Base.K_NUM_ALIGN_BITS, footerBits - Base.K_NUM_ALIGN_BITS);
+            _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.K_ALIGN_MASK);
        }

-        private async ValueTask FlushAsync(UInt32 nowPos)
+        private void Flush(UInt32 nowPos)
        {
            ReleaseMfStream();
-            await WriteEndMarkerAsync(nowPos & _posStateMask);
-            await _rangeEncoder.FlushData();
-            await _rangeEncoder.FlushAsync();
+            WriteEndMarker(nowPos & _posStateMask);
+            _rangeEncoder.FlushData();
+            _rangeEncoder.FlushStream();
        }

-        public async ValueTask<(Int64, Int64, bool)> CodeOneBlockAsync()
+        public void CodeOneBlock(out Int64 inSize, out Int64 outSize, out bool finished)
        {
-            long inSize = 0;
-            long outSize = 0;
-            var finished = true;
+            inSize = 0;
+            outSize = 0;
+            finished = true;

            if (_inStream != null)
            {
@@ -1235,7 +1233,7 @@ namespace SharpCompress.Compressors.LZMA

            if (_finished)
            {
-                return (inSize, outSize, finished);
+                return;
            }
            _finished = true;

@@ -1256,20 +1254,20 @@ namespace SharpCompress.Compressors.LZMA
                if (_processingMode && _matchFinder.IsDataStarved)
                {
                    _finished = false;
-                    return (inSize, outSize, finished);
+                    return;
                }
                if (_matchFinder.GetNumAvailableBytes() == 0)
                {
-                    await FlushAsync((UInt32)_nowPos64);
-                    return (inSize, outSize, finished);
+                    Flush((UInt32)_nowPos64);
+                    return;
                }
                UInt32 len, numDistancePairs; // it's not used
                ReadMatchDistances(out len, out numDistancePairs);
                UInt32 posState = (UInt32)(_nowPos64) & _posStateMask;
-                await _isMatch[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].EncodeAsync(_rangeEncoder, 0);
+                _isMatch[(_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState].Encode(_rangeEncoder, 0);
                _state.UpdateChar();
                Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset));
-                await _literalEncoder.GetSubCoder((UInt32)(_nowPos64), _previousByte).EncodeAsync(_rangeEncoder, curByte);
+                _literalEncoder.GetSubCoder((UInt32)(_nowPos64), _previousByte).Encode(_rangeEncoder, curByte);
                _previousByte = curByte;
                _additionalOffset--;
                _nowPos64++;
@@ -1277,19 +1275,19 @@ namespace SharpCompress.Compressors.LZMA
            if (_processingMode && _matchFinder.IsDataStarved)
            {
                _finished = false;
-                return (inSize, outSize, finished);
+                return;
            }
            if (_matchFinder.GetNumAvailableBytes() == 0)
            {
-                await FlushAsync((UInt32)_nowPos64);
-                return (inSize, outSize, finished);
+                Flush((UInt32)_nowPos64);
+                return;
            }
            while (true)
            {
                if (_processingMode && _matchFinder.IsDataStarved)
                {
                    _finished = false;
-                    return (inSize, outSize, finished);
+                    return;
                }

                UInt32 pos;
@@ -1299,51 +1297,51 @@ namespace SharpCompress.Compressors.LZMA
                UInt32 complexState = (_state._index << Base.K_NUM_POS_STATES_BITS_MAX) + posState;
                if (len == 1 && pos == 0xFFFFFFFF)
                {
-                    await _isMatch[complexState].EncodeAsync(_rangeEncoder, 0);
+                    _isMatch[complexState].Encode(_rangeEncoder, 0);
                    Byte curByte = _matchFinder.GetIndexByte((Int32)(0 - _additionalOffset));
                    LiteralEncoder.Encoder2 subCoder = _literalEncoder.GetSubCoder((UInt32)_nowPos64, _previousByte);
                    if (!_state.IsCharState())
                    {
                        Byte matchByte =
                            _matchFinder.GetIndexByte((Int32)(0 - _repDistances[0] - 1 - _additionalOffset));
-                        await subCoder.EncodeMatchedAsync(_rangeEncoder, matchByte, curByte);
+                        subCoder.EncodeMatched(_rangeEncoder, matchByte, curByte);
                    }
                    else
                    {
-                        await  subCoder.EncodeAsync(_rangeEncoder, curByte);
+                        subCoder.Encode(_rangeEncoder, curByte);
                    }
                    _previousByte = curByte;
                    _state.UpdateChar();
                }
                else
                {
-                    await  _isMatch[complexState].EncodeAsync(_rangeEncoder, 1);
+                    _isMatch[complexState].Encode(_rangeEncoder, 1);
                    if (pos < Base.K_NUM_REP_DISTANCES)
                    {
-                        await  _isRep[_state._index].EncodeAsync(_rangeEncoder, 1);
+                        _isRep[_state._index].Encode(_rangeEncoder, 1);
                        if (pos == 0)
                        {
-                            await  _isRepG0[_state._index].EncodeAsync(_rangeEncoder, 0);
+                            _isRepG0[_state._index].Encode(_rangeEncoder, 0);
                            if (len == 1)
                            {
-                                await _isRep0Long[complexState].EncodeAsync(_rangeEncoder, 0);
+                                _isRep0Long[complexState].Encode(_rangeEncoder, 0);
                            }
                            else
                            {
-                                await  _isRep0Long[complexState].EncodeAsync(_rangeEncoder, 1);
+                                _isRep0Long[complexState].Encode(_rangeEncoder, 1);
                            }
                        }
                        else
                        {
-                            await  _isRepG0[_state._index].EncodeAsync(_rangeEncoder, 1);
+                            _isRepG0[_state._index].Encode(_rangeEncoder, 1);
                            if (pos == 1)
                            {
-                                await _isRepG1[_state._index].EncodeAsync(_rangeEncoder, 0);
+                                _isRepG1[_state._index].Encode(_rangeEncoder, 0);
                            }
                            else
                            {
-                                await _isRepG1[_state._index].EncodeAsync(_rangeEncoder, 1);
-                                await _isRepG2[_state._index].EncodeAsync(_rangeEncoder, pos - 2);
+                                _isRepG1[_state._index].Encode(_rangeEncoder, 1);
+                                _isRepG2[_state._index].Encode(_rangeEncoder, pos - 2);
                            }
                        }
                        if (len == 1)
@@ -1352,7 +1350,7 @@ namespace SharpCompress.Compressors.LZMA
                        }
                        else
                        {
-                            await _repMatchLenEncoder.EncodeAsync(_rangeEncoder, len - Base.K_MATCH_MIN_LEN, posState);
+                            _repMatchLenEncoder.Encode(_rangeEncoder, len - Base.K_MATCH_MIN_LEN, posState);
                            _state.UpdateRep();
                        }
                        UInt32 distance = _repDistances[pos];
@@ -1367,13 +1365,13 @@ namespace SharpCompress.Compressors.LZMA
                    }
                    else
                    {
-                        await _isRep[_state._index].EncodeAsync(_rangeEncoder, 0);
+                        _isRep[_state._index].Encode(_rangeEncoder, 0);
                        _state.UpdateMatch();
-                        await _lenEncoder.EncodeAsync(_rangeEncoder, len - Base.K_MATCH_MIN_LEN, posState);
+                        _lenEncoder.Encode(_rangeEncoder, len - Base.K_MATCH_MIN_LEN, posState);
                        pos -= Base.K_NUM_REP_DISTANCES;
                        UInt32 posSlot = GetPosSlot(pos);
                        UInt32 lenToPosState = Base.GetLenToPosState(len);
-                        await _posSlotEncoder[lenToPosState].EncodeAsync(_rangeEncoder, posSlot);
+                        _posSlotEncoder[lenToPosState].Encode(_rangeEncoder, posSlot);

                        if (posSlot >= Base.K_START_POS_MODEL_INDEX)
                        {
@@ -1383,15 +1381,15 @@ namespace SharpCompress.Compressors.LZMA

                            if (posSlot < Base.K_END_POS_MODEL_INDEX)
                            {
-                                await BitTreeEncoder.ReverseEncodeAsync(_posEncoders,
-                                                                        baseVal - posSlot - 1, _rangeEncoder, footerBits,
-                                                                        posReduced);
+                                BitTreeEncoder.ReverseEncode(_posEncoders,
+                                                             baseVal - posSlot - 1, _rangeEncoder, footerBits,
+                                                             posReduced);
                            }
                            else
                            {
-                                await _rangeEncoder.EncodeDirectBits(posReduced >> Base.K_NUM_ALIGN_BITS,
+                                _rangeEncoder.EncodeDirectBits(posReduced >> Base.K_NUM_ALIGN_BITS,
                                                               footerBits - Base.K_NUM_ALIGN_BITS);
-                                await _posAlignEncoder.ReverseEncodeAsync(_rangeEncoder, posReduced & Base.K_ALIGN_MASK);
+                                _posAlignEncoder.ReverseEncode(_rangeEncoder, posReduced & Base.K_ALIGN_MASK);
                                _alignPriceCount++;
                            }
                        }
@@ -1423,19 +1421,19 @@ namespace SharpCompress.Compressors.LZMA
                    if (_processingMode && _matchFinder.IsDataStarved)
                    {
                        _finished = false;
-                        return (inSize, outSize, finished);
+                        return;
                    }
                    if (_matchFinder.GetNumAvailableBytes() == 0)
                    {
-                        await FlushAsync((UInt32)_nowPos64);
-                        return (inSize, outSize, finished);
+                        Flush((UInt32)_nowPos64);
+                        return;
                    }

                    if (_nowPos64 - progressPosValuePrev >= (1 << 12))
                    {
                        _finished = false;
                        finished = false;
-                        return (inSize, outSize, finished);
+                        return;
                    }
                }
            }
@@ -1490,8 +1488,8 @@ namespace SharpCompress.Compressors.LZMA
            _nowPos64 = 0;
        }

-        public async ValueTask CodeAsync(Stream inStream, Stream outStream,
-                         Int64 inSize, Int64 outSize, ICodeProgress progress, CancellationToken cancellationToken)
+        public void Code(Stream inStream, Stream outStream,
+                         Int64 inSize, Int64 outSize, ICodeProgress progress)
        {
            _needReleaseMfStream = false;
            _processingMode = false;
@@ -1500,7 +1498,10 @@ namespace SharpCompress.Compressors.LZMA
                SetStreams(inStream, outStream, inSize, outSize);
                while (true)
                {
-                    var (processedInSize, processedOutSize, finished) = await CodeOneBlockAsync();
+                    Int64 processedInSize;
+                    Int64 processedOutSize;
+                    bool finished;
+                    CodeOneBlock(out processedInSize, out processedOutSize, out finished);
                    if (finished)
                    {
                        return;
@@ -1517,7 +1518,7 @@ namespace SharpCompress.Compressors.LZMA
            }
        }

-        public async ValueTask<long> CodeAsync(Stream inStream, bool final)
+        public long Code(Stream inStream, bool final)
        {
            _matchFinder.SetStream(inStream);
            _processingMode = !final;
@@ -1525,7 +1526,10 @@ namespace SharpCompress.Compressors.LZMA
            {
                while (true)
                {
-                    var (processedInSize, processedOutSize, finished) = await CodeOneBlockAsync();
+                    Int64 processedInSize;
+                    Int64 processedOutSize;
+                    bool finished;
+                    CodeOneBlock(out processedInSize, out processedOutSize, out finished);
                    if (finished)
                    {
                        return processedInSize;
@@ -1645,7 +1649,7 @@ namespace SharpCompress.Compressors.LZMA
        {
            for (int m = 0; m < K_MATCH_FINDER_I_DS.Length; m++)
            {
-                if (s == K_MATCH_FINDER_I_DS[m])
+                if (string.Equals(s, K_MATCH_FINDER_I_DS[m], StringComparison.OrdinalIgnoreCase))
                {
                    return m;
                }
@@ -1692,7 +1696,7 @@ namespace SharpCompress.Compressors.LZMA
                                throw new InvalidParamException();
                            }
                            EMatchFinderType matchFinderIndexPrev = _matchFinderType;
-                            int m = FindMatchFinder(((string)prop).ToUpper());
+                            int m = FindMatchFinder(((string)prop));
                            if (m < 0)
                            {
                                throw new InvalidParamException();
--- a/src/SharpCompress/Compressors/LZMA/LzmaStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaStream.cs
@@ -1,25 +1,21 @@
 #nullable disable

 using System;
-using System.Buffers;
 using System.Buffers.Binary;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.LZ;
-using SharpCompress.IO;

 namespace SharpCompress.Compressors.LZMA
 {
-    public class LzmaStream : AsyncStream
+    public class LzmaStream : Stream
    {
-        private Stream _inputStream;
-        private long _inputSize;
-        private long _outputSize;
+        private readonly Stream _inputStream;
+        private readonly long _inputSize;
+        private readonly long _outputSize;

-        private int _dictionarySize;
-        private OutWindow _outWindow = new OutWindow();
-        private RangeCoder.Decoder _rangeDecoder = new RangeCoder.Decoder();
+        private readonly int _dictionarySize;
+        private readonly OutWindow _outWindow = new OutWindow();
+        private readonly RangeCoder.Decoder _rangeDecoder = new RangeCoder.Decoder();
        private Decoder _decoder;

        private long _position;
@@ -29,60 +25,70 @@ namespace SharpCompress.Compressors.LZMA
        private long _inputPosition;

        // LZMA2
-        private bool _isLzma2;
+        private readonly bool _isLzma2;
        private bool _uncompressedChunk;
        private bool _needDictReset = true;
        private bool _needProps = true;

        private readonly Encoder _encoder;
        private bool _isDisposed;
-        
-        private LzmaStream() {}

-        public static async ValueTask<LzmaStream> CreateAsync(byte[] properties, Stream inputStream, long inputSize = -1, long outputSize = -1,
-                                                       Stream presetDictionary = null, bool? isLzma2 = null, CancellationToken cancellationToken = default)
+        public LzmaStream(byte[] properties, Stream inputStream)
+            : this(properties, inputStream, -1, -1, null, properties.Length < 5)
        {
-            var ls = new LzmaStream();
-            ls._inputStream = inputStream;
-            ls._inputSize = inputSize;
-            ls._outputSize = outputSize;
-            ls._isLzma2 = isLzma2 ?? properties.Length < 5;
+        }

-            if (!ls._isLzma2)
+        public LzmaStream(byte[] properties, Stream inputStream, long inputSize)
+            : this(properties, inputStream, inputSize, -1, null, properties.Length < 5)
+        {
+        }
+
+        public LzmaStream(byte[] properties, Stream inputStream, long inputSize, long outputSize)
+            : this(properties, inputStream, inputSize, outputSize, null, properties.Length < 5)
+        {
+        }
+
+        public LzmaStream(byte[] properties, Stream inputStream, long inputSize, long outputSize,
+                          Stream presetDictionary, bool isLzma2)
+        {
+            _inputStream = inputStream;
+            _inputSize = inputSize;
+            _outputSize = outputSize;
+            _isLzma2 = isLzma2;
+
+            if (!isLzma2)
            {
-                ls._dictionarySize = BinaryPrimitives.ReadInt32LittleEndian(properties.AsSpan(1));
-                ls._outWindow.Create(ls._dictionarySize);
+                _dictionarySize = BinaryPrimitives.ReadInt32LittleEndian(properties.AsSpan(1));
+                _outWindow.Create(_dictionarySize);
                if (presetDictionary != null)
                {
-                    ls._outWindow.Train(presetDictionary);
+                    _outWindow.Train(presetDictionary);
                }

-                await ls._rangeDecoder.InitAsync(inputStream, cancellationToken);
+                _rangeDecoder.Init(inputStream);

-                ls._decoder = new Decoder();
-                ls._decoder.SetDecoderProperties(properties);
-                ls.Properties = properties;
+                _decoder = new Decoder();
+                _decoder.SetDecoderProperties(properties);
+                Properties = properties;

-                ls._availableBytes = outputSize < 0 ? long.MaxValue : outputSize;
-                ls._rangeDecoderLimit = inputSize;
+                _availableBytes = outputSize < 0 ? long.MaxValue : outputSize;
+                _rangeDecoderLimit = inputSize;
            }
            else
            {
-                ls. _dictionarySize = 2 | (properties[0] & 1);
-                ls. _dictionarySize <<= (properties[0] >> 1) + 11;
+                _dictionarySize = 2 | (properties[0] & 1);
+                _dictionarySize <<= (properties[0] >> 1) + 11;

-                ls._outWindow.Create(ls._dictionarySize);
+                _outWindow.Create(_dictionarySize);
                if (presetDictionary != null)
                {
-                    ls._outWindow.Train(presetDictionary);
-                    ls._needDictReset = false;
+                    _outWindow.Train(presetDictionary);
+                    _needDictReset = false;
                }

-                ls. Properties = new byte[1];
-                ls._availableBytes = 0;
+                Properties = new byte[1];
+                _availableBytes = 0;
            }
-
-            return ls;
        }

        public LzmaStream(LzmaEncoderProperties properties, bool isLzma2, Stream outputStream)
@@ -120,25 +126,33 @@ namespace SharpCompress.Compressors.LZMA

        public override bool CanWrite => _encoder != null;

-        public override async ValueTask DisposeAsync()
+        public override void Flush()
+        {
+        }
+
+        protected override void Dispose(bool disposing)
        {
            if (_isDisposed)
            {
                return;
            }
            _isDisposed = true;
-            if (_encoder != null)
+            if (disposing)
            {
-                _position = await _encoder.CodeAsync(null, true);
+                if (_encoder != null)
+                {
+                    _position = _encoder.Code(null, true);
+                }
+                _inputStream?.Dispose();
            }
-            _inputStream?.DisposeAsync();
+            base.Dispose(disposing);
        }

        public override long Length => _position + _availableBytes;

        public override long Position { get => _position; set => throw new NotSupportedException(); }

-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override int Read(byte[] buffer, int offset, int count)
        {
            if (_endReached)
            {
@@ -152,7 +166,7 @@ namespace SharpCompress.Compressors.LZMA
                {
                    if (_isLzma2)
                    {
-                        await DecodeChunkHeader(cancellationToken);
+                        DecodeChunkHeader();
                    }
                    else
                    {
@@ -175,7 +189,7 @@ namespace SharpCompress.Compressors.LZMA
                {
                    _inputPosition += _outWindow.CopyStream(_inputStream, toProcess);
                }
-                else if (await _decoder.CodeAsync(_dictionarySize, _outWindow, _rangeDecoder, cancellationToken)
+                else if (_decoder.Code(_dictionarySize, _outWindow, _rangeDecoder)
                         && _outputSize < 0)
                {
                    _availableBytes = _outWindow.AvailableBytes;
@@ -217,7 +231,7 @@ namespace SharpCompress.Compressors.LZMA
            return total;
        }

-        private async ValueTask DecodeChunkHeader(CancellationToken cancellationToken)
+        private void DecodeChunkHeader()
        {
            int control = _inputStream.ReadByte();
            _inputPosition++;
@@ -269,7 +283,7 @@ namespace SharpCompress.Compressors.LZMA
                    _decoder.SetDecoderProperties(Properties);
                }

-                await _rangeDecoder.InitAsync(_inputStream, cancellationToken);
+                _rangeDecoder.Init(_inputStream);
            }
            else if (control > 0x02)
            {
@@ -293,25 +307,14 @@ namespace SharpCompress.Compressors.LZMA
            throw new NotSupportedException();
        }

-        public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override void Write(byte[] buffer, int offset, int count)
        {
            if (_encoder != null)
            {
-                _position = await _encoder.CodeAsync(new MemoryStream(buffer, offset, count), false);
+                _position = _encoder.Code(new MemoryStream(buffer, offset, count), false);
            }
        }

-        public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = new CancellationToken())
-        {
-            if (_encoder != null)
-            {
-                 var m = ArrayPool<byte>.Shared.Rent(buffer.Length);
-                 buffer.CopyTo(m.AsMemory().Slice(0, buffer.Length));
-                _position = await _encoder.CodeAsync(new MemoryStream(m, 0, buffer.Length), false);
-                ArrayPool<byte>.Shared.Return(m);
-            }
-        }
-
-        public byte[] Properties { get; private set; }
+        public byte[] Properties { get; } = new byte[5];
    }
 }
--- a/src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoder.cs
+++ b/src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoder.cs
@@ -1,14 +1,11 @@
 #nullable disable

 using System;
-using System.Buffers;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Compressors.LZMA.RangeCoder
 {
-    internal class Encoder : IAsyncDisposable
+    internal class Encoder
    {
        public const uint K_TOP_VALUE = (1 << 24);

@@ -41,46 +38,43 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            _cache = 0;
        }

-        public async ValueTask FlushData()
+        public void FlushData()
        {
            for (int i = 0; i < 5; i++)
            {
-                await ShiftLowAsync();
+                ShiftLow();
            }
        }

-        public Task FlushAsync()
+        public void FlushStream()
        {
-            return _stream.FlushAsync();
+            _stream.Flush();
        }

-        public ValueTask DisposeAsync()
+        public void CloseStream()
        {
-            return _stream.DisposeAsync();
+            _stream.Dispose();
        }

-        public async ValueTask EncodeAsync(uint start, uint size, uint total)
+        public void Encode(uint start, uint size, uint total)
        {
            _low += start * (_range /= total);
            _range *= size;
            while (_range < K_TOP_VALUE)
            {
                _range <<= 8;
-                await ShiftLowAsync();
+                ShiftLow();
            }
        }

-        public async ValueTask ShiftLowAsync()
+        public void ShiftLow()
        {
            if ((uint)_low < 0xFF000000 || (uint)(_low >> 32) == 1)
            {
-                using var buffer = MemoryPool<byte>.Shared.Rent(1);
-                var b = buffer.Memory.Slice(0,1);
                byte temp = _cache;
                do
                {
-                    b.Span[0] = (byte)(temp + (_low >> 32));
-                    await _stream.WriteAsync(b);
+                    _stream.WriteByte((byte)(temp + (_low >> 32)));
                    temp = 0xFF;
                }
                while (--_cacheSize != 0);
@@ -90,7 +84,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            _low = ((uint)_low) << 8;
        }

-        public async ValueTask EncodeDirectBits(uint v, int numTotalBits)
+        public void EncodeDirectBits(uint v, int numTotalBits)
        {
            for (int i = numTotalBits - 1; i >= 0; i--)
            {
@@ -102,12 +96,12 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
                if (_range < K_TOP_VALUE)
                {
                    _range <<= 8;
-                    await ShiftLowAsync();
+                    ShiftLow();
                }
            }
        }

-        public async ValueTask EncodeBitAsync(uint size0, int numTotalBits, uint symbol)
+        public void EncodeBit(uint size0, int numTotalBits, uint symbol)
        {
            uint newBound = (_range >> numTotalBits) * size0;
            if (symbol == 0)
@@ -122,7 +116,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            while (_range < K_TOP_VALUE)
            {
                _range <<= 8;
-                await ShiftLowAsync();
+                ShiftLow();
            }
        }

@@ -135,7 +129,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
        }
    }

-    internal class Decoder: IAsyncDisposable
+    internal class Decoder
    {
        public const uint K_TOP_VALUE = (1 << 24);
        public uint _range;
@@ -145,7 +139,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
        public Stream _stream;
        public long _total;

-        public async ValueTask InitAsync(Stream stream, CancellationToken cancellationToken)
+        public void Init(Stream stream)
        {
            // Stream.Init(stream);
            _stream = stream;
@@ -154,7 +148,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            _range = 0xFFFFFFFF;
            for (int i = 0; i < 5; i++)
            {
-                _code = (_code << 8) | await _stream.ReadByteAsync(cancellationToken);
+                _code = (_code << 8) | (byte)_stream.ReadByte();
            }
            _total = 5;
        }
@@ -165,34 +159,44 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            _stream = null;
        }

-        public ValueTask DisposeAsync()
+        public void CloseStream()
        {
-            return _stream.DisposeAsync();
+            _stream.Dispose();
        }

-        public async ValueTask NormalizeAsync(CancellationToken cancellationToken)
+        public void Normalize()
        {
            while (_range < K_TOP_VALUE)
            {
-                _code = (_code << 8) | await _stream.ReadByteAsync(cancellationToken);
+                _code = (_code << 8) | (byte)_stream.ReadByte();
                _range <<= 8;
                _total++;
            }
        }
-        
+
+        public void Normalize2()
+        {
+            if (_range < K_TOP_VALUE)
+            {
+                _code = (_code << 8) | (byte)_stream.ReadByte();
+                _range <<= 8;
+                _total++;
+            }
+        }
+
        public uint GetThreshold(uint total)
        {
            return _code / (_range /= total);
        }

-        public async ValueTask DecodeAsync(uint start, uint size, CancellationToken cancellationToken)
+        public void Decode(uint start, uint size)
        {
            _code -= start * _range;
            _range *= size;
-            await NormalizeAsync(cancellationToken);
+            Normalize();
        }

-        public async ValueTask<uint> DecodeDirectBitsAsync(int numTotalBits, CancellationToken cancellationToken)
+        public uint DecodeDirectBits(int numTotalBits)
        {
            uint range = _range;
            uint code = _code;
@@ -214,7 +218,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder

                if (range < K_TOP_VALUE)
                {
-                    code = (code << 8) | await _stream.ReadByteAsync(cancellationToken);
+                    code = (code << 8) | (byte)_stream.ReadByte();
                    range <<= 8;
                    _total++;
                }
@@ -224,7 +228,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            return result;
        }

-        public async ValueTask<uint> DecodeBitAsync(uint size0, int numTotalBits, CancellationToken cancellationToken)
+        public uint DecodeBit(uint size0, int numTotalBits)
        {
            uint newBound = (_range >> numTotalBits) * size0;
            uint symbol;
@@ -239,7 +243,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
                _code -= newBound;
                _range -= newBound;
            }
-            await NormalizeAsync(cancellationToken);
+            Normalize();
            return symbol;
        }

--- a/src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBit.cs
+++ b/src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBit.cs
@@ -1,7 +1,4 @@
 using System;
-using System.Buffers;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Compressors.LZMA.RangeCoder
 {
@@ -32,7 +29,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            }
        }

-        public async ValueTask EncodeAsync(Encoder encoder, uint symbol)
+        public void Encode(Encoder encoder, uint symbol)
        {
            // encoder.EncodeBit(Prob, kNumBitModelTotalBits, symbol);
            // UpdateModel(symbol);
@@ -51,7 +48,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            if (encoder._range < Encoder.K_TOP_VALUE)
            {
                encoder._range <<= 8;
-                await encoder.ShiftLowAsync();
+                encoder.ShiftLow();
            }
        }

@@ -113,7 +110,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            _prob = K_BIT_MODEL_TOTAL >> 1;
        }

-        public async ValueTask<uint> DecodeAsync(Decoder rangeDecoder, CancellationToken cancellationToken)
+        public uint Decode(Decoder rangeDecoder)
        {
            uint newBound = (rangeDecoder._range >> K_NUM_BIT_MODEL_TOTAL_BITS) * _prob;
            if (rangeDecoder._code < newBound)
@@ -122,7 +119,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
                _prob += (K_BIT_MODEL_TOTAL - _prob) >> K_NUM_MOVE_BITS;
                if (rangeDecoder._range < Decoder.K_TOP_VALUE)
                {
-                    rangeDecoder._code = (rangeDecoder._code << 8) | await rangeDecoder._stream.ReadByteAsync(cancellationToken);
+                    rangeDecoder._code = (rangeDecoder._code << 8) | (byte)rangeDecoder._stream.ReadByte();
                    rangeDecoder._range <<= 8;
                    rangeDecoder._total++;
                }
@@ -133,7 +130,7 @@ namespace SharpCompress.Compressors.LZMA.RangeCoder
            _prob -= (_prob) >> K_NUM_MOVE_BITS;
            if (rangeDecoder._range < Decoder.K_TOP_VALUE)
            {
-                rangeDecoder._code = (rangeDecoder._code << 8) | await rangeDecoder._stream.ReadByteAsync(cancellationToken);
+                rangeDecoder._code = (rangeDecoder._code << 8) | (byte)rangeDecoder._stream.ReadByte();
                rangeDecoder._range <<= 8;
                rangeDecoder._total++;
            }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Hathcock	3009e6dcfd	Mark for 0.32.2	2022-07-29 10:45:56 +01:00
Adam Hathcock	70343b17bc	add more tests for uncompressed streaming zips	2022-07-29 09:47:35 +01:00
Adam Hathcock	3f6027ec2c	Merge pull request #686 from Erior/477 Mitigation of problems	2022-07-29 09:41:24 +01:00
Lars Vahlenberg	5706732c55	Naive implementation of searching of DataDescriptor, not compatible with big archives (>32bit), but handles test cases.	2022-07-28 23:03:06 +02:00
Lars Vahlenberg	ad633a9dd0	missing test file from error report	2022-07-28 21:20:42 +02:00
Lars Vahlenberg	7c56df1237	Mitigation of problems	2022-07-28 20:36:28 +02:00
Adam Hathcock	c1110f2897	Merge pull request #683 from OwnageIsMagic/patch-1 WriteAll: use delegate instead of Expression	2022-07-27 10:13:50 +01:00
Adam Hathcock	647642578b	Merge branch 'master' into patch-1	2022-07-27 09:49:13 +01:00
OwnageIsMagic	5ca4efac31	WriteAll: revert `109a7c1`	2022-07-26 21:36:00 +03:00
Adam Hathcock	deddf12b70	Merge pull request #684 from daverant/nuget-license Include license in nuget package	2022-07-26 16:21:41 +01:00
OwnageIsMagic	109a7c12ea	WriteAll: update delegate type	2022-07-19 04:03:26 +03:00
David Rant	f955031e27	Hide license in IDE	2022-07-18 17:16:22 +01:00
David Rant	6a69c6cd02	Reference bundled package license file	2022-07-18 17:11:06 +01:00
David Rant	c1d4ac45ab	Include license when packing	2022-07-18 17:10:36 +01:00
OwnageIsMagic	2946a35b0e	WriteAll: use delegate instead of Expression	2022-07-18 04:36:31 +03:00
Adam Hathcock	c73a8cb18f	Merge pull request #682 from adamhathcock/RarFileVolIdx_RarArcVer_GzCrc	2022-07-16 11:29:48 +01:00
Nanook	574a093038	Minor tweak that got missed in the last tidy.	2022-07-15 21:25:39 +01:00
Nanook	4eb1fe0b80	RarArchive has Min/MaxVersion. RarEntry has Volumne Indexes. GZ CRC fix.	2022-07-15 21:15:10 +01:00
Adam Hathcock	4c46cd725b	Merge pull request #679 from louis-michelbergeron/master Fix LZMADecoder Code function	2022-06-28 08:27:13 +01:00
Adam Hathcock	fdbd0e1fba	Merge branch 'master' into master	2022-06-28 08:21:49 +01:00
louis-michel	5801168ce0	Merge branch 'master' of https://github.com/louis-michelbergeron/sharpcompress	2022-06-27 19:13:20 -04:00
louis-michel	d4c7551087	Fix LZMA Code function	2022-06-27 19:13:10 -04:00
Adam Hathcock	c9daf0c9f5	Merge pull request #675 from Erior/feature/#636 ReadOnlySubStream overrides and adds logic #636	2022-06-22 11:17:18 +01:00
Adam Hathcock	8cb566b031	Merge branch 'master' into feature/#636	2022-06-22 09:05:57 +01:00
Lars Vahlenberg	089b16326e	ReadOnlySubStream overrides and adds logic to Read byte[], needs to have same logic for Span<byte> for consistency.	2022-06-21 19:30:07 +02:00
Adam Hathcock	c0e43cc0e5	Mark for 0.32.1	2022-06-20 10:32:47 +01:00
Adam Hathcock	514c3539e6	Merge pull request #672 from MartinDemberger/Task_477 Corrected skip-marker on skip of uncompressed ZIP file with missing size informations.	2022-06-20 10:31:31 +01:00
Adam Hathcock	62c94a178c	Merge branch 'master' into Task_477	2022-06-20 10:26:45 +01:00
Adam Hathcock	9fee38b18d	Merge pull request #674 from MartinDemberger/DeduplicateNonDisposing Suppress nested NonDisposingStream	2022-06-20 10:25:25 +01:00
Adam Hathcock	cd3114d39e	Merge branch 'master' into DeduplicateNonDisposing	2022-06-20 10:20:02 +01:00
Adam Hathcock	12b4e15812	Merge pull request #673 from Erior/feature/Malformed-zip-file-generated Feature/malformed zip file generated	2022-06-20 10:19:41 +01:00
Martin Demberger	35336a0827	Suppress nested NonDisposingStream	2022-06-19 22:05:52 +02:00
Martin Demberger	ece7cbfec3	Set skip-marker when stream is skipped	2022-06-18 14:35:14 +02:00
Lars Vahlenberg	a00075ee0d	Wrong flags set, we do not expose this in the interface	2022-06-17 15:07:07 +02:00
Lars Vahlenberg	b6c4e28b4d	Generated test case, however, don't see any problems	2022-06-16 23:32:46 +02:00
Martin Demberger	8b55cce39a	Better handling of uncompressed zip files.	2022-06-15 16:28:14 +02:00
Adam Hathcock	6e99446ce5	Mark for 0.32	2022-06-13 15:28:54 +01:00
Adam Hathcock	20a09b4866	Drop net5	2022-06-13 15:24:53 +01:00
Adam Hathcock	7f7db5eabd	Merge pull request #669 from louis-michelbergeron/master XZ decoding BCJ filters support	2022-06-13 08:37:28 +01:00
louis-michelbergeron	0651d064fc	Update README.md	2022-06-10 15:32:41 -04:00
louis-michelbergeron	73ca7759d3	Update README.md Contribution line.	2022-06-10 15:32:08 -04:00
louis-michel	0f112d0685	BCJ executable filter (only for decoding), used by XZ.	2022-06-10 13:29:42 -04:00
Adam Hathcock	fa5c91ecf6	Merge pull request #663 from Nanook/master Align behavour of 7Zip exception with encrypted filenames arc with rar when no password provided	2022-05-04 08:21:39 +01:00
Nanook	3b2fd1b9fa	Merge branch 'adamhathcock:master' into master	2022-05-04 01:36:58 +01:00
Craig	e424094fdf	7z encrypted filename exception with no password matches rar behaviour.	2022-05-04 01:35:58 +01:00
Adam Hathcock	bad9ab2c9d	Merge pull request #662 from Nanook/master Properly integrated zip multivolume and general split support.	2022-05-03 08:23:33 +01:00
Craig	61c01ce9b0	Properly integrated zip multivolume and split support.	2022-04-30 19:35:40 +01:00
Adam Hathcock	3de5df9f38	Merge pull request #661 from Nanook/master Added multipart Zip support (z01...). Added IEntry.IsSolid	2022-04-29 13:43:37 +01:00
Craig	910aa1c22e	Corrected the Crc exception as it was within a #DEBUG define	2022-04-27 14:12:00 +01:00
Craig	71c8f3129f	RarStream Position fix, it was returning the file size. 7Zip CrcCheckStream always failed. Added a Solid Rar entry CRC test.	2022-04-27 13:16:05 +01:00
Craig	224614312f	Added multipart Zip support (z01...). Added IEntry.IsSolid and implemented Rar and 7Zi[ support.	2022-04-25 01:16:53 +01:00
Adam Hathcock	f717133947	Merge pull request #660 from adamhathcock/dependabot/github_actions/actions/upload-artifact-3 Bump actions/upload-artifact from 2 to 3	2022-04-21 11:16:52 +01:00
dependabot[bot]	fcbfcfed03	Bump actions/upload-artifact from 2 to 3 Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 2 to 3. - [Release notes](https://github.com/actions/upload-artifact/releases) - [Commits](https://github.com/actions/upload-artifact/compare/v2...v3) --- updated-dependencies: - dependency-name: actions/upload-artifact dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com>	2022-04-21 08:52:47 +00:00
Adam Hathcock	e6601c91ca	Merge pull request #659 from adamhathcock/updates Dependency updates and start of enforcing some C# standards	2022-04-21 09:52:26 +01:00
Adam Hathcock	0379903689	Fix tests	2022-04-21 08:59:35 +01:00
Adam Hathcock	6950eebf9f	Dependency updates and start of enforcing some C# standards	2022-04-21 08:54:59 +01:00
Adam Hathcock	c15f1327c9	Merge pull request #658 from Nanook/master Added Split archive support with unit tests. …	2022-04-21 08:26:06 +01:00
Craig	ec1999f73d	Added Split archive support with unit tests. Added ArchiveFactory.IsArchive() and minor refactor.	2022-04-21 00:12:26 +01:00
Adam Hathcock	3d0a18b05d	Merge pull request #655 from Ryhon0/master Tar file mode, user and group	2022-04-11 16:43:40 +01:00
Ryhon	156a02c5a8	Tar file mode, user and group	2022-04-11 14:33:55 +02:00
Adam Hathcock	eba1a443e3	Merge pull request #652 from ds5678/net6_with_trimming Add a net 6 target and make trimmable	2022-04-11 10:14:18 +01:00
ds5678	eb44cdc903	Update dotnetcore.yml	2022-04-08 02:21:07 -04:00
Jeremy Pritts	196df63de2	fix build project	2022-03-31 14:52:36 -04:00
Jeremy Pritts	ed3c11f44c	update workflow and csproj files	2022-03-31 04:04:56 -04:00
Jeremy Pritts	7f6c877fdc	add a net 6 target and make trimmable	2022-03-30 21:24:51 -04:00
Adam Hathcock	eee8309db8	Mark for 0.31	2022-03-30 12:03:03 +01:00
Adam Hathcock	155cfab792	Merge pull request #651 from loop-evgeny/evgeny-upgrade-adler32 Update Adler32 from ImageSharp v2.1.0	2022-03-30 12:01:32 +01:00
Evgeny Morozov	e1c36afdec	Update Adler32 from ImageSharp v2.1.0 Adler32.cs is taken from `09b2cdb83a` with minimal change to make it build as part of SharpCompress. Fixes https://github.com/adamhathcock/sharpcompress/issues/650 and https://github.com/adamhathcock/sharpcompress/issues/645.	2022-03-30 12:17:14 +02:00
Adam Hathcock	6b0d6a41ca	Merge pull request #638 from Nanook/rar2MultiWithTest Rar2 fix with new unit tests that fail on previous build.	2022-02-16 08:33:12 +00:00
Craig	dab157bb71	Rar2 fix with new unit tests that fail on previous build.	2022-02-15 16:24:22 +00:00
Adam Hathcock	8d17d09455	Merge pull request #624 from adamhathcock/issue-617 Add test and probable fix for Issue 617	2021-11-22 09:20:15 +00:00
Adam Hathcock	05208ccd9b	Add test and probable fix for Issue 617	2021-11-22 08:40:40 +00:00
Adam Hathcock	a1e7c0068d	Merge pull request #622 from adamhathcock/net461-tests Net461 tests	2021-10-02 15:32:20 +01:00
Adam Hathcock	e6bec19946	Mark for 0.30	2021-10-02 15:29:22 +01:00
Adam Hathcock	ec2be2869f	Fix whitespace from dotnet format	2021-10-02 15:29:03 +01:00
Adam Hathcock	ce5432ed73	Fix tests for multi-targetting	2021-10-02 15:25:43 +01:00
Adam Hathcock	b6e0ad89ce	Remove duplicated artifact step	2021-10-02 15:21:05 +01:00
Adam Hathcock	2745bfa19b	Minor SDK update	2021-10-02 15:19:51 +01:00
Adam Hathcock	3cdc4b38a6	Test 461 on github actions	2021-10-02 15:19:13 +01:00
Adam Hathcock	fc1ca808d7	Merge pull request #621 from inthemedium/master Add net461 target to clean up issues with system.* nuget dependencies	2021-10-02 15:08:18 +01:00
Jeff Tyson	6983e66037	Fix preprocessor condition	2021-10-01 16:34:00 +00:00
Jeff Tyson	01f7336d09	Based on docs, the target should bet net461	2021-09-29 22:04:47 +00:00
Jeff Tyson	1561bba538	Add net462 target to clean up issues with system.* nuget dependencies	2021-09-29 21:55:11 +00:00
Adam Hathcock	3ecf8a5e0c	Merge pull request #616 from amosonn/patch-1 Fix for chunked read for ZLibBaseStream	2021-09-27 09:14:58 +01:00
Adam Hathcock	e2095fc416	Merge branch 'master' into patch-1	2021-09-27 09:08:58 +01:00
Amos Onn	8398d40106	Fix #615	2021-09-14 22:02:18 +02:00
Amos Onn	134fa8892f	Test for bug #615	2021-09-14 21:55:05 +02:00
Adam Hathcock	ea5c8dc063	Merge pull request #614 from adamhathcock/ensure-dest-dir-exists Ensure destination directory exists.	2021-09-12 08:56:42 +01:00
Adam Hathcock	0209d00164	Minor updates and prep for 0.29	2021-09-12 08:52:00 +01:00
Adam Hathcock	a8d065dc9e	Ensure destination directory exists	2021-09-12 08:47:30 +01:00
Adam Hathcock	7bd9711ade	Merge pull request #610 from cyr/master Bugfix for TarWriter - too much padding in large files	2021-09-12 08:43:20 +01:00
cyr	61802eadb4	Merge branch 'adamhathcock:master' into master	2021-09-12 09:37:07 +02:00
Adam Hathcock	b425659058	Merge pull request #611 from Thunderstr1k3/fix-zipheader-seeking Allowing to seek empty zip files	2021-09-12 08:28:05 +01:00
Christian	3e32e3d7b1	Allowing to seek empty zip files	2021-09-02 13:54:32 +02:00
cyr	1b661c9df1	Fixed bug where large (int32+ file size) adds an additional 512 bytes of padding in tar files.	2021-08-27 22:38:04 +02:00
Adam Hathcock	54fc26b93d	Update build and mark for 0.28.3	2021-06-04 13:43:35 +01:00
Adam Hathcock	161f99bbad	Merge pull request #601 from salvois/master Write ZIP64 End of Central Directory only if needed.	2021-06-04 13:22:01 +01:00
Adam Hathcock	c012db0776	Merge branch 'master' into master	2021-06-04 13:17:13 +01:00
Adam Hathcock	8ee257d299	Merge pull request #592 from adamhathcock/memory-downgrade Downgrade System.Memory to fix buffer version issue	2021-06-04 13:16:40 +01:00
Adam Hathcock	f9522107c3	Merge branch 'master' into memory-downgrade	2021-06-04 13:16:34 +01:00
Adam Hathcock	e07046a37a	Merge pull request #596 from DannyBoyk/issue_595_conditionally_read_zip64_extra Conditionally parse Zip64 extra field based on specification	2021-06-04 13:07:08 +01:00
Salvatore Isaja	ad6d0d9ae8	Write ZIP64 End of Central Directory only if needed.	2021-05-23 21:10:35 +02:00
Daniel Nash	fdc33e91bd	Conditionally parse Zip64 extra field based on specification The Zip64 extra field should look for values based on the corresponding values in the local entry header. Fixes adamhathcock/sharpcompress#595	2021-04-26 14:58:10 -04:00
Adam Hathcock	a34f5a855c	Mark for 0.28.2	2021-04-25 09:29:56 +01:00
Adam Hathcock	6474741af1	Merge pull request #593 from adamhathcock/fix-pkware-encryption ReadFully used by pkware encryption didn’t like spans	2021-04-25 09:29:02 +01:00
Adam Hathcock	c10bd840c5	ReadFully used by pkware encryption didn’t like spans	2021-04-25 09:25:51 +01:00
Adam Hathcock	e6dded826b	Downgrade System.Memory to fix buffer version issue	2021-04-24 09:16:46 +01:00
Adam Hathcock	8a022c4b18	Update FORMATS.md remove LZipArchive/Reader/Writer mention	2021-03-28 08:58:11 +01:00
Adam Hathcock	cfef228afc	Merge pull request #579 from Looooong/fix/do-not-place-extention-classes-in-common-namespace Do not place extension classes in common namespace	2021-03-18 13:52:40 +00:00
Nguyễn Đức Long	237ff9f055	Do not place extension classes in common namespace	2021-03-18 20:44:04 +07:00
Adam Hathcock	020f862814	Bug fix for recursive call introduced in 0.28	2021-02-18 08:31:50 +00:00
Adam Hathcock	fa6107200d	Merge pull request #572 from Erior/feature/521 Not so elegant perhaps for checking 7z encryption	2021-02-16 08:05:08 +00:00
Adam Hathcock	eb81f972c4	Merge branch 'master' into feature/521	2021-02-16 08:01:32 +00:00
Lars Vahlenberg	93c1ff396e	Not so elegant perhaps	2021-02-14 16:29:01 +01:00