Mark for 0.32

Drop net5
Merge pull request #669 from louis-michelbergeron/master
2026-02-04 13:34:59 +00:00 · 2022-06-13 15:28:54 +01:00 · 2022-06-13 15:24:53 +01:00 · 2022-06-13 08:37:28 +01:00 · 2022-06-10 15:32:41 -04:00 · 2022-06-10 15:32:08 -04:00
147 changed files with 3945 additions and 1042 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,8 +1,9 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
+using SharpCompress.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Archives
@@ -23,28 +24,14 @@ namespace SharpCompress.Archives
        protected ReaderOptions ReaderOptions { get; }

        private bool disposed;
+        protected SourceStream SrcStream;

-        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
+        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));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
-        }
-
-
-        protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
-
-        internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
-        {
-            Type = type;
-            ReaderOptions = readerOptions;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams)));
+            ReaderOptions = srcStream.ReaderOptions;
+            SrcStream = srcStream;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
        }

@@ -98,7 +85,7 @@ namespace SharpCompress.Archives
        /// </summary>
        public virtual long TotalUncompressSize => Entries.Aggregate(0L, (total, cf) => total + cf.Size);

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

        IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
@@ -111,6 +98,8 @@ namespace SharpCompress.Archives
            {
                lazyVolumes.ForEach(v => v.Dispose());
                lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+                if (SrcStream != null)
+                    SrcStream.Dispose();
                disposed = true;
            }
        }
--- a/src/SharpCompress/Archives/AbstractWritableArchive.cs
+++ b/src/SharpCompress/Archives/AbstractWritableArchive.cs
@@ -1,8 +1,9 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Writers;

@@ -40,13 +41,8 @@ namespace SharpCompress.Archives
        {
        }

-        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions)
-            : base(type, stream.AsEnumerable(), readerFactoryOptions)
-        {
-        }
-
-        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
-            : base(type, fileInfo, readerFactoryOptions)
+        internal AbstractWritableArchive(ArchiveType type, SourceStream srcStream)
+            : base(type, srcStream)
        {
        }

--- a/src/SharpCompress/Archives/ArchiveFactory.cs
+++ b/src/SharpCompress/Archives/ArchiveFactory.cs
@@ -1,11 +1,14 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using SharpCompress.Archives.GZip;
 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
@@ -26,34 +29,25 @@ namespace SharpCompress.Archives
                throw new ArgumentException("Stream should be readable and seekable");
            }
            readerOptions ??= new ReaderOptions();
-            if (ZipArchive.IsZipFile(stream, null))
+
+            ArchiveType? type;
+            IsArchive(stream, out type); //test and reset stream position
+
+            if (type != null)
            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return ZipArchive.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 (GZipArchive.IsGZipFile(stream))
-            {
-                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 (TarArchive.IsTarFile(stream))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return TarArchive.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);
+                }
            }
            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
        }
@@ -90,30 +84,108 @@ namespace SharpCompress.Archives
            fileInfo.CheckNotNull(nameof(fileInfo));
            options ??= new ReaderOptions { LeaveStreamOpen = false };

-            using var stream = fileInfo.OpenRead();
-            if (ZipArchive.IsZipFile(stream, null))
+            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 (GZipArchive.IsGZipFile(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="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);
-            }
-            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);
+                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);
+                }
            }
            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
        }
@@ -130,5 +202,95 @@ namespace SharpCompress.Archives
                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,9 +1,10 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
 using SharpCompress.Writers;
@@ -32,7 +33,31 @@ namespace SharpCompress.Archives.GZip
        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
+            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>
@@ -43,7 +68,7 @@ namespace SharpCompress.Archives.GZip
        public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
-            return new GZipArchive(stream, readerOptions ?? new ReaderOptions());
+            return new GZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
        }

        public static GZipArchive Create()
@@ -52,20 +77,20 @@ 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)
-            : base(ArchiveType.GZip, fileInfo, options)
+        internal GZipArchive(SourceStream srcStream)
+            : base(ArchiveType.Tar, srcStream)
        {
        }

-        protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file)
+        protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream srcStream)
        {
-            return new GZipVolume(file, ReaderOptions).AsEnumerable();
+            srcStream.LoadAllParts();
+            return srcStream.Streams.Select(a => new GZipVolume(a, ReaderOptions));
        }
-
        public static bool IsGZipFile(string filePath)
        {
            return IsGZipFile(new FileInfo(filePath));
@@ -98,7 +123,7 @@ namespace SharpCompress.Archives.GZip
        public static bool IsGZipFile(Stream stream)
        {
            // read the header on the first read
-            byte[] header = new byte[10];
+            Span<byte> header = stackalloc byte[10];

            // workitem 8501: handle edge case (decompress empty stream)
            if (!stream.ReadFully(header))
@@ -114,16 +139,6 @@ 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)
-            : base(ArchiveType.GZip, stream, options)
-        {
-        }
-
        internal GZipArchive()
            : base(ArchiveType.GZip)
        {
@@ -160,11 +175,6 @@ namespace SharpCompress.Archives.GZip
            }
        }

-        protected override IEnumerable<GZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new GZipVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
        protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
        {
            Stream stream = volumes.Single().Stream;
--- a/src/SharpCompress/Archives/Rar/RarArchive.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchive.cs
@@ -5,49 +5,48 @@ 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 RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
+    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)
        {
        }

        protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes)
        {
-            return RarArchiveEntryFactory.GetEntries(this, volumes);
+            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();
+            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));
+            }
+            else //split mode or single file
+                return new StreamRarArchiveVolume(base.SrcStream, ReaderOptions).AsEnumerable();
        }

        protected override IReader CreateReaderForSolidExtraction()
@@ -68,7 +67,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>
@@ -79,7 +79,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>
@@ -90,20 +90,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
@@ -6,6 +6,7 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
+using SharpCompress.Readers;

 namespace SharpCompress.Archives.Rar
 {
@@ -13,11 +14,14 @@ namespace SharpCompress.Archives.Rar
    {
        private readonly ICollection<RarFilePart> parts;
        private readonly RarArchive archive;
+        private readonly ReaderOptions readerOptions;

-        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts)
+        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts, ReaderOptions readerOptions)
        {
            this.parts = parts.ToList();
            this.archive = archive;
+            this.readerOptions = readerOptions;
+            this.IsSolid = this.FileHeader.IsSolid;
        }

        public override CompressionType CompressionType => CompressionType.Rar;
@@ -69,13 +73,14 @@ namespace SharpCompress.Archives.Rar
        {
            get
            {
-                return parts.Select(fp => fp.FileHeader).Any(fh => !fh.IsSplitAfter);
+                var headers = parts.Select(x => x.FileHeader);
+                return !headers.First().IsSplitBefore && !headers.Last().IsSplitAfter;
            }
        }

        private void CheckIncomplete()
        {
-            if (!IsComplete)
+            if (!readerOptions.DisableCheckIncomplete && !IsComplete)
            {
                throw new IncompleteArchiveException("ArchiveEntry is incomplete and cannot perform this operation.");
            }
--- a/src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using SharpCompress.Common.Rar;
+using SharpCompress.Readers;

 namespace SharpCompress.Archives.Rar
 {
@@ -36,11 +37,12 @@ namespace SharpCompress.Archives.Rar
        }

        internal static IEnumerable<RarArchiveEntry> GetEntries(RarArchive archive,
-                                                                IEnumerable<RarVolume> rarParts)
+                                                                IEnumerable<RarVolume> rarParts,
+                                                                ReaderOptions readerOptions)
        {
            foreach (var groupedParts in GetMatchedFileParts(rarParts))
            {
-                yield return new RarArchiveEntry(archive, groupedParts);
+                yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
            }
        }
    }
--- 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/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,23 @@ 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
+            return new SevenZipVolume(srcStream, ReaderOptions).AsEnumerable(); //simple single volume or split, multivolume not supported
        }

        public static bool IsSevenZipFile(string filePath)
@@ -74,38 +105,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,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -34,7 +34,31 @@ namespace SharpCompress.Archives.Tar
        public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions());
+            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>
@@ -45,7 +69,7 @@ namespace SharpCompress.Archives.Tar
        public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
-            return new TarArchive(stream, readerOptions ?? new ReaderOptions());
+            return new TarArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
        }

        public static bool IsTarFile(string filePath)
@@ -80,28 +104,19 @@ 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)
-            : base(ArchiveType.Tar, fileInfo, readerOptions)
+        protected override IEnumerable<TarVolume> LoadVolumes(SourceStream srcStream)
        {
-        }
-
-        protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
-        {
-            return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
+            base.SrcStream.LoadAllParts(); //request all streams
+            return new TarVolume(srcStream, ReaderOptions).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)
-            : base(ArchiveType.Tar, stream, readerOptions)
+        /// <param name="srcStream"></param>
+        /// <param name="options"></param>
+        internal TarArchive(SourceStream srcStream)
+            : base(ArchiveType.Tar, srcStream)
        {
        }

@@ -110,11 +125,6 @@ namespace SharpCompress.Archives.Tar
        {
        }

-        protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new TarVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
        protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
        {
            Stream stream = volumes.Single().Stream;
--- a/src/SharpCompress/Archives/Zip/ZipArchive.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchive.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -6,6 +6,7 @@ using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Zip;
 using SharpCompress.Writers;
@@ -25,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>
@@ -44,7 +56,31 @@ namespace SharpCompress.Archives.Zip
        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
        {
            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
+            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>
@@ -55,7 +91,7 @@ namespace SharpCompress.Archives.Zip
        public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
        {
            stream.CheckNotNull(nameof(stream));
-            return new ZipArchive(stream, readerOptions ?? new ReaderOptions());
+            return new ZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
        }

        public static bool IsZipFile(string filePath, string? password = null)
@@ -97,20 +133,61 @@ 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)
-            : base(ArchiveType.Zip, fileInfo, readerOptions)
+        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 IEnumerable<ZipVolume> LoadVolumes(FileInfo file)
+        protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream srcStream)
        {
-            return new ZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
+            base.SrcStream.LoadAllParts(); //request all streams
+            base.SrcStream.Position = 0;
+
+            List<Stream> streams = base.SrcStream.Streams.ToList();
+            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));
+                }
+            }
+
+            //split mode or single file
+            return new ZipVolume(base.SrcStream, ReaderOptions).AsEnumerable();
        }

        internal ZipArchive()
@@ -118,46 +195,35 @@ 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)
-            : base(ArchiveType.Zip, stream, readerOptions)
-        {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
-        }
-
-        protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new ZipVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
        protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
        {
-            var volume = volumes.Single();
-            Stream stream = volume.Stream;
-            foreach (ZipHeader h in headerFactory.ReadSeekableHeader(stream))
+            var vols = volumes.ToArray();
+            foreach (ZipHeader h in headerFactory.ReadSeekableHeader(vols.Last().Stream))
            {
                if (h != null)
                {
                    switch (h.ZipHeaderType)
                    {
                        case ZipHeaderType.DirectoryEntry:
+                        {
+                            DirectoryEntryHeader deh = (DirectoryEntryHeader)h;
+                            Stream s;
+                            if (deh.RelativeOffsetOfEntryHeader + deh.CompressedSize > vols[deh.DiskNumberStart].Stream.Length)
                            {
-                                yield return new ZipArchiveEntry(this,
-                                                                 new SeekableZipFilePart(headerFactory,
-                                                                                         (DirectoryEntryHeader)h,
-                                                                                         stream));
+                                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 });
                            }
-                            break;
+                            else
+                                s = vols[deh.DiskNumberStart].Stream;
+                            yield return new ZipArchiveEntry(this, new SeekableZipFilePart(headerFactory, deh, s));
+                        }
+                        break;
                        case ZipHeaderType.DirectoryEnd:
-                            {
-                                byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                                volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                                yield break;
-                            }
+                        {
+                            byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
+                            volumes.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                            yield break;
+                        }
                    }
                }
            }
--- 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/Common/ArchiveEncoding.cs
+++ b/src/SharpCompress/Common/ArchiveEncoding.cs
@@ -36,7 +36,7 @@ namespace SharpCompress.Common
            Password = password;
        }

-#if !NET461
+#if !NETFRAMEWORK
        static ArchiveEncoding()
        {
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
--- a/src/SharpCompress/Common/Entry.cs
+++ b/src/SharpCompress/Common/Entry.cs
@@ -75,7 +75,7 @@ namespace SharpCompress.Common

        internal abstract IEnumerable<FilePart> Parts { get; }

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

        internal virtual void Close()
        {
--- a/src/SharpCompress/Common/ExtractionMethods.cs
+++ b/src/SharpCompress/Common/ExtractionMethods.cs
@@ -14,14 +14,25 @@ namespace SharpCompress.Common
                                                 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)!;
--- a/src/SharpCompress/Common/GZip/GZipFilePart.cs
+++ b/src/SharpCompress/Common/GZip/GZipFilePart.cs
@@ -110,13 +110,13 @@ namespace SharpCompress.Common.GZip

        private string ReadZeroTerminatedString(Stream stream)
        {
-            byte[] buf1 = new byte[1];
+            Span<byte> buf1 = stackalloc byte[1];
            var list = new List<byte>();
            bool done = false;
            do
            {
                // workitem 7740
-                int n = stream.Read(buf1, 0, 1);
+                int n = stream.Read(buf1);
                if (n != 1)
                {
                    throw new ZlibException("Unexpected EOF reading GZIP header.");
--- a/src/SharpCompress/Common/IEntry.cs
+++ b/src/SharpCompress/Common/IEntry.cs
@@ -14,6 +14,7 @@ namespace SharpCompress.Common
        bool IsDirectory { get; }
        bool IsEncrypted { get; }
        bool IsSplitAfter { get; }
+        bool IsSolid { get; }
        DateTime? LastAccessedTime { get; }
        DateTime? LastModifiedTime { get; }
        long Size { get; }
--- a/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
@@ -437,6 +437,7 @@ namespace SharpCompress.Common.Rar.Headers
        internal long DataStartPosition { get; set; }
        public Stream PackedStream { get; set; }

+        public bool IsSplitBefore => IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_BEFORE) : HasFlag(FileFlagsV4.SPLIT_BEFORE);
        public bool IsSplitAfter => IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_AFTER) : HasFlag(FileFlagsV4.SPLIT_AFTER);

        public bool IsDirectory => HasFlag(IsRar5 ? FileFlagsV5.DIRECTORY : FileFlagsV4.DIRECTORY);
--- a/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
+++ b/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
@@ -50,11 +50,11 @@ namespace SharpCompress.Common.Rar
            if (sizeToRead > 0)
            {
                int alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
-                byte[] cipherText = new byte[RarRijndael.CRYPTO_BLOCK_SIZE];
+                Span<byte> cipherText = stackalloc byte[RarRijndael.CRYPTO_BLOCK_SIZE];
                for (int i = 0; i < alignedSize / 16; i++)
                {
                    //long ax = System.currentTimeMillis();
-                    _actualStream.Read(cipherText, 0, RarRijndael.CRYPTO_BLOCK_SIZE);
+                    _actualStream.Read(cipherText);

                    var readBytes = _rijndael.ProcessBlock(cipherText);
                    foreach (var readByte in readBytes)
--- 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/SevenZip/ArchiveReader.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
@@ -1248,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);
@@ -1517,6 +1517,7 @@ namespace SharpCompress.Common.SevenZip
                }
            }

+            byte[] buffer = null;
            foreach (CExtractFolderInfo efi in extractFolderInfoVector)
            {
                int startIndex;
@@ -1553,7 +1554,7 @@ namespace SharpCompress.Common.SevenZip

                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes,
                                                                   folderInfo, db.PasswordProvider);
-                byte[] buffer = new byte[4 << 10];
+                buffer ??= new byte[4 << 10];
                for (; ; )
                {
                    int processed = s.Read(buffer, 0, buffer.Length);
--- 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
@@ -102,5 +102,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/Tar/Headers/TarHeader.cs
+++ b/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
@@ -19,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; }
@@ -97,7 +95,7 @@ namespace SharpCompress.Common.Tar.Headers
            {
                numPaddingBytes = BLOCK_SIZE;
            }
-            output.Write(new byte[numPaddingBytes], 0, numPaddingBytes);
+            output.Write(stackalloc byte[numPaddingBytes]);
        }

        internal bool Read(BinaryReader reader)
@@ -127,9 +125,12 @@ namespace SharpCompress.Common.Tar.Headers
            EntryType = ReadEntryType(buffer);
            Size = ReadSize(buffer);

-            //Mode = ReadASCIIInt32Base8(buffer, 100, 7);
-            //UserId = ReadASCIIInt32Base8(buffer, 108, 7);
-            //GroupId = ReadASCIIInt32Base8(buffer, 116, 7);
+            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();

--- a/src/SharpCompress/Common/Tar/TarEntry.cs
+++ b/src/SharpCompress/Common/Tar/TarEntry.cs
@@ -44,6 +44,12 @@ 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 IEnumerable<TarEntry> GetEntries(StreamingMode mode, Stream stream,
--- a/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs
@@ -63,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/LocalEntryHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs
@@ -53,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,62 +66,74 @@ namespace SharpCompress.Common.Zip.Headers
        public Zip64ExtendedInformationExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
            : base(type, length, dataBytes)
        {
-            Process();
        }

-        //From the spec values are only in the extradata if the standard
-        //value is set to 0xFFFF, but if one of the sizes are present, both are.
-        //Hence if length == 4 volume only
-        //      if length == 8 offset only
-        //      if length == 12 offset + volume
-        //      if length == 16 sizes only
-        //      if length == 20 sizes + volume
-        //      if length == 24 sizes + offset
-        //      if length == 28 everything.
-        //It is unclear how many of these are used in the wild.
-
-        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)
        {
-            switch (DataBytes.Length)
+            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)
            {
-                case 4:
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes);
-                    return;
-                case 8:
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    return;
-                case 12:
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(8));
-                    return;
-                case 16:
-                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
-                    return;
-                case 20:
-                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(16));
-                    return;
-                case 24:
-                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
-                    return;
-                case 28:
-                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(24));
-                    return;
-                default:
-                    throw new ArchiveException("Unexpected size of of Zip64 extended information extra field");
+                throw new ArchiveException("Zip64 extended information extra field is not large enough for the required information");
+            }
+
+            if (uncompressedFileSize == uint.MaxValue)
+            {
+                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
+            }
+
+            if (compressedFileSize == uint.MaxValue)
+            {
+                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
+            }
+
+            if (relativeHeaderOffset == uint.MaxValue)
+            {
+                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
+                currentIndex += 8;
+            }
+
+            if (diskNumber == ushort.MaxValue)
+            {
+                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/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/SeekableZipHeaderFactory.cs
+++ b/src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs
@@ -8,7 +8,10 @@ namespace SharpCompress.Common.Zip
 {
    internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
    {
-        private const int MAX_ITERATIONS_FOR_DIRECTORY_HEADER = 4096;
+        private const int MINIMUM_EOCD_LENGTH = 22;
+        private const int ZIP64_EOCD_LENGTH = 20;
+        // Comment may be within 64kb + structure 22 bytes
+        private const int MAX_SEARCH_LENGTH_FOR_EOCD = 65557;
        private bool _zip64;

        internal SeekableZipHeaderFactory(string? password, ArchiveEncoding archiveEncoding)
@@ -20,14 +23,24 @@ namespace SharpCompress.Common.Zip
        {
            var reader = new BinaryReader(stream);

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

            if (entry.IsZip64)
            {
                _zip64 = true;
-                SeekBackToHeader(stream, reader, ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR);
+
+                // ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR should be before the EOCD
+                stream.Seek(eocd_location - ZIP64_EOCD_LENGTH - 4, SeekOrigin.Begin);
+                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();
                zip64Locator.Read(reader);

@@ -73,27 +86,50 @@ namespace SharpCompress.Common.Zip
            }
        }

-        private static void SeekBackToHeader(Stream stream, BinaryReader reader, uint headerSignature)
+        private static bool IsMatch(byte[] haystack, int position, byte[] needle)
        {
-            long offset = 0;
-            uint signature;
-            int iterationCount = 0;
-            do
+            for (int i = 0; i < needle.Length; i++)
            {
-                if ((stream.Length + offset) - 4 < 0)
+                if (haystack[position + i] != needle[i])
                {
-                    throw new ArchiveException("Failed to locate the Zip Header");
-                }
-                stream.Seek(offset - 4, SeekOrigin.End);
-                signature = reader.ReadUInt32();
-                offset--;
-                iterationCount++;
-                if (iterationCount > MAX_ITERATIONS_FOR_DIRECTORY_HEADER)
-                {
-                    throw new ArchiveException("Could not find Zip file Directory at the end of the file.  File may be corrupted.");
+                    return false;
                }
            }
-            while (signature != headerSignature);
+
+            return true;
+        }
+        private static void SeekBackToHeader(Stream stream, BinaryReader reader)
+        {
+            // Minimum EOCD length
+            if (stream.Length < MINIMUM_EOCD_LENGTH)
+            {
+                throw new ArchiveException("Could not find Zip file Directory at the end of the file. File may be corrupted.");
+            }
+
+            int len = stream.Length < MAX_SEARCH_LENGTH_FOR_EOCD ? (int)stream.Length : MAX_SEARCH_LENGTH_FOR_EOCD;
+            // We search for marker in reverse to find the first occurance
+            byte[] needle = { 0x06, 0x05, 0x4b, 0x50 };
+
+            stream.Seek(-len, SeekOrigin.End);
+
+            byte[] seek = reader.ReadBytes(len);
+
+            // Search in reverse
+            Array.Reverse(seek);
+
+            // don't exclude the minimum eocd region, otherwise you fail to locate the header in empty zip files
+            var max_search_area = len; // - MINIMUM_EOCD_LENGTH;
+
+            for (int pos_from_end = 0; pos_from_end < max_search_area; ++pos_from_end)
+            {
+                if (IsMatch(seek, pos_from_end, needle))
+                {
+                    stream.Seek(-pos_from_end, SeekOrigin.End);
+                    return;
+                }
+            }
+
+            throw new ArchiveException("Failed to locate the Zip Header");
        }

        internal LocalEntryHeader GetLocalHeader(Stream stream, DirectoryEntryHeader directoryEntryHeader)
--- a/src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs
+++ b/src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs
@@ -75,7 +75,7 @@ namespace SharpCompress.Common.Zip
            if (disposing)
            {
                //read out last 10 auth bytes
-                var ten = new byte[10];
+                Span<byte> ten = stackalloc byte[10];
                _stream.ReadFully(ten);
                _stream.Dispose();
            }
--- a/src/SharpCompress/Common/Zip/ZipFilePart.cs
+++ b/src/SharpCompress/Common/Zip/ZipFilePart.cs
@@ -93,7 +93,7 @@ namespace SharpCompress.Common.Zip
                    }
                case ZipCompressionMethod.PPMd:
                    {
-                        var props = new byte[2];
+                        Span<byte> props = stackalloc byte[2];
                        stream.ReadFully(props);
                        return new PpmdStream(new PpmdProperties(props), stream, false);
                    }
@@ -174,7 +174,7 @@ namespace SharpCompress.Common.Zip

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

                }
--- a/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs
+++ b/src/SharpCompress/Compressors/BZip2/BZip2Stream.cs
@@ -83,7 +83,7 @@ namespace SharpCompress.Compressors.BZip2
            stream.SetLength(value);
        }

-#if !NET461 && !NETSTANDARD2_0
+#if !NETFRAMEWORK && !NETSTANDARD2_0

        public override int Read(Span<byte> buffer)
        {
@@ -123,4 +123,4 @@ namespace SharpCompress.Compressors.BZip2
            return true;
        }
    }
-}
+}
--- 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
@@ -256,17 +256,15 @@ namespace SharpCompress.Compressors.Deflate
                        }

                        // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-                        byte[] trailer = new byte[8];
+                        Span<byte> trailer = stackalloc byte[8];

                        // workitem 8679
                        if (_z.AvailableBytesIn != 8)
                        {
                            // Make sure we have read to the end of the stream
-                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, _z.AvailableBytesIn);
+                            _z.InputBuffer.AsSpan(_z.NextIn, _z.AvailableBytesIn).CopyTo(trailer);
                            int bytesNeeded = 8 - _z.AvailableBytesIn;
-                            int bytesRead = _stream.Read(trailer,
-                                                         _z.AvailableBytesIn,
-                                                         bytesNeeded);
+                            int bytesRead = _stream.Read(trailer.Slice(_z.AvailableBytesIn, bytesNeeded));
                            if (bytesNeeded != bytesRead)
                            {
                                throw new ZlibException(String.Format(
@@ -276,12 +274,12 @@ namespace SharpCompress.Compressors.Deflate
                        }
                        else
                        {
-                            Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
+                            _z.InputBuffer.AsSpan(_z.NextIn, trailer.Length).CopyTo(trailer);
                        }

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

                        if (crc32_actual != crc32_expected)
@@ -504,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)
            {
-                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)
            {
@@ -529,13 +551,6 @@ namespace SharpCompress.Compressors.Deflate
                throw new ArgumentOutOfRangeException(nameof(count));
            }

-            int 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.)
--- 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/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
@@ -59,16 +59,16 @@ namespace SharpCompress.Compressors.LZMA
                    crc32Stream.Dispose();
                    var compressedCount = _countingWritableSubStream!.Count;

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

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

                    //total with headers
                    BinaryPrimitives.WriteUInt64LittleEndian(intBuf, compressedCount + 6 + 20);
-                    _countingWritableSubStream.Write(intBuf, 0, 8);
+                    _countingWritableSubStream.Write(intBuf);
                }
                _finished = true;
            }
@@ -118,7 +118,7 @@ namespace SharpCompress.Compressors.LZMA
        public override void SetLength(long value) => throw new NotImplementedException();


-#if !NET461 && !NETSTANDARD2_0
+#if !NETFRAMEWORK && !NETSTANDARD2_0

        public override int Read(Span<byte> buffer)
        {
--- a/src/SharpCompress/Compressors/LZMA/LzmaEncoder.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaEncoder.cs
@@ -1649,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;
                }
@@ -1696,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/Utilites/CrcCheckStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/Utilites/CrcCheckStream.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.IO;

@@ -21,16 +21,17 @@ namespace SharpCompress.Compressors.LZMA.Utilites

        protected override void Dispose(bool disposing)
        {
-            if (_mCurrentCrc != _mExpectedCrc)
-            {
-                throw new InvalidOperationException();
-            }
+            //Nanook - is not equal here - _mCurrentCrc is yet to be negated
+            //if (_mCurrentCrc != _mExpectedCrc)
+            //{
+            //    throw new InvalidOperationException();
+            //}
            try
            {
                if (disposing && !_mClosed)
                {
                    _mClosed = true;
-                    _mCurrentCrc = Crc.Finish(_mCurrentCrc);
+                    _mCurrentCrc = Crc.Finish(_mCurrentCrc); //now becomes equal
 #if DEBUG
                    if (_mCurrentCrc == _mExpectedCrc)
                    {
@@ -54,6 +55,10 @@ namespace SharpCompress.Compressors.LZMA.Utilites
                    }
                    Debug.WriteLine("entropy: " + (int)(entropy * 100) + "%");
 #endif
+                    if (_mCurrentCrc != _mExpectedCrc) //moved test to here
+                    {
+                        throw new InvalidOperationException();
+                    }
                }
            }
            finally
@@ -102,4 +107,4 @@ namespace SharpCompress.Compressors.LZMA.Utilites
            _mCurrentCrc = Crc.Update(_mCurrentCrc, buffer, offset, count);
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/LZMA/Utilites/Utils.cs
+++ b/src/SharpCompress/Compressors/LZMA/Utilites/Utils.cs
@@ -50,7 +50,7 @@ namespace SharpCompress.Compressors.LZMA.Utilites
                    Debugger.Break();
                }

-                throw new Exception("Assertion failed.");
+                throw new InvalidOperationException("Assertion failed.");
            }
        }

@@ -89,4 +89,4 @@ namespace SharpCompress.Compressors.LZMA.Utilites
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/H/RangeCoder.cs
+++ b/src/SharpCompress/Compressors/PPMd/H/RangeCoder.cs
@@ -83,7 +83,7 @@ namespace SharpCompress.Compressors.PPMd.H

        internal void AriDecNormalize()
        {
-            //		while ((low ^ (low + range)) < TOP || range < BOT && ((range = -low & (BOT - 1)) != 0 ? true : true)) 
+            //		while ((low ^ (low + range)) < TOP || range < BOT && ((range = -low & (BOT - 1)) != 0 ? true : true))
            //		{
            //			code = ((code << 8) | unpackRead.getChar()&0xff)&uintMask;
            //			range = (range << 8)&uintMask;
@@ -118,7 +118,7 @@ namespace SharpCompress.Compressors.PPMd.H
            buffer.Append(_range);
            buffer.Append("\n  subrange=");
            buffer.Append(SubRange);
-            buffer.Append("]");
+            buffer.Append(']');
            return buffer.ToString();
        }
    }
@@ -150,8 +150,8 @@ namespace SharpCompress.Compressors.PPMd.H
            buffer.Append(_highCount);
            buffer.Append("\n  scale=");
            buffer.Append(_scale);
-            buffer.Append("]");
+            buffer.Append(']');
            return buffer.ToString();
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/PPMd/PpmdProperties.cs
+++ b/src/SharpCompress/Compressors/PPMd/PpmdProperties.cs
@@ -31,7 +31,11 @@ namespace SharpCompress.Compressors.PPMd
        public PpmdVersion Version { get; } = PpmdVersion.I1;
        internal ModelRestorationMethod RestorationMethod { get; }

-        public PpmdProperties(byte[] properties)
+        public PpmdProperties(byte[] properties) : this(properties.AsSpan())
+        {
+        }
+
+        public PpmdProperties(ReadOnlySpan<byte> properties)
        {
            if (properties.Length == 2)
            {
@@ -43,7 +47,7 @@ namespace SharpCompress.Compressors.PPMd
            else if (properties.Length == 5)
            {
                Version = PpmdVersion.H7Z;
-                AllocatorSize = BinaryPrimitives.ReadInt32LittleEndian(properties.AsSpan(1));
+                AllocatorSize = BinaryPrimitives.ReadInt32LittleEndian(properties.Slice(1));
                ModelOrder = properties[0];
            }
        }
--- a/src/SharpCompress/Compressors/Rar/RarStream.cs
+++ b/src/SharpCompress/Compressors/Rar/RarStream.cs
@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable

 using System;
 using System.IO;
@@ -23,6 +23,7 @@ namespace SharpCompress.Compressors.Rar
        private int outCount;
        private int outTotal;
        private bool isDisposed;
+        private long _position;

        public RarStream(IRarUnpack unpack, FileHeader fileHeader, Stream readStream)
        {
@@ -32,6 +33,7 @@ namespace SharpCompress.Compressors.Rar
            fetch = true;
            unpack.DoUnpack(fileHeader, readStream, this);
            fetch = false;
+            _position = 0;
        }

        protected override void Dispose(bool disposing)
@@ -56,7 +58,8 @@ namespace SharpCompress.Compressors.Rar

        public override long Length => fileHeader.UncompressedSize;

-        public override long Position { get => fileHeader.UncompressedSize - unpack.DestSize; set => throw new NotSupportedException(); }
+        //commented out code always returned the length of the file
+        public override long Position { get => _position; /* fileHeader.UncompressedSize - unpack.DestSize;*/ set => throw new NotSupportedException(); }

        public override int Read(byte[] buffer, int offset, int count)
        {
@@ -80,6 +83,7 @@ namespace SharpCompress.Compressors.Rar
                unpack.DoUnpack();
                fetch = false;
            }
+            _position += (long)outTotal;
            return outTotal;
        }

@@ -129,4 +133,4 @@ namespace SharpCompress.Compressors.Rar
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Compressors/Xz/BinaryUtils.cs
+++ b/src/SharpCompress/Compressors/Xz/BinaryUtils.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;

 namespace SharpCompress.Compressors.Xz
@@ -8,7 +9,7 @@ namespace SharpCompress.Compressors.Xz
        public static int ReadLittleEndianInt32(this BinaryReader reader)
        {
            byte[] bytes = reader.ReadBytes(4);
-            return (bytes[0] + (bytes[1] << 8) + (bytes[2] << 16) + (bytes[3] << 24));
+            return BinaryPrimitives.ReadInt32LittleEndian(bytes);
        }

        internal static uint ReadLittleEndianUInt32(this BinaryReader reader)
@@ -17,13 +18,13 @@ namespace SharpCompress.Compressors.Xz
        }
        public static int ReadLittleEndianInt32(this Stream stream)
        {
-            byte[] bytes = new byte[4];
+            Span<byte> bytes = stackalloc byte[4];
            var read = stream.ReadFully(bytes);
            if (!read)
            {
                throw new EndOfStreamException();
            }
-            return (bytes[0] + (bytes[1] << 8) + (bytes[2] << 16) + (bytes[3] << 24));
+            return BinaryPrimitives.ReadInt32LittleEndian(bytes);
        }

        internal static uint ReadLittleEndianUInt32(this Stream stream)
--- a/src/SharpCompress/Compressors/Xz/Crc32.cs
+++ b/src/SharpCompress/Compressors/Xz/Crc32.cs
@@ -1,7 +1,6 @@
 #nullable disable

 using System;
-using System.Collections.Generic;

 namespace SharpCompress.Compressors.Xz
 {
@@ -24,7 +23,7 @@ namespace SharpCompress.Compressors.Xz

        public static UInt32 Compute(UInt32 polynomial, UInt32 seed, byte[] buffer)
        {
-            return ~CalculateHash(InitializeTable(polynomial), seed, buffer, 0, buffer.Length);
+            return ~CalculateHash(InitializeTable(polynomial), seed, buffer);
        }

        private static UInt32[] InitializeTable(UInt32 polynomial)
@@ -61,16 +60,16 @@ namespace SharpCompress.Compressors.Xz
            return createTable;
        }

-        private static UInt32 CalculateHash(UInt32[] table, UInt32 seed, IList<byte> buffer, int start, int size)
+        private static UInt32 CalculateHash(UInt32[] table, UInt32 seed, ReadOnlySpan<byte> buffer)
        {
            var crc = seed;
-            for (var i = start; i < size - start; i++)
+            int len = buffer.Length;
+            for (var i = 0; i < len; i++)
            {
-                crc = (crc >> 8) ^ table[buffer[i] ^ crc & 0xff];
+                crc = (crc >> 8) ^ table[(buffer[i] ^ crc) & 0xff];
            }

            return crc;
        }
-
    }
 }
--- a/src/SharpCompress/Compressors/Xz/Crc64.cs
+++ b/src/SharpCompress/Compressors/Xz/Crc64.cs
@@ -22,14 +22,14 @@ namespace SharpCompress.Compressors.Xz
        {
            Table ??= CreateTable(Iso3309Polynomial);

-            return CalculateHash(seed, Table, buffer, 0, buffer.Length);
+            return CalculateHash(seed, Table, buffer);
        }

-        public static UInt64 CalculateHash(UInt64 seed, UInt64[] table, IList<byte> buffer, int start, int size)
+        public static UInt64 CalculateHash(UInt64 seed, UInt64[] table, ReadOnlySpan<byte> buffer)
        {
            var crc = seed;
-
-            for (var i = start; i < size; i++)
+            int len = buffer.Length;
+            for (var i = 0; i < len; i++)
            {
                unchecked
                {
--- a/src/SharpCompress/Compressors/Xz/Filters/ArmFilter.cs
+++ b/src/SharpCompress/Compressors/Xz/Filters/ArmFilter.cs
@@ -0,0 +1,68 @@
+/*
+ * ArmFilter.cs -- XZ converter ARM executable
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * @TODO Properties offset
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.Filters;
+
+namespace SharpCompress.Compressors.Xz.Filters
+{
+    internal class ArmFilter : BlockFilter
+    {
+        public override bool AllowAsLast => false;
+
+        public override bool AllowAsNonLast => true;
+
+        public override bool ChangesDataSize => false;
+
+        private UInt32 _ip = 0;
+
+        //private UInt32 _offset = 0;
+
+        public override void Init(byte[] properties)
+        {
+            if (properties.Length != 0 && properties.Length != 4)
+            {
+                throw new InvalidDataException("ARM properties unexpected length");
+            }
+
+            if (properties.Length == 4)
+            {
+                // Even XZ doesn't support it.
+                throw new InvalidDataException("ARM properties offset is not supported");
+
+                //_offset = BitConverter.ToUInt32(properties, 0);
+                //
+                //if (_offset % (UInt32)BranchExec.Alignment.ARCH_ARM_ALIGNMENT != 0)
+                //{
+                //    throw new InvalidDataException("Filter offset does not match alignment");
+                //}
+            }
+        }
+
+        public override void ValidateFilter()
+        {
+
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int bytesRead = BaseStream.Read(buffer, offset, count);
+            BranchExecFilter.ARMConverter(buffer, _ip);
+            _ip += (UInt32)bytesRead;
+            return bytesRead;
+        }
+
+        public override void SetBaseStream(Stream stream)
+        {
+            BaseStream = stream;
+        }
+    }
+}
--- a/src/SharpCompress/Compressors/Xz/Filters/ArmThumbFilter.cs
+++ b/src/SharpCompress/Compressors/Xz/Filters/ArmThumbFilter.cs
@@ -0,0 +1,69 @@
+/*
+ * ArmFThumbFilter.cs -- XZ converter ARMThumb executable
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * @TODO Properties offset
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.Filters;
+
+namespace SharpCompress.Compressors.Xz.Filters
+{
+    internal class ArmThumbFilter : BlockFilter
+    {
+        public override bool AllowAsLast => false;
+
+        public override bool AllowAsNonLast => true;
+
+        public override bool ChangesDataSize => false;
+
+        private UInt32 _ip = 0;
+
+        //private UInt32 _offset = 0;
+
+        public override void Init(byte[] properties)
+        {
+
+            if (properties.Length != 0 && properties.Length != 4)
+            {
+                throw new InvalidDataException("ARM Thumb properties unexpected length");
+            }
+
+            if (properties.Length == 4)
+            {
+                // Even XZ doesn't support it.
+                throw new InvalidDataException("ARM Thumb properties offset is not supported");
+
+                //_offset = BitConverter.ToUInt32(properties, 0);
+                //
+                //if (_offset % (UInt32)BranchExec.Alignment.ARCH_ARMTHUMB_ALIGNMENT != 0)
+                //{
+                //    throw new InvalidDataException("Filter offset does not match alignment");
+                //}
+            }
+        }
+
+        public override void ValidateFilter()
+        {
+
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int bytesRead = BaseStream.Read(buffer, offset, count);
+            BranchExecFilter.ARMTConverter(buffer, _ip);
+            _ip += (UInt32)bytesRead;
+            return bytesRead;
+        }
+
+        public override void SetBaseStream(Stream stream)
+        {
+            BaseStream = stream;
+        }
+    }
+}
--- a/src/SharpCompress/Compressors/Xz/Filters/BlockFilter.cs
+++ b/src/SharpCompress/Compressors/Xz/Filters/BlockFilter.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;

@@ -20,6 +20,12 @@ namespace SharpCompress.Compressors.Xz.Filters

        private static readonly Dictionary<FilterTypes, Type> FilterMap = new Dictionary<FilterTypes, Type>
                                                                          {
+            {FilterTypes.ARCH_x86_FILTER, typeof(X86Filter) },
+            {FilterTypes.ARCH_PowerPC_FILTER, typeof(PowerPCFilter) },
+            {FilterTypes.ARCH_IA64_FILTER, typeof(IA64Filter) },
+            {FilterTypes.ARCH_ARM_FILTER, typeof(ArmFilter) },
+            {FilterTypes.ARCH_ARMTHUMB_FILTER, typeof(ArmThumbFilter) },
+            {FilterTypes.ARCH_SPARC_FILTER, typeof(SparcFilter) },
            {FilterTypes.LZMA2, typeof(Lzma2Filter) }
        };

--- a/src/SharpCompress/Compressors/Xz/Filters/IA64Filter.cs
+++ b/src/SharpCompress/Compressors/Xz/Filters/IA64Filter.cs
@@ -0,0 +1,67 @@
+/*
+ * IA64Filter.cs -- XZ converter IA64 executable
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * @TODO Properties offset
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.Filters;
+
+namespace SharpCompress.Compressors.Xz.Filters
+{
+    internal class IA64Filter : BlockFilter
+    {
+        public override bool AllowAsLast => false;
+
+        public override bool AllowAsNonLast => true;
+
+        public override bool ChangesDataSize => false;
+
+        private UInt32 _ip = 0;
+
+        //private UInt32 _offset = 0;
+
+        public override void Init(byte[] properties)
+        {
+            if (properties.Length != 0 && properties.Length != 4)
+            {
+                throw new InvalidDataException("IA64 properties unexpected length");
+            }
+
+            if (properties.Length == 4)
+            {
+                // Even XZ doesn't support it.
+                throw new InvalidDataException("IA64 properties offset is not supported");
+
+                //_offset = BitConverter.ToUInt32(properties, 0);
+                //
+                //if (_offset % (UInt32)BranchExec.Alignment.ARCH_IA64_ALIGNMENT != 0)
+                //{
+                //    throw new InvalidDataException("Filter offset does not match alignment");
+                //}
+            }
+        }
+
+        public override void ValidateFilter()
+        {
+
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int bytesRead = BaseStream.Read(buffer, offset, count);
+            BranchExecFilter.IA64Converter(buffer, _ip);
+            _ip += (UInt32)bytesRead;
+            return bytesRead;
+        }
+        public override void SetBaseStream(Stream stream)
+        {
+            BaseStream = stream;
+        }
+    }
+}
--- a/src/SharpCompress/Compressors/Xz/Filters/PowerPCFilter.cs
+++ b/src/SharpCompress/Compressors/Xz/Filters/PowerPCFilter.cs
@@ -0,0 +1,66 @@
+/*
+ * PowerPCFilter.cs -- XZ converter PowerPC executable
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * @TODO Properties offset
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.Filters;
+
+namespace SharpCompress.Compressors.Xz.Filters
+{
+    internal class PowerPCFilter : BlockFilter
+    {
+        public override bool AllowAsLast => false;
+
+        public override bool AllowAsNonLast => true;
+
+        public override bool ChangesDataSize => false;
+
+        private UInt32 _ip = 0;
+
+        //private UInt32 _offset = 0;
+
+        public override void Init(byte[] properties)
+        {
+
+            if (properties.Length != 0 && properties.Length != 4)
+            {
+                throw new InvalidDataException("PPC properties unexpected length");
+            }
+
+            if (properties.Length == 4)
+            {
+                // Even XZ doesn't support it.
+                throw new InvalidDataException("PPC properties offset is not supported");
+
+                //_offset = BitConverter.ToUInt32(properties, 0);
+                //
+                //if (_offset % (UInt32)BranchExec.Alignment.ARCH_PowerPC_ALIGNMENT != 0)
+                //{
+                //    throw new InvalidDataException("Filter offset does not match alignment");
+                //}
+            }
+        }
+
+        public override void ValidateFilter() { }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int bytesRead = BaseStream.Read(buffer, offset, count);
+            BranchExecFilter.PowerPCConverter(buffer, _ip);
+            _ip += (UInt32)bytesRead;
+            return bytesRead;
+        }
+
+        public override void SetBaseStream(Stream stream)
+        {
+            BaseStream = stream;
+        }
+    }
+}
--- a/src/SharpCompress/Compressors/Xz/Filters/SparcFilter.cs
+++ b/src/SharpCompress/Compressors/Xz/Filters/SparcFilter.cs
@@ -0,0 +1,65 @@
+/*
+ * SparcFilter.cs -- XZ converter SPARC executable
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * @TODO Properties offset
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.Filters;
+
+namespace SharpCompress.Compressors.Xz.Filters
+{
+    internal class SparcFilter : BlockFilter
+    {
+        public override bool AllowAsLast => false;
+
+        public override bool AllowAsNonLast => true;
+
+        public override bool ChangesDataSize => false;
+
+        private UInt32 _ip = 0;
+
+        //private UInt32 _offset = 0;
+
+        public override void Init(byte[] properties) {
+
+            if (properties.Length != 0 && properties.Length != 4)
+            {
+                throw new InvalidDataException("SPARC properties unexpected length");
+            }
+
+            if (properties.Length == 4)
+            {
+                // Even XZ doesn't support it.
+                throw new InvalidDataException("SPARC properties offset is not supported");
+
+                //_offset = BitConverter.ToUInt32(properties, 0);
+                //
+                //if (_offset % (UInt32)BranchExec.Alignment.ARCH_SPARC_ALIGNMENT != 0)
+                //{
+                //    throw new InvalidDataException("Filter offset does not match alignment");
+                //}
+            }
+        }
+
+        public override void ValidateFilter() {
+
+        }
+
+        public override int Read(byte[] buffer, int offset, int count){
+            int bytesRead = BaseStream.Read(buffer, offset, count);
+            BranchExecFilter.SPARCConverter(buffer, _ip);
+            _ip += (UInt32)bytesRead;
+            return bytesRead;
+        }
+
+        public override void SetBaseStream(Stream stream) {
+            BaseStream = stream;
+        }
+    }
+}
--- a/src/SharpCompress/Compressors/Xz/Filters/X86Filter.cs
+++ b/src/SharpCompress/Compressors/Xz/Filters/X86Filter.cs
@@ -0,0 +1,70 @@
+/*
+ * X86Filter.cs -- XZ converter x86 executable
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * @TODO Properties offset
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.Filters;
+
+namespace SharpCompress.Compressors.Xz.Filters
+{
+    internal class X86Filter : BlockFilter
+    {
+        public override bool AllowAsLast => false;
+
+        public override bool AllowAsNonLast => true;
+
+        public override bool ChangesDataSize => false;
+
+        private UInt32 _ip = 0;
+
+        private UInt32 _state = 0;
+
+        //private UInt32 _offset = 0;
+
+        public override void Init(byte[] properties)
+        {
+            if (properties.Length != 0 && properties.Length != 4)
+            {
+                throw new InvalidDataException("X86 properties unexpected length");
+            }
+
+            if (properties.Length == 4)
+            {
+                // Even XZ doesn't support it.
+                throw new InvalidDataException("X86 properties offset is not supported");
+
+                //_offset = BitConverter.ToUInt32(properties, 0);
+                //
+                //if (_offset % (UInt32)BranchExec.Alignment.ARCH_x86_ALIGNMENT != 0)
+                //{
+                //    throw new InvalidDataException("Filter offset does not match alignment");
+                //}
+            }
+        }
+
+        public override void ValidateFilter()
+        {
+
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            int bytesRead = BaseStream.Read(buffer, offset, count);
+            BranchExecFilter.X86Converter(buffer, _ip, ref _state);
+            _ip += (UInt32)bytesRead;
+            return bytesRead;
+        }
+
+        public override void SetBaseStream(Stream stream)
+        {
+            BaseStream = stream;
+        }
+    }
+}
--- a/src/SharpCompress/Compressors/Xz/MultiByteIntegers.cs
+++ b/src/SharpCompress/Compressors/Xz/MultiByteIntegers.cs
@@ -9,7 +9,7 @@ namespace SharpCompress.Compressors.Xz
        {
            if (MaxBytes <= 0)
            {
-                throw new ArgumentOutOfRangeException();
+                throw new ArgumentOutOfRangeException(nameof(MaxBytes));
            }

            if (MaxBytes > 9)
--- a/src/SharpCompress/Crypto/Crc32Stream.cs
+++ b/src/SharpCompress/Crypto/Crc32Stream.cs
@@ -42,7 +42,7 @@ namespace SharpCompress.Crypto

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

-#if !NET461 && !NETSTANDARD2_0
+#if !NETFRAMEWORK && !NETSTANDARD2_0

        public override void Write(ReadOnlySpan<byte> buffer)
        {
--- a/src/SharpCompress/IO/NonDisposingStream.cs
+++ b/src/SharpCompress/IO/NonDisposingStream.cs
@@ -58,7 +58,7 @@ namespace SharpCompress.IO
            Stream.Write(buffer, offset, count);
        }

-#if !NET461 && !NETSTANDARD2_0
+#if !NETFRAMEWORK && !NETSTANDARD2_0

        public override int Read(Span<byte> buffer)
        {
@@ -72,4 +72,4 @@ namespace SharpCompress.IO

 #endif
    }
-}
+}
--- a/src/SharpCompress/IO/RewindableStream.cs
+++ b/src/SharpCompress/IO/RewindableStream.cs
@@ -84,11 +84,11 @@ namespace SharpCompress.IO
            throw new NotSupportedException();
        }

-        public override long Length => throw new NotSupportedException();
+        public override long Length => stream.Length;

        public override long Position
        {
-            get { return stream.Position + bufferStream.Position - bufferStream.Length; }
+            get => stream.Position + bufferStream.Position - bufferStream.Length;
            set
            {
                if (!isRewound)
--- a/src/SharpCompress/IO/SourceStream.cs
+++ b/src/SharpCompress/IO/SourceStream.cs
@@ -0,0 +1,215 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Readers;
+
+namespace SharpCompress.IO
+{
+    public class SourceStream : Stream
+    {
+        private long _prevSize;
+        private List<FileInfo> _files;
+        private List<Stream> _streams;
+        private Func<int, FileInfo?> _getFilePart;
+        private Func<int, Stream?> _getStreamPart;
+        private int _stream;
+
+        public SourceStream(FileInfo file, Func<int, FileInfo?> getPart, ReaderOptions options) : this(null, null, file, getPart, options)
+        {
+        }
+
+        public SourceStream(Stream stream, Func<int, Stream?> getPart, ReaderOptions options) : this(stream, getPart, null, null, options)
+        {
+        }
+
+        private SourceStream(Stream? stream, Func<int, Stream?>? getStreamPart, FileInfo? file, Func<int, FileInfo?>? getFilePart, ReaderOptions options)
+        {
+            this.ReaderOptions = options;
+            _files = new List<FileInfo>();
+            _streams = new List<Stream>();
+            IsFileMode = file != null;
+            IsVolumes = false;
+
+            if (!IsFileMode)
+            {
+                _streams.Add(stream!);
+                _getStreamPart = getStreamPart!;
+                _getFilePart = new Func<int, FileInfo>(a => null!);
+                if (stream! is FileStream)
+                    _files.Add(new FileInfo(((FileStream)stream!).Name));
+            }
+            else
+            {
+                _files.Add(file!);
+                _streams.Add(_files[0].OpenRead());
+                _getFilePart = getFilePart!;
+                _getStreamPart = new Func<int, Stream>(a => null!);
+            }
+            _stream = 0;
+            _prevSize = 0;
+        }
+
+        public void LoadAllParts()
+        {
+            for (int i = 1; SetStream(i); i++)
+            {
+            }
+            SetStream(0);
+        }
+
+        public bool IsVolumes { get; set; }
+
+        public ReaderOptions ReaderOptions { get; }
+        public bool IsFileMode { get; }
+
+        public IEnumerable<FileInfo> Files => _files;
+        public IEnumerable<Stream> Streams => _streams;
+
+        private Stream Current => _streams[_stream];
+        public bool LoadStream(int index) //ensure all parts to id are loaded
+        {
+            while (_streams.Count <= index)
+            {
+                if (IsFileMode)
+                {
+                    FileInfo? f = _getFilePart(_streams.Count);
+                    if (f == null)
+                    {
+                        _stream = _streams.Count - 1;
+                        return false;
+                    }
+                    //throw new Exception($"File part {idx} not available.");
+                    _files.Add(f);
+                    _streams.Add(_files.Last().OpenRead());
+                }
+                else
+                {
+                    Stream? s = _getStreamPart(_streams.Count);
+                    if (s == null)
+                    {
+                        _stream = _streams.Count - 1;
+                        return false;
+                    }
+                    //throw new Exception($"Stream part {idx} not available.");
+                    _streams.Add(s);
+                    if (s is FileStream)
+                        _files.Add(new FileInfo(((FileStream)s).Name));
+                }
+            }
+            return true;
+        }
+        public bool SetStream(int idx) //allow caller to switch part in multipart
+        {
+            if (LoadStream(idx))
+                _stream = idx;
+            return _stream == idx;
+        }
+
+        public override bool CanRead => true;
+
+        public override bool CanSeek => true;
+
+        public override bool CanWrite => false;
+
+        public override long Length => (!IsVolumes ? _streams.Sum(a => a.Length) : Current.Length);
+
+        public override long Position
+        {
+            get => _prevSize + Current.Position; //_prevSize is 0 for multivolume
+            set => Seek(value, SeekOrigin.Begin);
+        }
+
+        public override void Flush()
+        {
+            Current.Flush();
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (count <= 0)
+                return 0;
+
+            int total = count;
+            int r = -1;
+
+            while (count != 0 && r != 0)
+            {
+                r = Current.Read(buffer, offset, (int)Math.Min(count, Current.Length - Current.Position));
+                count -= r;
+                offset += r;
+
+                if (!IsVolumes && count != 0 && Current.Position == Current.Length)
+                {
+                    _prevSize += Current.Length;
+                    SetStream(_stream + 1); //will load next file
+                    Current.Seek(0, SeekOrigin.Begin);
+                }
+            }
+
+            return total - count;
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            long pos = this.Position;
+            switch (origin)
+            {
+                case SeekOrigin.Begin: pos = offset; break;
+                case SeekOrigin.Current: pos += offset; break;
+                case SeekOrigin.End: pos = Length + offset; break;
+            }
+
+            _prevSize = 0;
+            if (!IsVolumes)
+            {
+                SetStream(0);
+                while (_prevSize + Current.Length < pos)
+                {
+                    _prevSize += Current.Length;
+                    SetStream(_stream + 1);
+                }
+            }
+
+            if (pos != _prevSize + Current.Position)
+                Current.Seek(pos - _prevSize, SeekOrigin.Begin);
+            return pos;
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Close()
+        {
+            if (this.IsFileMode || !this.ReaderOptions.LeaveStreamOpen) //close if file mode or options specify it
+            {
+                foreach (Stream stream in _streams)
+                {
+                    try
+                    {
+                        if (stream != null)
+                            stream.Dispose();
+                    }
+                    catch { }
+                }
+                _streams.Clear();
+                _files.Clear();
+            }
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            this.Close();
+            base.Dispose(disposing);
+        }
+    }
+}
--- a/src/SharpCompress/Polyfills/StreamExtensions.cs
+++ b/src/SharpCompress/Polyfills/StreamExtensions.cs
@@ -1,12 +1,14 @@
-#if NET461 || NETSTANDARD2_0
+#if NETFRAMEWORK || NETSTANDARD2_0

+using System;
 using System.Buffers;
+using System.IO;

-namespace System.IO
+namespace SharpCompress
 {
-    public static class StreamExtensions
+    internal static class StreamExtensions
    {
-        public static int Read(this Stream stream, Span<byte> buffer)
+        internal static int Read(this Stream stream, Span<byte> buffer)
        {
            byte[] temp = ArrayPool<byte>.Shared.Rent(buffer.Length);

@@ -24,7 +26,7 @@ namespace System.IO
            }
        }

-        public static void Write(this Stream stream, ReadOnlySpan<byte> buffer)
+        internal static void Write(this Stream stream, ReadOnlySpan<byte> buffer)
        {
            byte[] temp = ArrayPool<byte>.Shared.Rent(buffer.Length);

@@ -42,4 +44,4 @@ namespace System.IO
    }
 }

-#endif
+#endif
--- a/src/SharpCompress/Polyfills/StringExtensions.cs
+++ b/src/SharpCompress/Polyfills/StringExtensions.cs
@@ -1,15 +1,15 @@
-#if NET461 || NETSTANDARD2_0
+#if NETFRAMEWORK || NETSTANDARD2_0

-namespace System
+namespace SharpCompress
 {
-    public static class StringExtensions
+    internal static class StringExtensions
    {
-        public static bool EndsWith(this string text, char value)
+        internal static bool EndsWith(this string text, char value)
        {
            return text.Length > 0 && text[text.Length - 1] == value;
        }

-        public static bool Contains(this string text, char value)
+        internal static bool Contains(this string text, char value)
        {
            return text.IndexOf(value) > -1;
        }
--- a/src/SharpCompress/Readers/AbstractReader.cs
+++ b/src/SharpCompress/Readers/AbstractReader.cs
@@ -38,7 +38,7 @@ namespace SharpCompress.Readers
        public abstract TVolume Volume { get; }

        /// <summary>
-        /// Current file entry 
+        /// Current file entry
        /// </summary>
        public TEntry Entry => entriesForCurrentReadStream!.Current;

@@ -160,9 +160,14 @@ namespace SharpCompress.Readers
            {
                throw new ArgumentException("WriteEntryTo or OpenEntryStream can only be called once.");
            }
-            if ((writableStream is null) || (!writableStream.CanWrite))
+
+            if (writableStream is null)
            {
-                throw new ArgumentNullException("A writable Stream was required.  Use Cancel if that was intended.");
+                throw new ArgumentNullException(nameof(writableStream));
+            }
+            if (!writableStream.CanWrite)
+            {
+                throw new ArgumentException("A writable Stream was required.  Use Cancel if that was intended.");
            }

            Write(writableStream);
@@ -228,4 +233,4 @@ namespace SharpCompress.Readers
            EntryExtractionProgress?.Invoke(this, new ReaderExtractionEventArgs<IEntry>(entry, new ReaderProgress(entry, bytesTransferred, iterations)));
        }
    }
-}
+}
--- a/src/SharpCompress/Readers/ReaderOptions.cs
+++ b/src/SharpCompress/Readers/ReaderOptions.cs
@@ -10,5 +10,7 @@ namespace SharpCompress.Readers
        public bool LookForHeader { get; set; }

        public string? Password { get; set; }
+
+        public bool DisableCheckIncomplete { get; set; }
    }
 }
--- a/src/SharpCompress/SharpCompress.csproj
+++ b/src/SharpCompress/SharpCompress.csproj
@@ -2,11 +2,11 @@
  <PropertyGroup>
    <AssemblyTitle>SharpCompress - Pure C# Decompression/Compression</AssemblyTitle>
    <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.27.0</VersionPrefix>
-    <AssemblyVersion>0.27.0</AssemblyVersion>
-    <FileVersion>0.27.0</FileVersion>
+    <VersionPrefix>0.32.0</VersionPrefix>
+    <AssemblyVersion>0.32.0</AssemblyVersion>
+    <FileVersion>0.32.0</FileVersion>
    <Authors>Adam Hathcock</Authors>
-    <TargetFrameworks>netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0</TargetFrameworks>
+    <TargetFrameworks>net461;netstandard2.0;netstandard2.1;netcoreapp3.1;net6.0</TargetFrameworks>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
    <AssemblyName>SharpCompress</AssemblyName>
@@ -18,24 +18,30 @@
    <PackageLicense>https://github.com/adamhathcock/sharpcompress/blob/master/LICENSE.txt</PackageLicense>
    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
-    <Description>SharpCompress is a compression library for NET Standard 2.0/2.1//NET 4.6 that can unrar, decompress 7zip, decompress xz, zip/unzip, tar/untar lzip/unlzip, bzip2/unbzip2 and gzip/ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip is implemented.</Description>
-    <LangVersion>9</LangVersion>
+    <Description>SharpCompress is a compression library for NET Standard 2.0/2.1/NET 5.0 that can unrar, decompress 7zip, decompress xz, zip/unzip, tar/untar lzip/unlzip, bzip2/unbzip2 and gzip/ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip is implemented.</Description>
+    <LangVersion>latest</LangVersion>
    <Nullable>enable</Nullable>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <PublishRepositoryUrl>true</PublishRepositoryUrl>
    <IncludeSymbols>true</IncludeSymbols>
    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+    <IsTrimmable>true</IsTrimmable>
+    <RunAnalyzersDuringLiveAnalysis>False</RunAnalyzersDuringLiveAnalysis>
+    <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
-  </ItemGroup>  
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
+  </ItemGroup>
  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1' ">
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="5.0.0" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="6.0.0" />
  </ItemGroup>
  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="5.0.0" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="6.0.0" />
+    <PackageReference Include="System.Memory" Version="4.5.4" />
+  </ItemGroup>
+  <ItemGroup Condition=" '$(VersionlessImplicitFrameworkDefine)' == 'NETFRAMEWORK' ">
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="6.0.0" />
    <PackageReference Include="System.Memory" Version="4.5.4" />
  </ItemGroup>
-
 </Project>
--- a/src/SharpCompress/Utility.cs
+++ b/src/SharpCompress/Utility.cs
@@ -72,17 +72,17 @@ namespace SharpCompress
        {
            if (sourceIndex > Int32.MaxValue || sourceIndex < Int32.MinValue)
            {
-                throw new ArgumentOutOfRangeException();
+                throw new ArgumentOutOfRangeException(nameof(sourceIndex));
            }

            if (destinationIndex > Int32.MaxValue || destinationIndex < Int32.MinValue)
            {
-                throw new ArgumentOutOfRangeException();
+                throw new ArgumentOutOfRangeException(nameof(destinationIndex));
            }

            if (length > Int32.MaxValue || length < Int32.MinValue)
            {
-                throw new ArgumentOutOfRangeException();
+                throw new ArgumentOutOfRangeException(nameof(length));
            }

            Array.Copy(sourceArray, (int)sourceIndex, destinationArray, (int)destinationIndex, (int)length);
@@ -296,9 +296,65 @@ namespace SharpCompress
            return (total >= buffer.Length);
        }

+        public static bool ReadFully(this Stream stream, Span<byte> buffer)
+        {
+            int total = 0;
+            int read;
+            while ((read = stream.Read(buffer.Slice(total, buffer.Length - total))) > 0)
+            {
+                total += read;
+                if (total >= buffer.Length)
+                {
+                    return true;
+                }
+            }
+            return (total >= buffer.Length);
+        }
+
        public static string TrimNulls(this string source)
        {
            return source.Replace('\0', ' ').Trim();
        }
+
+        /// <summary>
+        /// Swap the endianness of a UINT32
+        /// </summary>
+        /// <param name="number">The UINT32 you want to swap his endianness</param>
+        /// <returns>Return the new UINT32 in the other endianness format</returns>
+        public static UInt32 SwapUINT32(UInt32 number)
+        {
+            return (number >> 24) |
+                 ((number << 8) & 0x00FF0000) |
+                 ((number >> 8) & 0x0000FF00) |
+                 (number << 24);
+        }
+
+        /// <summary>
+        /// Insert a little endian UINT32 into a byte array
+        /// </summary>
+        /// <param name="buffer">The buffer to insert into</param>
+        /// <param name="number">The UINT32 to insert</param>
+        /// <param name="offset">Offset of the buffer to insert into</param>
+        public static void SetLittleUInt32(ref byte[] buffer, UInt32 number, long offset)
+        {
+            buffer[offset] = (byte)(number);
+            buffer[offset + 1] = (byte)(number >> 8);
+            buffer[offset + 2] = (byte)(number >> 16);
+            buffer[offset + 3] = (byte)(number >> 24);
+        }
+
+        /// <summary>
+        /// Insert a big endian UINT32 into a byte array
+        /// </summary>
+        /// <param name="buffer">The buffer to insert into</param>
+        /// <param name="number">The UINT32 to insert</param>
+        /// <param name="offset">Offset of the buffer to insert into</param>
+        public static void SetBigUInt32(ref byte[] buffer, UInt32 number, long offset)
+        {
+            buffer[offset] = (byte)(number >> 24);
+            buffer[offset + 1] = (byte)(number >> 16);
+            buffer[offset + 2] = (byte)(number >> 8);
+            buffer[offset + 3] = (byte)number;
+        }
    }
 }
--- a/src/SharpCompress/Writers/Tar/TarWriter.cs
+++ b/src/SharpCompress/Writers/Tar/TarWriter.cs
@@ -87,19 +87,16 @@ namespace SharpCompress.Writers.Tar
            header.Name = NormalizeFilename(filename);
            header.Size = realSize;
            header.Write(OutputStream);
+
            size = source.TransferTo(OutputStream);
-            PadTo512(size.Value, false);
+            PadTo512(size.Value);
        }

-        private void PadTo512(long size, bool forceZeros)
+        private void PadTo512(long size)
        {
-            int zeros = (int)size % 512;
-            if (zeros == 0 && !forceZeros)
-            {
-                return;
-            }
-            zeros = 512 - zeros;
-            OutputStream.Write(new byte[zeros], 0, zeros);
+            int zeros = unchecked((int)(((size + 511L) & ~511L) - size));
+
+            OutputStream.Write(stackalloc byte[zeros]);
        }

        protected override void Dispose(bool isDisposing)
@@ -108,8 +105,7 @@ namespace SharpCompress.Writers.Tar
            {
                if (finalizeArchiveOnClose)
                {
-                    PadTo512(0, true);
-                    PadTo512(0, true);
+                    OutputStream.Write(stackalloc byte[1024]);
                }
                switch (OutputStream)
                {
@@ -128,4 +124,4 @@ namespace SharpCompress.Writers.Tar
            base.Dispose(isDisposing);
        }
    }
-}
+}
--- a/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs
+++ b/src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs
@@ -71,60 +71,60 @@ namespace SharpCompress.Writers.Zip
                usedCompression = ZipCompressionMethod.None;
            }

-            byte[] intBuf = new byte[] { 80, 75, 1, 2, version, 0, version, 0 };
+            Span<byte> intBuf = stackalloc byte[] { 80, 75, 1, 2, version, 0, version, 0 };
            //constant sig, then version made by, then version to extract
-            outputStream.Write(intBuf, 0, 8);
+            outputStream.Write(intBuf);

            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            outputStream.Write(intBuf, 0, 2);
+            outputStream.Write(intBuf.Slice(0, 2));
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)usedCompression);
-            outputStream.Write(intBuf, 0, 2); // zipping method
+            outputStream.Write(intBuf.Slice(0, 2)); // zipping method
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ModificationTime.DateTimeToDosTime());
-            outputStream.Write(intBuf, 0, 4);
+            outputStream.Write(intBuf.Slice(0, 4));

            // zipping date and time
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, Crc);
-            outputStream.Write(intBuf, 0, 4); // file CRC
+            outputStream.Write(intBuf.Slice(0, 4)); // file CRC
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, compressedvalue);
-            outputStream.Write(intBuf, 0, 4); // compressed file size
+            outputStream.Write(intBuf.Slice(0, 4)); // compressed file size
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, decompressedvalue);
-            outputStream.Write(intBuf, 0, 4); // uncompressed file size
+            outputStream.Write(intBuf.Slice(0, 4)); // uncompressed file size
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedFilename.Length);
-            outputStream.Write(intBuf, 0, 2); // Filename in zip
+            outputStream.Write(intBuf.Slice(0, 2)); // Filename in zip
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)extralength);
-            outputStream.Write(intBuf, 0, 2); // extra length
+            outputStream.Write(intBuf.Slice(0, 2)); // extra length
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedComment.Length);
-            outputStream.Write(intBuf, 0, 2);
+            outputStream.Write(intBuf.Slice(0, 2));

            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0);
-            outputStream.Write(intBuf, 0, 2); // disk=0
+            outputStream.Write(intBuf.Slice(0, 2)); // disk=0
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            outputStream.Write(intBuf, 0, 2); // file type: binary
+            outputStream.Write(intBuf.Slice(0, 2)); // file type: binary
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            outputStream.Write(intBuf, 0, 2); // Internal file attributes
+            outputStream.Write(intBuf.Slice(0, 2)); // Internal file attributes
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x8100);
-            outputStream.Write(intBuf, 0, 2);
+            outputStream.Write(intBuf.Slice(0, 2));

            // External file attributes (normal/readable)
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, headeroffsetvalue);
-            outputStream.Write(intBuf, 0, 4); // Offset of header
+            outputStream.Write(intBuf.Slice(0, 4)); // Offset of header

            outputStream.Write(encodedFilename, 0, encodedFilename.Length);
            if (zip64)
            {
                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x0001);
-                outputStream.Write(intBuf, 0, 2);
+                outputStream.Write(intBuf.Slice(0, 2));
                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)(extralength - 4));
-                outputStream.Write(intBuf, 0, 2);
+                outputStream.Write(intBuf.Slice(0, 2));

                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, Decompressed);
-                outputStream.Write(intBuf, 0, 8);
+                outputStream.Write(intBuf);
                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, Compressed);
-                outputStream.Write(intBuf, 0, 8);
+                outputStream.Write(intBuf);
                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, HeaderOffset);
-                outputStream.Write(intBuf, 0, 8);
+                outputStream.Write(intBuf);
                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                outputStream.Write(intBuf, 0, 4); // VolumeNumber = 0
+                outputStream.Write(intBuf.Slice(0, 4)); // VolumeNumber = 0
            }

            outputStream.Write(encodedComment, 0, encodedComment.Length);
--- a/src/SharpCompress/Writers/Zip/ZipWriter.cs
+++ b/src/SharpCompress/Writers/Zip/ZipWriter.cs
@@ -162,10 +162,9 @@ namespace SharpCompress.Writers.Zip
            var explicitZipCompressionInfo = ToZipCompressionMethod(zipWriterEntryOptions.CompressionType ?? compressionType);
            byte[] encodedFilename = WriterOptions.ArchiveEncoding.Encode(filename);

-            // TODO: Use stackalloc when we exclusively support netstandard2.1 or higher
-            byte[] intBuf = new byte[4];
+            Span<byte> intBuf = stackalloc byte[4];
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ZipHeaderFactory.ENTRY_HEADER_BYTES);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(intBuf);
            if (explicitZipCompressionInfo == ZipCompressionMethod.Deflate)
            {
                if (OutputStream.CanSeek && useZip64)
@@ -193,18 +192,18 @@ namespace SharpCompress.Writers.Zip
            }

            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            OutputStream.Write(intBuf, 0, 2);
+            OutputStream.Write(intBuf.Slice(0, 2));
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)explicitZipCompressionInfo);
-            OutputStream.Write(intBuf, 0, 2); // zipping method
+            OutputStream.Write(intBuf.Slice(0, 2)); // zipping method
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime());
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(intBuf);

            // zipping date and time
            OutputStream.Write(stackalloc byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });

            // unused CRC, un/compressed size, updated later
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedFilename.Length);
-            OutputStream.Write(intBuf, 0, 2); // filename length
+            OutputStream.Write(intBuf.Slice(0, 2)); // filename length

            var extralength = 0;
            if (OutputStream.CanSeek && useZip64)
@@ -213,7 +212,7 @@ namespace SharpCompress.Writers.Zip
            }

            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)extralength);
-            OutputStream.Write(intBuf, 0, 2); // extra length
+            OutputStream.Write(intBuf.Slice(0, 2)); // extra length
            OutputStream.Write(encodedFilename, 0, encodedFilename.Length);

            if (extralength != 0)
@@ -227,25 +226,25 @@ namespace SharpCompress.Writers.Zip

        private void WriteFooter(uint crc, uint compressed, uint uncompressed)
        {
-            byte[] intBuf = new byte[4];
+            Span<byte> intBuf = stackalloc byte[4];
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, crc);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(intBuf);
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, compressed);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(intBuf);
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, uncompressed);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(intBuf);
        }

        private void WriteEndRecord(ulong size)
        {

-            var zip64 = isZip64 || entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
+            var zip64EndOfCentralDirectoryNeeded = entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;

            var sizevalue = size >= uint.MaxValue ? uint.MaxValue : (uint)size;
            var streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streamPosition;

-            byte[] intBuf = new byte[8];
-            if (zip64)
+            Span<byte> intBuf = stackalloc byte[8];
+            if (zip64EndOfCentralDirectoryNeeded)
            {
                var recordlen = 2 + 2 + 4 + 4 + 8 + 8 + 8 + 8;

@@ -253,51 +252,50 @@ namespace SharpCompress.Writers.Zip
                OutputStream.Write(stackalloc byte[] { 80, 75, 6, 6 });

                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)recordlen);
-                OutputStream.Write(intBuf, 0, 8); // Size of zip64 end of central directory record
-                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 2); // Made by
+                OutputStream.Write(intBuf); // Size of zip64 end of central directory record
                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 45);
-                OutputStream.Write(intBuf, 0, 2); // Version needed
+                OutputStream.Write(intBuf.Slice(0, 2)); // Made by
+                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 45);
+                OutputStream.Write(intBuf.Slice(0, 2)); // Version needed

                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 4); // Disk number
-                OutputStream.Write(intBuf, 0, 4); // Central dir disk
+                OutputStream.Write(intBuf.Slice(0, 4)); // Disk number
+                OutputStream.Write(intBuf.Slice(0, 4)); // Central dir disk

                // TODO: entries.Count is int, so max 2^31 files
                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)entries.Count);
-                OutputStream.Write(intBuf, 0, 8); // Entries in this disk
-                OutputStream.Write(intBuf, 0, 8); // Total entries
+                OutputStream.Write(intBuf); // Entries in this disk
+                OutputStream.Write(intBuf); // Total entries
                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, size);
-                OutputStream.Write(intBuf, 0, 8); // Central Directory size
+                OutputStream.Write(intBuf); // Central Directory size
                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)streamPosition);
-                OutputStream.Write(intBuf, 0, 8); // Disk offset
+                OutputStream.Write(intBuf); // Disk offset

                // Write zip64 end of central directory locator
                OutputStream.Write(stackalloc byte[] { 80, 75, 6, 7 });

                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 4); // Entry disk
+                OutputStream.Write(intBuf.Slice(0, 4)); // Entry disk
                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)streamPosition + size);
-                OutputStream.Write(intBuf, 0, 8); // Offset to the zip64 central directory
-                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 4); // Number of disks
+                OutputStream.Write(intBuf); // Offset to the zip64 central directory
+                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 1);
+                OutputStream.Write(intBuf.Slice(0, 4)); // Number of disks

-                streamPosition += recordlen + (4 + 4 + 8 + 4);
-                streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streampositionvalue;
+                streamPosition += 4 + 8 + recordlen + (4 + 4 + 8 + 4);
            }

            // Write normal end of central directory record
            OutputStream.Write(stackalloc byte[] { 80, 75, 5, 6, 0, 0, 0, 0 });
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)entries.Count);
-            OutputStream.Write(intBuf, 0, 2);
-            OutputStream.Write(intBuf, 0, 2);
+            OutputStream.Write(intBuf.Slice(0, 2));
+            OutputStream.Write(intBuf.Slice(0, 2));
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, sizevalue);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(intBuf.Slice(0, 4));
            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, streampositionvalue);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(intBuf.Slice(0, 4));
            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(zipComment);
            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedComment.Length);
-            OutputStream.Write(intBuf, 0, 2);
+            OutputStream.Write(intBuf.Slice(0, 2));
            OutputStream.Write(encodedComment, 0, encodedComment.Length);
        }

@@ -443,16 +441,16 @@ namespace SharpCompress.Writers.Zip
                        if (entry.Zip64HeaderOffset != 0)
                        {
                            originalStream.Position = (long)(entry.HeaderOffset + entry.Zip64HeaderOffset);
-                            byte[] intBuf = new byte[8];
+                            Span<byte> intBuf = stackalloc byte[8];
                            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x0001);
-                            originalStream.Write(intBuf, 0, 2);
+                            originalStream.Write(intBuf.Slice(0, 2));
                            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 8 + 8);
-                            originalStream.Write(intBuf, 0, 2);
+                            originalStream.Write(intBuf.Slice(0, 2));

                            BinaryPrimitives.WriteUInt64LittleEndian(intBuf, entry.Decompressed);
-                            originalStream.Write(intBuf, 0, 8);
+                            originalStream.Write(intBuf);
                            BinaryPrimitives.WriteUInt64LittleEndian(intBuf, entry.Compressed);
-                            originalStream.Write(intBuf, 0, 8);
+                            originalStream.Write(intBuf);
                        }

                        originalStream.Position = writer.streamPosition + (long)entry.Compressed;
@@ -471,9 +469,9 @@ namespace SharpCompress.Writers.Zip
                            throw new NotSupportedException("Streams larger than 4GiB are not supported for non-seekable streams");
                        }

-                        byte[] intBuf = new byte[4];
+                        Span<byte> intBuf = stackalloc byte[4];
                        BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ZipHeaderFactory.POST_DATA_DESCRIPTOR);
-                        originalStream.Write(intBuf, 0, 4);
+                        originalStream.Write(intBuf);
                        writer.WriteFooter(entry.Crc,
                                           compressedvalue,
                                           decompressedvalue);
--- a/tests/SharpCompress.Test/ArchiveTests.cs
+++ b/tests/SharpCompress.Test/ArchiveTests.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -12,6 +12,15 @@ namespace SharpCompress.Test
 {
    public class ArchiveTests : ReaderTests
    {
+        protected void ArchiveGetParts(IEnumerable<string> testArchives)
+        {
+            string[] arcs = testArchives.Select(a => Path.Combine(TEST_ARCHIVES_PATH, a)).ToArray();
+            string[] found = ArchiveFactory.GetFileParts(arcs[0]).ToArray();
+            Assert.Equal(arcs.Length, found.Length);
+            for (int i = 0; i < arcs.Length; i++)
+                Assert.Equal(arcs[i], found[i]);
+        }
+
        protected void ArchiveStreamReadExtractAll(string testArchive, CompressionType compression)
        {
            testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
@@ -95,6 +104,65 @@ namespace SharpCompress.Test
            }
        }

+        protected void ArchiveStreamMultiRead(ReaderOptions readerOptions = null, params string[] testArchives)
+        {
+            ArchiveStreamMultiRead(readerOptions, testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)));
+        }
+
+        protected void ArchiveStreamMultiRead(ReaderOptions readerOptions, IEnumerable<string> testArchives)
+        {
+                using (var archive = ArchiveFactory.Open(testArchives.Select(a => new FileInfo(a)), readerOptions))
+                {
+                    try
+                    {
+                        foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+                        {
+                            entry.WriteToDirectory(SCRATCH_FILES_PATH,
+                                                    new ExtractionOptions()
+                                                    {
+                                                        ExtractFullPath = true,
+                                                        Overwrite = true
+                                                    });
+                        }
+                    }
+                    catch (IndexOutOfRangeException)
+                    {
+                        throw;
+                    }
+                }
+                VerifyFiles();
+        }
+
+        protected void ArchiveOpenStreamRead(ReaderOptions readerOptions = null, params string[] testArchives)
+        {
+            ArchiveOpenStreamRead(readerOptions, testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)));
+        }
+
+        protected void ArchiveOpenStreamRead(ReaderOptions readerOptions, IEnumerable<string> testArchives)
+        {
+            using (var archive = ArchiveFactory.Open(testArchives.Select(f => new FileInfo(f)), null))
+            {
+                try
+                {
+                    foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+                    {
+                        entry.WriteToDirectory(SCRATCH_FILES_PATH,
+                                               new ExtractionOptions()
+                                               {
+                                                   ExtractFullPath = true,
+                                                   Overwrite = true
+                                               });
+                    }
+                }
+                catch (IndexOutOfRangeException)
+                {
+                    throw;
+                }
+            }
+            VerifyFiles();
+        }
+
+
        protected void ArchiveFileRead(string testArchive, ReaderOptions readerOptions = null)
        {
            testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
--- a/tests/SharpCompress.Test/Filters/BranchExecTests.cs
+++ b/tests/SharpCompress.Test/Filters/BranchExecTests.cs
@@ -0,0 +1,157 @@
+/*
+ * BranchExecTests.cs -- Test for converters
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ * 
+ * All data is extracted from busybox, where "ip" is the offset within the busybox file.
+ */
+
+using SharpCompress.Compressors.Filters;
+using Xunit;
+
+namespace SharpCompress.Test.Filters
+{
+    public class BranchExecTests
+    {
+        private static byte[] x86resultData { get; } = new byte[] {
+            0x12, 0x00, 0x00, 0x00, 0x02, 0x0B, 0x00, 0x00, 0xE8, 0xBD, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6D, 0x01, 0x00, 0x00, 0xF0, 0xCA,
+            0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xBC, 0x09, 0x00, 0x00, 0x14, 0xC2, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+            0x98, 0x0B, 0x00, 0x00, 0x60, 0x75, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0xF1, 0xFF, 0x42, 0x01, 0x00, 0x00, 0x08, 0xC8, 0x00, 0x00, 0x1C, 0x00,
+        };
+
+        private static byte[] x86Data { get; } = new byte[] {
+            0x12, 0x00, 0x00, 0x00, 0x02, 0x0B, 0x00, 0x00, 0xE8, 0xCA, 0x20, 0x00, 0x00, 0x07, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x6D, 0x01, 0x00, 0x00, 0xF0, 0xCA,
+            0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0xBC, 0x09, 0x00, 0x00, 0x14, 0xC2, 0x00, 0x00, 0xE0, 0x01, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+            0x98, 0x0B, 0x00, 0x00, 0x60, 0x75, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0xF1, 0xFF, 0x42, 0x01, 0x00, 0x00, 0x08, 0xC8, 0x00, 0x00, 0x1C, 0x00,
+        };
+
+        private static byte[] ppcResultData { get; } = new byte[] {
+            0xF8, 0x6B, 0x2E, 0x8C, 0x95, 0xC5, 0x4B, 0x1B, 0x94, 0x78, 0x9E, 0x7C, 0xBD, 0x8B, 0xA8, 0xAF, 0x31, 0x20, 0xFE, 0x0F, 0xB3, 0x15, 0x9A, 0x7C, 0xD5, 0x5C,
+            0xC2, 0xC0, 0xEC, 0xE9, 0x43, 0x2B, 0xD0, 0x9F, 0x2C, 0xFC, 0xB8, 0x2B, 0x6B, 0x15, 0xCD, 0x3F, 0x0C, 0xAF, 0x8F, 0x68, 0xB0, 0x6E, 0x6B, 0x30, 0x2E, 0x8C,
+            0x3F, 0x7E, 0x96, 0x7C, 0x93, 0xB2, 0xA4, 0x0E, 0x43, 0xEA, 0x20, 0x10, 0x38, 0x6D, 0x37, 0xF8, 0x87, 0xFE, 0xA9, 0x63, 0x75, 0xF5, 0x56, 0x34, 0x4A, 0xE3,
+            0xCF, 0x89, 0x18, 0x08, 0xC2, 0x76, 0x74, 0x12, 0xEC, 0xA7, 0x6D, 0xC2, 0xB7, 0x1B, 0x7A, 0xB2, 0xD4, 0xED
+        };
+
+        private static byte[] ppcData { get; } = new byte[] {
+            0xF8, 0x6B, 0x2E, 0x8C, 0x95, 0xC5, 0x4B, 0x1B, 0x94, 0x78, 0x9E, 0x7C, 0xBD, 0x8B, 0xA8, 0xAF, 0x31, 0x20, 0xFE, 0x0F, 0xB3, 0x15, 0x9A, 0x7C, 0xD5, 0x5C,
+            0xC2, 0xC0, 0xEC, 0xE9, 0x43, 0x2B, 0xD0, 0x9F, 0x2C, 0xFC, 0xB8, 0x2B, 0x6B, 0x15, 0xCD, 0x3F, 0x0C, 0xAF, 0x8F, 0x68, 0xB0, 0x6E, 0x6B, 0x30, 0x2E, 0x8C,
+            0x3F, 0x7E, 0x96, 0x7C, 0x93, 0xB2, 0xA4, 0x0E, 0x43, 0xEA, 0x20, 0x10, 0x38, 0x6D, 0x37, 0xF8, 0x87, 0xFE, 0xA9, 0x63, 0x75, 0xF5, 0x56, 0x34, 0x4A, 0xE3,
+            0xD6, 0x75, 0x18, 0x08, 0xC2, 0x76, 0x74, 0x12, 0xEC, 0xA7, 0x6D, 0xC2, 0xB7, 0x1B, 0x7A, 0xB2, 0xD4, 0xED
+        };
+
+        private static byte[] armResultData { get; } = new byte[] {
+            0x7C, 0xFC, 0x0A, 0x00, 0x16, 0x42, 0x01, 0x00, 0x80, 0xFC, 0x0A, 0x00, 0x16, 0xB8, 0x00, 0x00, 0x84, 0xFC, 0x0A, 0x00, 0x16, 0x3A, 0x00, 0x00, 0x04, 0xE0,
+            0x2D, 0xE5, 0x04, 0xD0, 0x4D, 0xE2, 0x0E, 0x04, 0x00, 0xEB, 0x04, 0xD0, 0x8D, 0xE2, 0x04, 0xE0, 0x9D, 0xE4, 0x1E, 0xFF, 0x2F, 0xE1, 0x04, 0xE0, 0x2D, 0xE5,
+            0x04, 0xE0, 0x9F, 0xE5, 0x0E, 0xE0, 0x8F, 0xE0, 0x08, 0xF0, 0xBE, 0xE5, 0xF0, 0x3A, 0x0A, 0x00, 0x00, 0xC6, 0x8F, 0xE2, 0xA3, 0xCA, 0x8C, 0xE2, 0xF0, 0xFA,
+            0xBC, 0xE5, 0x00, 0xC6, 0x8F, 0xE2, 0xA3, 0xCA, 0x8C, 0xE2, 0xE8, 0xFA, 0xBC, 0xE5, 0x00, 0xC6, 0x8F, 0xE2
+        };
+
+        private static byte[] armData { get; } = new byte[] {
+            0x7C, 0xFC, 0x0A, 0x00, 0x16, 0x42, 0x01, 0x00, 0x80, 0xFC, 0x0A, 0x00, 0x16, 0xB8, 0x00, 0x00, 0x84, 0xFC, 0x0A, 0x00, 0x16, 0x3A, 0x00, 0x00, 0x04, 0xE0,
+            0x2D, 0xE5, 0x04, 0xD0, 0x4D, 0xE2, 0x18, 0x13, 0x00, 0xEB, 0x04, 0xD0, 0x8D, 0xE2, 0x04, 0xE0, 0x9D, 0xE4, 0x1E, 0xFF, 0x2F, 0xE1, 0x04, 0xE0, 0x2D, 0xE5,
+            0x04, 0xE0, 0x9F, 0xE5, 0x0E, 0xE0, 0x8F, 0xE0, 0x08, 0xF0, 0xBE, 0xE5, 0xF0, 0x3A, 0x0A, 0x00, 0x00, 0xC6, 0x8F, 0xE2, 0xA3, 0xCA, 0x8C, 0xE2, 0xF0, 0xFA,
+            0xBC, 0xE5, 0x00, 0xC6, 0x8F, 0xE2, 0xA3, 0xCA, 0x8C, 0xE2, 0xE8, 0xFA, 0xBC, 0xE5, 0x00, 0xC6, 0x8F, 0xE2
+        };
+
+        private static byte[] armtResultData { get; } = new byte[] {
+            0x95, 0x23, 0xB6, 0xB1, 0xBE, 0x60, 0x79, 0xF0, 0xF6, 0x01, 0xD9, 0x7F, 0x2E, 0x03, 0x31, 0x1C, 0xFD, 0xD3, 0x40, 0x0F, 0x21, 0x3C, 0x06, 0x97, 0xE5, 0xC3,
+            0x57, 0x11, 0x76, 0x6F, 0xE3, 0x70, 0xED, 0x49, 0xCB, 0xB5, 0xC9, 0x42, 0x59, 0x10, 0x2F, 0xBD, 0xAE, 0xB1, 0x40, 0x4D, 0x9D, 0x7C, 0xE9, 0xFC, 0x48, 0x3E,
+            0xBC, 0x7F, 0x0B, 0x23, 0xB0, 0x8A, 0x4D, 0x02, 0x39, 0xC4, 0xFB, 0x66, 0x83, 0x7F, 0xA7, 0xBD, 0x12, 0xAC, 0xED, 0x31, 0x34, 0x93, 0x4D, 0x8D, 0xD7, 0x94,
+            0x93, 0x1C, 0x0A, 0x50, 0x54, 0x4B, 0x03, 0x55, 0x27, 0xFE, 0xCE, 0x29, 0x66, 0x52, 0x81, 0xAE, 0x69, 0xA0, 0x69, 0xF2, 0x3D, 0xFF, 0xA1, 0x8A, 0x5D, 0x61,
+            0x7D, 0xC5, 0x94, 0x0A, 0x7D, 0xED, 0x11, 0x0F
+        };
+
+        private static byte[] armtData { get; } = new byte[] {
+            0x95, 0x23, 0xB6, 0xB1, 0xBE, 0x60, 0x79, 0xF0, 0xF6, 0x01, 0xD9, 0x7F, 0x2E, 0x03, 0x31, 0x1C, 0xFD, 0xD3, 0x40, 0x0F, 0x21, 0x3C, 0x06, 0x97, 0xE5, 0xC3,
+            0x57, 0x11, 0x76, 0x6F, 0xE3, 0x70, 0xED, 0x49, 0xCB, 0xB5, 0xC9, 0x42, 0x59, 0x10, 0x2F, 0xBD, 0xAE, 0xB1, 0x40, 0x4D, 0x9D, 0x7C, 0xE9, 0xFC, 0x48, 0x3E,
+            0xBC, 0x7F, 0x0B, 0x23, 0xB0, 0x8A, 0x4D, 0x02, 0x39, 0xC4, 0xFB, 0x66, 0x83, 0x7F, 0xA7, 0xBD, 0x12, 0xAC, 0xED, 0x31, 0x34, 0x93, 0x4D, 0x8D, 0xD7, 0x94,
+            0x93, 0x1C, 0x0A, 0x50, 0x54, 0x4B, 0x03, 0x55, 0x27, 0xFE, 0xCE, 0x29, 0x66, 0x52, 0x81, 0xAE, 0x69, 0xA0, 0x6A, 0xF2, 0x6F, 0xFC, 0xA1, 0x8A, 0x5D, 0x61,
+            0x7D, 0xC5, 0x94, 0x0A, 0x7D, 0xED, 0x11, 0x0F
+        };
+
+        private static byte[] ia64ResultData { get; } = new byte[] {
+            0x4D, 0xF8, 0xF2, 0x0D, 0x06, 0x2F, 0x74, 0x0F, 0xF0, 0x91, 0x06, 0x0B, 0x19, 0x22, 0x91, 0x5A, 0x66, 0x56, 0xA7, 0x15, 0x77, 0x1E, 0x2F, 0xA3, 0xE4, 0xDE,
+            0x93, 0x1C, 0xD5, 0xCE, 0x6E, 0x45, 0x36, 0x15, 0x15, 0x65, 0x4E, 0xC5, 0xA3, 0x8C, 0x5A, 0x8B, 0x8A, 0x1C, 0x12, 0x5B, 0x39, 0x1F, 0xA0, 0xF2, 0x93, 0x7C,
+            0x7F, 0x5D, 0xD9, 0x30, 0x1F, 0xF6, 0x5C, 0x10, 0x62, 0x3E, 0xB4, 0x64, 0x56, 0x48, 0xB2, 0x20, 0x39, 0xE8, 0x44, 0x10, 0x87, 0x9E, 0x2C, 0xFC, 0x29, 0x0E,
+            0x20, 0x76, 0xCE, 0xDA, 0x93, 0x1C, 0xED, 0x54, 0x0D, 0xAF, 0xEC, 0xDE, 0x93, 0x1C, 0x2B, 0x72, 0xD5, 0x0D
+        };
+
+        private static byte[] ia64Data { get; } = new byte[] {
+            0x4D, 0xF8, 0xF2, 0x0D, 0x06, 0x2F, 0x74, 0x0F, 0xF0, 0x91, 0x06, 0x0B, 0x19, 0x22, 0x91, 0x5A, 0x66, 0x56, 0xA7, 0x15, 0x77, 0x1E, 0x2F, 0xA3, 0xE4, 0xDE,
+            0x93, 0x1C, 0xD5, 0xCE, 0x6E, 0x45, 0x36, 0x15, 0x15, 0x65, 0x4E, 0xC5, 0xA3, 0x8C, 0x5A, 0x8B, 0x8A, 0x1C, 0x12, 0x5B, 0x39, 0x1F, 0xA0, 0xF2, 0x93, 0x7C,
+            0x7F, 0x5D, 0xD9, 0x30, 0x1F, 0xF6, 0x5C, 0x10, 0x62, 0x3E, 0xB4, 0x64, 0x56, 0x48, 0xB2, 0x20, 0x39, 0xE8, 0x44, 0x80, 0x8C, 0x9E, 0x2C, 0xFC, 0x29, 0x0E,
+            0x20, 0x76, 0xCE, 0xDA, 0x93, 0x1C, 0xED, 0x54, 0x0D, 0xAF, 0xEC, 0xDE, 0x93, 0x1C, 0x2B, 0x72, 0xD5, 0x0D
+        };
+
+        private static byte[] sparcResultData { get; } = new byte[] {
+            0x78, 0x2E, 0x73, 0x6F, 0x2E, 0x33, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xA2, 0x0D,
+            0x10, 0x12, 0x30, 0x03, 0xC9, 0x37, 0x40, 0x1A, 0x85, 0xD9, 0x44, 0x34, 0x40, 0x32, 0x85, 0xA0, 0x30, 0x40, 0x00, 0x70, 0x00, 0x40, 0x84, 0x80, 0x04, 0x00,
+            0xE4, 0xAC, 0x07, 0x04, 0x21, 0x44, 0x02, 0x20, 0x10, 0x00, 0x40, 0xC2, 0x89, 0x98, 0x85, 0x00, 0x58, 0x6A, 0x41, 0x8E, 0x18, 0xA1, 0x91, 0x00, 0x10, 0x00,
+        };
+
+        private static byte[] sparcData { get; } = new byte[] {
+            0x78, 0x2E, 0x73, 0x6F, 0x2E, 0x33, 0x00, 0x00, 0x07, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x44, 0x0B, 0x00, 0x00, 0x00, 0xA2, 0x0D,
+            0x10, 0x12, 0x30, 0x03, 0xC9, 0x37, 0x40, 0x1A, 0x86, 0x21, 0x44, 0x34, 0x40, 0x32, 0x85, 0xA0, 0x30, 0x40, 0x00, 0x70, 0x00, 0x40, 0x84, 0x80, 0x04, 0x00,
+            0xE4, 0xAC, 0x07, 0x04, 0x21, 0x44, 0x02, 0x20, 0x10, 0x00, 0x40, 0xC2, 0x89, 0x98, 0x85, 0x00, 0x58, 0x6A, 0x41, 0x8E, 0x18, 0xA1, 0x91, 0x00, 0x10, 0x00,
+        };
+
+        private void CompareBuffer(byte[] testBuffer, byte[] targetBuffer)
+        {
+            Assert.Equal(testBuffer, targetBuffer);
+        }
+
+        [Fact]
+        public void X86ConverterDecodeTest()
+        {
+            uint state = 0;
+            uint ip = 0x2000;
+            var testData = x86Data;
+            BranchExecFilter.X86Converter(testData, ip, ref state);
+            CompareBuffer(testData, x86resultData);
+        }
+
+        [Fact]
+        public void PowerPCConverterDecodeTest()
+        {
+            uint ip = 0x6A0;
+            var testData = ppcData;
+            BranchExecFilter.PowerPCConverter(testData, ip);
+            CompareBuffer(testData, ppcResultData);
+        }
+
+        [Fact]
+        public void ARMConverteDecoderTest()
+        {
+            uint ip = 0x3C00;
+            var testData = armData;
+            BranchExecFilter.ARMConverter(testData, ip);
+            CompareBuffer(testData, armResultData);
+        }
+
+        [Fact]
+        public void ARMTConverterDecodeTest()
+        {
+            uint ip = 0xA00;
+            var testData = armtData;
+            BranchExecFilter.ARMTConverter(testData, ip);
+            CompareBuffer(testData, armtResultData);
+        }
+
+        [Fact]
+        public void IA64ConverterDecodeTest()
+        {
+            uint ip = 0xAA0;
+            var testData = ia64Data;
+            BranchExecFilter.IA64Converter(testData, ip);
+            CompareBuffer(testData, ia64ResultData);
+        }
+
+        [Fact]
+        public void SPARCConverterDecodeTest()
+        {
+            uint ip = 0x100;
+            var testData = sparcData;
+            BranchExecFilter.SPARCConverter(testData, ip);
+            CompareBuffer(testData, sparcResultData);
+        }
+    }
+}
--- a/tests/SharpCompress.Test/GZip/GZipReaderTests.cs
+++ b/tests/SharpCompress.Test/GZip/GZipReaderTests.cs
@@ -0,0 +1,37 @@
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.IO;
+using Xunit;
+
+namespace SharpCompress.Test.GZip
+{
+    public class GZipReaderTests : ReaderTests
+    {
+        public GZipReaderTests()
+        {
+            UseExtensionInsteadOfNameToVerify = true;
+        }
+
+        [Fact]
+        public void GZip_Reader_Generic()
+        {
+            Read("Tar.tar.gz", CompressionType.GZip);
+        }
+
+
+        [Fact]
+        public void GZip_Reader_Generic2()
+        {
+            //read only as GZip itme
+            using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")))
+            using (var reader = SharpCompress.Readers.GZip.GZipReader.Open(new RewindableStream(stream)))
+            {
+                while (reader.MoveToNextEntry()) // Crash here
+                {
+                    Assert.NotEqual(0, reader.Entry.Size);
+                    Assert.NotEqual(0, reader.Entry.Crc);
+                }
+            }
+        }
+    }
+}
--- a/tests/SharpCompress.Test/Rar/RarArchiveTests.cs
+++ b/tests/SharpCompress.Test/Rar/RarArchiveTests.cs
@@ -1,8 +1,9 @@
-using System.IO;
+using System.IO;
 using System.Linq;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Rar;
 using SharpCompress.Common;
+using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.Readers;
 using Xunit;

@@ -16,12 +17,24 @@ namespace SharpCompress.Test.Rar
            ReadRarPassword("Rar.encrypted_filesAndHeader.rar", "test");
        }

+        [Fact]
+        public void Rar_EncryptedFileAndHeader_NoPasswordExceptionTest()
+        {
+            Assert.Throws(typeof(CryptographicException), () => ReadRarPassword("Rar.encrypted_filesAndHeader.rar", null));
+        }
+
        /*[Fact]
        public void Rar5_EncryptedFileAndHeader_Archive()
        {
            ReadRarPassword("Rar5.encrypted_filesAndHeader.rar", "test");
        }*/

+        [Fact]
+        public void Rar5_EncryptedFileAndHeader_NoPasswordExceptionTest()
+        {
+            Assert.Throws(typeof(CryptographicException), () => ReadRarPassword("Rar5.encrypted_filesAndHeader.rar", null));
+        }
+
        [Fact]
        public void Rar_EncryptedFileOnly_Archive()
        {
@@ -203,6 +216,43 @@ namespace SharpCompress.Test.Rar
            VerifyFiles();
        }

+
+        [Fact]
+        public void Rar_IsSolidEntryStreamCheck()
+        {
+            DoRar_IsSolidEntryStreamCheck("Rar.solid.rar");
+        }
+
+        //Extract the 2nd file in a solid archive to check that the first file is skipped properly
+        private void DoRar_IsSolidEntryStreamCheck(string filename)
+        {
+            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)))
+            {
+                using (var archive = RarArchive.Open(stream))
+                {
+                    Assert.True(archive.IsSolid);
+                    IArchiveEntry[] entries = archive.Entries.Where(a => !a.IsDirectory).ToArray();
+                    Assert.NotInRange(entries.Length, 0, 1);
+                    Assert.False(entries[0].IsSolid); //first item in a solid archive is not marked solid and is seekable
+                    IArchiveEntry testEntry = entries[1];
+                    Assert.True(testEntry.IsSolid); //the target. The non seekable entry
+
+                    //process all entries in solid archive until the one we want to test
+                    foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+                    {
+                        using (CrcCheckStream crcStream = new CrcCheckStream((uint)entry.Crc)) //use the 7zip CRC stream for convenience (required a bug fix)
+                        {
+                            using (Stream eStream = entry.OpenEntryStream()) //bug fix in RarStream to report the correct Position
+                                eStream.CopyTo(crcStream);
+                        } //throws if not valid
+                        if (entry == testEntry)
+                            break;
+                    }
+                }
+            }
+        }
+
+
        [Fact]
        public void Rar_Solid_ArchiveStreamRead()
        {
@@ -361,6 +411,171 @@ namespace SharpCompress.Test.Rar
        }

        [Fact]
+        public void Rar2_Multi_ArchiveStreamRead()
+        {
+            DoRar_Multi_ArchiveStreamRead(new string[] {
+                "Rar2.multi.rar",
+                "Rar2.multi.r00",
+                "Rar2.multi.r01",
+                "Rar2.multi.r02",
+                "Rar2.multi.r03",
+                "Rar2.multi.r04",
+                "Rar2.multi.r05"}, false);
+        }
+
+        [Fact]
+        public void Rar2_Multi_ArchiveFileRead()
+        {
+            ArchiveFileRead("Rar2.multi.rar"); //r00, r01...
+        }
+
+        [Fact]
+        public void Rar2_ArchiveFileRead()
+        {
+            ArchiveFileRead("Rar2.rar");
+        }
+
+        [Fact]
+        public void Rar4_Multi_ArchiveFileRead()
+        {
+            ArchiveFileRead("Rar4.multi.part01.rar");
+        }
+
+        [Fact]
+        public void Rar4_ArchiveFileRead()
+        {
+            ArchiveFileRead("Rar4.rar");
+        }
+
+        [Fact]
+        public void Rar_GetPartsSplit()
+        {
+            //uses first part to search for all parts and compares against this array
+            ArchiveGetParts(new string[] {
+                "Rar4.split.001",
+                "Rar4.split.002",
+                "Rar4.split.003",
+                "Rar4.split.004",
+                "Rar4.split.005",
+                "Rar4.split.006"});
+        }
+        [Fact]
+        public void Rar_GetPartsOld()
+        {
+            //uses first part to search for all parts and compares against this array
+            ArchiveGetParts(new string[] {
+                "Rar2.multi.rar",
+                "Rar2.multi.r00",
+                "Rar2.multi.r01",
+                "Rar2.multi.r02",
+                "Rar2.multi.r03",
+                "Rar2.multi.r04",
+                "Rar2.multi.r05"});
+        }
+        [Fact]
+        public void Rar_GetPartsNew()
+        {
+            //uses first part to search for all parts and compares against this array
+            ArchiveGetParts(new string[] {
+                "Rar4.multi.part01.rar",
+                "Rar4.multi.part02.rar",
+                "Rar4.multi.part03.rar",
+                "Rar4.multi.part04.rar",
+                "Rar4.multi.part05.rar",
+                "Rar4.multi.part06.rar",
+                "Rar4.multi.part07.rar"});
+        }
+
+        [Fact]
+        public void Rar4_Multi_ArchiveStreamRead()
+        {
+            DoRar_Multi_ArchiveStreamRead(new string[] {
+                "Rar4.multi.part01.rar",
+                "Rar4.multi.part02.rar",
+                "Rar4.multi.part03.rar",
+                "Rar4.multi.part04.rar",
+                "Rar4.multi.part05.rar",
+                "Rar4.multi.part06.rar",
+                "Rar4.multi.part07.rar"}, false);
+        }
+
+        //no extension to test the lib identifies the archive by content not ext
+        [Fact]
+        public void Rar4_Split_ArchiveStreamRead()
+        {
+            ArchiveStreamMultiRead(null, new string[] {
+                "Rar4.split.001",
+                "Rar4.split.002",
+                "Rar4.split.003",
+                "Rar4.split.004",
+                "Rar4.split.005",
+                "Rar4.split.006"});
+        }
+        //will detect and load other files
+        [Fact]
+        public void Rar4_Multi_ArchiveFirstFileRead()
+        {
+            ArchiveFileRead("Rar4.multi.part01.rar");
+                //"Rar4.multi.part02.rar",
+                //"Rar4.multi.part03.rar",
+                //"Rar4.multi.part04.rar",
+                //"Rar4.multi.part05.rar",
+                //"Rar4.multi.part06.rar",
+                //"Rar4.multi.part07.rar"
+        }
+    //will detect and load other files
+    [Fact]
+        public void Rar4_Split_ArchiveFirstFileRead()
+        {
+            ArchiveFileRead("Rar4.split.001");
+                //"Rar4.split.002",
+                //"Rar4.split.003",
+                //"Rar4.split.004",
+                //"Rar4.split.005",
+                //"Rar4.split.006"
+        }
+        //will detect and load other files
+        [Fact]
+        public void Rar4_Split_ArchiveStreamFirstFileRead()
+        {
+            ArchiveStreamMultiRead(null, new string[] {
+                "Rar4.split.001",
+                //"Rar4.split.002",
+                //"Rar4.split.003",
+                //"Rar4.split.004",
+                //"Rar4.split.005",
+                //"Rar4.split.006"
+                });
+        }
+
+        //open with ArchiveFactory.Open and stream
+        [Fact]
+        public void Rar4_Split_ArchiveOpen()
+        {
+            ArchiveOpenStreamRead(null,
+                "Rar4.split.001",
+                "Rar4.split.002",
+                "Rar4.split.003",
+                "Rar4.split.004",
+                "Rar4.split.005",
+                "Rar4.split.006");
+        }
+
+        //open with ArchiveFactory.Open and stream
+        [Fact]
+        public void Rar4_Multi_ArchiveOpen()
+        {
+            ArchiveOpenStreamRead(null,
+                "Rar4.multi.part01.rar",
+                "Rar4.multi.part02.rar",
+                "Rar4.multi.part03.rar",
+                "Rar4.multi.part04.rar",
+                "Rar4.multi.part05.rar",
+                "Rar4.multi.part06.rar",
+                "Rar4.multi.part07.rar");
+        }
+
+    [Fact]
        public void Rar_Multi_ArchiveFileRead()
        {
            ArchiveFileRead("Rar.multi.part01.rar");
--- a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs
+++ b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 using Xunit;
@@ -7,6 +7,16 @@ namespace SharpCompress.Test.SevenZip
 {
    public class SevenZipArchiveTests : ArchiveTests
    {
+        [Fact]
+        public void SevenZipArchive_Solid_StreamRead()
+        {
+            ArchiveStreamRead("7Zip.solid.7z");
+        }
+        [Fact]
+        public void SevenZipArchive_NonSolid_StreamRead()
+        {
+            ArchiveStreamRead("7Zip.nonsolid.7z");
+        }
        [Fact]
        public void SevenZipArchive_LZMA_StreamRead()
        {
@@ -31,6 +41,11 @@ namespace SharpCompress.Test.SevenZip
            ArchiveFileRead("7Zip.LZMA.Aes.7z", new ReaderOptions() { Password = "testpassword" });
        }
        [Fact]
+        public void SevenZipArchive_LZMAAES_NoPasswordExceptionTest()
+        {
+            Assert.Throws(typeof(CryptographicException), () => ArchiveFileRead("7Zip.LZMA.Aes.7z", new ReaderOptions() { Password = null })); //was failing with ArgumentNullException not CryptographicException like rar
+        }
+        [Fact]
        public void SevenZipArchive_PPMd_StreamRead()
        {
            ArchiveStreamRead("7Zip.PPMd.7z");
@@ -93,13 +108,41 @@ namespace SharpCompress.Test.SevenZip
        [Fact]
        public void SevenZipArchive_BZip2_Split()
        {
-            Assert.Throws<IndexOutOfRangeException>(() => ArchiveStreamRead(null, "Original.7z.001",
-                                                                            "Original.7z.002",
-                                                                            "Original.7z.003",
-                                                                            "Original.7z.004",
-                                                                            "Original.7z.005",
-                                                                            "Original.7z.006",
-                                                                            "Original.7z.007"));
+            Assert.Throws<InvalidOperationException>(() => ArchiveStreamRead(null, "Original.7z.001",
+                                                                             "Original.7z.002",
+                                                                             "Original.7z.003",
+                                                                             "Original.7z.004",
+                                                                             "Original.7z.005",
+                                                                             "Original.7z.006",
+                                                                             "Original.7z.007"));
        }
+
+        //Same as archive as Original.7z.001 ... 007 files without the root directory 'Original\' in the archive - this caused the verify to fail
+        [Fact]
+        public void SevenZipArchive_BZip2_Split_Working()
+        {
+            ArchiveStreamMultiRead(null, "7Zip.BZip2.split.001",
+                                        "7Zip.BZip2.split.002",
+                                        "7Zip.BZip2.split.003",
+                                        "7Zip.BZip2.split.004",
+                                        "7Zip.BZip2.split.005",
+                                        "7Zip.BZip2.split.006",
+                                        "7Zip.BZip2.split.007");
+        }
+
+        //will detect and load other files
+        [Fact]
+        public void SevenZipArchive_BZip2_Split_FirstFileRead()
+        {
+            ArchiveFileRead("7Zip.BZip2.split.001");
+                                        //"7Zip.BZip2.split.002",
+                                        //"7Zip.BZip2.split.003",
+                                        //"7Zip.BZip2.split.004",
+                                        //"7Zip.BZip2.split.005",
+                                        //"7Zip.BZip2.split.006",
+                                        //"7Zip.BZip2.split.007"
+        }
+
+
    }
-}
+}
--- a/tests/SharpCompress.Test/SharpCompress.Test.csproj
+++ b/tests/SharpCompress.Test/SharpCompress.Test.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
-    <TargetFrameworks>net5.0</TargetFrameworks>
+    <TargetFrameworks>net6.0;net461</TargetFrameworks>
    <AssemblyName>SharpCompress.Test</AssemblyName>
    <AssemblyOriginatorKeyFile>../../SharpCompress.snk</AssemblyOriginatorKeyFile>
    <SignAssembly>true</SignAssembly>
@@ -12,13 +12,13 @@
    <ProjectReference Include="..\..\src\SharpCompress\SharpCompress.csproj" />
  </ItemGroup>
  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
+    <PackageReference Include="FluentAssertions" Version="6.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" />
    <PackageReference Include="xunit" Version="2.4.1" />
    <PackageReference Include="Xunit.SkippableFact" Version="1.4.13" />
+  </ItemGroup>
+  <ItemGroup Condition=" '$(VersionlessImplicitFrameworkDefine)' != 'NETFRAMEWORK' ">
    <PackageReference Include="Mono.Posix.NETStandard" Version="1.0.0" />
  </ItemGroup>
 </Project>
--- a/tests/SharpCompress.Test/Streams/ZlibBaseStreamTests.cs
+++ b/tests/SharpCompress.Test/Streams/ZlibBaseStreamTests.cs
@@ -0,0 +1,88 @@
+using System.IO;
+using System.Text;
+using FluentAssertions;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.Deflate;
+using SharpCompress.IO;
+using Xunit;
+
+namespace SharpCompress.Test.Streams
+{
+    public class ZLibBaseStreamTests
+    {
+        [Fact]
+        public void TestChunkedZlibCompressesEverything()
+        {
+            byte[] plainData = new byte[] { 0xf7, 0x1b, 0xda, 0x0f, 0xb6, 0x2b, 0x3d, 0x91, 0xd7, 0xe1, 0xb5, 0x11, 0x34, 0x5a, 0x51, 0x3f, 0x8b, 0xce, 0x49, 0xd2 };
+            byte[] buf = new byte[plainData.Length * 2];
+
+            MemoryStream plainStream1 = new MemoryStream(plainData);
+            DeflateStream compressor1 = new DeflateStream(plainStream1, CompressionMode.Compress);
+            // This is enough to read the entire data
+            int realCompressedSize = compressor1.Read(buf, 0, plainData.Length * 2);
+
+            MemoryStream plainStream2 = new MemoryStream(plainData);
+            DeflateStream compressor2 = new DeflateStream(plainStream2, CompressionMode.Compress);
+            int total = 0;
+            int r = -1; // Jumpstart
+            while (r != 0)
+            {
+                // Reading in chunks
+                r = compressor2.Read(buf, 0, plainData.Length);
+                total += r;
+            }
+
+            Assert.Equal(total, realCompressedSize);
+        }
+        
+        [Fact]
+        public void Zlib_should_read_the_previously_written_message()
+        {
+            var message = new string('a', 131073);  // 131073 causes the failure, but 131072 (-1) doesn't
+            var bytes = Encoding.ASCII.GetBytes(message);
+
+            using (var inputStream = new MemoryStream(bytes))
+            {
+                using (var compressedStream = new MemoryStream())
+                using (var byteBufferStream = new BufferedStream(inputStream)) // System.IO
+                {
+                    Compress(byteBufferStream, compressedStream, compressionLevel: 1);
+                    compressedStream.Position = 0;
+
+                    using (var decompressedStream = new MemoryStream())
+                    {
+                        Decompress(compressedStream, decompressedStream);
+
+                        byteBufferStream.Position = 0;
+                        var result = Encoding.ASCII.GetString(GetBytes(byteBufferStream));
+                        result.Should().Be(message);
+                    }
+                }
+            }
+        }
+
+        private void Compress(Stream input, Stream output, int compressionLevel)
+        {
+            using (var zlibStream = new ZlibStream(new NonDisposingStream(output), CompressionMode.Compress, (CompressionLevel)compressionLevel))
+            {
+                zlibStream.FlushMode = FlushType.Sync;
+                input.CopyTo(zlibStream);
+            }
+        }
+
+        private void Decompress(Stream input, Stream output)
+        {
+            using (var zlibStream = new ZlibStream(new NonDisposingStream(input), CompressionMode.Decompress))
+            {
+                zlibStream.CopyTo(output);
+            }
+        }
+
+        byte[] GetBytes(BufferedStream stream)
+        {
+            byte[] bytes = new byte[stream.Length];
+            stream.Read(bytes, 0, (int)stream.Length);
+            return bytes;
+        }
+    }
+}
--- a/tests/SharpCompress.Test/Tar/TarArchiveTests.cs
+++ b/tests/SharpCompress.Test/Tar/TarArchiveTests.cs
@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Linq;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Tar;
@@ -185,7 +186,7 @@ namespace SharpCompress.Test.Tar

            using (var archive = TarArchive.Open(unmodified))
            {
-                var entry = archive.Entries.Single(x => x.Key.EndsWith("jpg"));
+                var entry = archive.Entries.Single(x => x.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase));
                archive.RemoveEntry(entry);
                archive.SaveTo(scratchPath, CompressionType.None);
            }
--- a/tests/SharpCompress.Test/Tar/TarReaderTests.cs
+++ b/tests/SharpCompress.Test/Tar/TarReaderTests.cs
@@ -190,7 +190,7 @@ namespace SharpCompress.Test.Tar
            }
        }

-#if !NET461
+#if !NETFRAMEWORK
        [Fact]
        public void Tar_GZip_With_Symlink_Entries()
        {
--- a/tests/SharpCompress.Test/TestBase.cs
+++ b/tests/SharpCompress.Test/TestBase.cs
@@ -156,7 +156,7 @@ namespace SharpCompress.Test
        protected void CompareFilesByPath(string file1, string file2)
        {
            //TODO: fix line ending issues with the text file
-            if (file1.EndsWith("txt"))
+            if (file1.EndsWith("txt", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }
--- a/tests/SharpCompress.Test/Xz/Filters/BCJTests.cs
+++ b/tests/SharpCompress.Test/Xz/Filters/BCJTests.cs
@@ -0,0 +1,88 @@
+/*
+ * BCJTests.cs -- XZ converter test class
+ * <Contribution by Louis-Michel Bergeron, on behalf of aDolus Technolog Inc., 2022>
+ */
+
+using System.IO;
+using SharpCompress.Compressors.Xz.Filters;
+using Xunit;
+
+namespace SharpCompress.Test.Xz.Filters
+{
+    public class BCJTests : XZTestsBase
+    {
+        private readonly ArmFilter armFilter;
+        private readonly ArmThumbFilter armtFilter;
+        private readonly IA64Filter ia64Filter;
+        private readonly PowerPCFilter ppcFilter;
+        private readonly SparcFilter sparcFilter;
+        private readonly X86Filter x86Filter;
+        public BCJTests()
+        {
+            armFilter = new ArmFilter();
+            armtFilter = new ArmThumbFilter();
+            ia64Filter = new IA64Filter();
+            ppcFilter = new PowerPCFilter();
+            sparcFilter = new SparcFilter();
+            x86Filter = new X86Filter();
+        }
+
+        [Fact]
+        public void IsOnlyAllowedLast()
+        {
+            Assert.False(armFilter.AllowAsLast);
+            Assert.True(armFilter.AllowAsNonLast);
+
+            Assert.False(armtFilter.AllowAsLast);
+            Assert.True(armtFilter.AllowAsNonLast);
+
+            Assert.False(ia64Filter.AllowAsLast);
+            Assert.True(ia64Filter.AllowAsNonLast);
+
+            Assert.False(ppcFilter.AllowAsLast);
+            Assert.True(ppcFilter.AllowAsNonLast);
+
+            Assert.False(sparcFilter.AllowAsLast);
+            Assert.True(sparcFilter.AllowAsNonLast);
+
+            Assert.False(x86Filter.AllowAsLast);
+            Assert.True(x86Filter.AllowAsNonLast);
+        }
+
+        [Fact]
+        public void ChangesStreamSize()
+        {
+            Assert.False(armFilter.ChangesDataSize);
+            Assert.False(armtFilter.ChangesDataSize);
+            Assert.False(ia64Filter.ChangesDataSize);
+            Assert.False(ppcFilter.ChangesDataSize);
+            Assert.False(sparcFilter.ChangesDataSize);
+            Assert.False(x86Filter.ChangesDataSize);
+        }
+
+        [Theory]
+        [InlineData(new byte[] { 0 })]
+        [InlineData(new byte[] { 0, 0, 0, 0, 0 })]
+        public void OnlyAcceptsOneByte(byte[] bytes)
+        {
+            InvalidDataException ex;
+            ex = Assert.Throws<InvalidDataException>(() => armFilter.Init(bytes));
+            Assert.Equal("ARM properties unexpected length", ex.Message);
+
+            ex = Assert.Throws<InvalidDataException>(() => armtFilter.Init(bytes));
+            Assert.Equal("ARM Thumb properties unexpected length", ex.Message);
+
+            ex = Assert.Throws<InvalidDataException>(() => ia64Filter.Init(bytes));
+            Assert.Equal("IA64 properties unexpected length", ex.Message);
+
+            ex = Assert.Throws<InvalidDataException>(() => ppcFilter.Init(bytes));
+            Assert.Equal("PPC properties unexpected length", ex.Message);
+
+            ex = Assert.Throws<InvalidDataException>(() => sparcFilter.Init(bytes));
+            Assert.Equal("SPARC properties unexpected length", ex.Message);
+
+            ex = Assert.Throws<InvalidDataException>(() => x86Filter.Init(bytes));
+            Assert.Equal("X86 properties unexpected length", ex.Message);
+        }
+    }
+}
--- a/tests/SharpCompress.Test/Xz/XZTestsBase.cs
+++ b/tests/SharpCompress.Test/Xz/XZTestsBase.cs
@@ -1,9 +1,10 @@
-using System.Text;
+using System;
+using System.Text;
 using System.IO;

 namespace SharpCompress.Test.Xz
 {
-    public abstract class XZTestsBase
+    public abstract class XZTestsBase : IDisposable
    {
        public XZTestsBase()
        {
@@ -12,6 +13,13 @@ namespace SharpCompress.Test.Xz
            RewindIndexed(CompressedIndexedStream);
        }

+        public void Dispose()
+        {
+            CompressedEmptyStream?.Dispose();
+            CompressedStream?.Dispose();
+            CompressedIndexedStream?.Dispose();
+        }
+
        protected virtual void RewindEmpty(Stream stream)
        {
            stream.Position = 0;
--- a/tests/SharpCompress.Test/Zip/Zip64Tests.cs
+++ b/tests/SharpCompress.Test/Zip/Zip64Tests.cs
@@ -64,7 +64,7 @@ namespace SharpCompress.Test.Zip
            {
                // One single file, should fail
                RunSingleTest(1, FOUR_GB_LIMIT, set_zip64: false, forward_only: false);
-                throw new Exception("Test did not fail?");
+                throw new InvalidOperationException("Test did not fail?");
            }
            catch (NotSupportedException)
            {
@@ -78,7 +78,7 @@ namespace SharpCompress.Test.Zip
            {
                // One single file, should fail (fast) with zip64
                RunSingleTest(1, FOUR_GB_LIMIT, set_zip64: true, forward_only: true);
-                throw new Exception("Test did not fail?");
+                throw new InvalidOperationException("Test did not fail?");
            }
            catch (NotSupportedException)
            {
@@ -92,7 +92,7 @@ namespace SharpCompress.Test.Zip
            {
                // One single file, should fail once the write discovers the problem
                RunSingleTest(1, FOUR_GB_LIMIT, set_zip64: false, forward_only: true);
-                throw new Exception("Test did not fail?");
+                throw new InvalidOperationException("Test did not fail?");
            }
            catch (NotSupportedException)
            {
@@ -116,23 +116,23 @@ namespace SharpCompress.Test.Zip
            var resForward = ReadForwardOnly(filename);
            if (resForward.Item1 != files)
            {
-                throw new Exception($"Incorrect number of items reported: {resForward.Item1}, should have been {files}");
+                throw new InvalidOperationException($"Incorrect number of items reported: {resForward.Item1}, should have been {files}");
            }

            if (resForward.Item2 != files * filesize)
            {
-                throw new Exception($"Incorrect combined size reported: {resForward.Item2}, should have been {files * filesize}");
+                throw new InvalidOperationException($"Incorrect combined size reported: {resForward.Item2}, should have been {files * filesize}");
            }

            var resArchive = ReadArchive(filename);
            if (resArchive.Item1 != files)
            {
-                throw new Exception($"Incorrect number of items reported: {resArchive.Item1}, should have been {files}");
+                throw new InvalidOperationException($"Incorrect number of items reported: {resArchive.Item1}, should have been {files}");
            }

            if (resArchive.Item2 != files * filesize)
            {
-                throw new Exception($"Incorrect number of items reported: {resArchive.Item2}, should have been {files * filesize}");
+                throw new InvalidOperationException($"Incorrect number of items reported: {resArchive.Item2}, should have been {files * filesize}");
            }
        }

@@ -209,4 +209,4 @@ namespace SharpCompress.Test.Zip
            }
        }
    }
-}
+}
--- a/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs
+++ b/tests/SharpCompress.Test/Zip/ZipArchiveTests.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -93,6 +93,33 @@ namespace SharpCompress.Test.Zip
            ArchiveFileRead("Zip.bzip2.zip");
        }
        [Fact]
+        public void WinZip26_ArchiveFileRead()
+        {
+            ArchiveFileRead("WinZip26.zip");
+        }
+        [Fact]
+        public void WinZip26_Multi_ArchiveFileRead()
+        {
+            ArchiveStreamMultiRead(null, "WinZip26.nocomp.multi.zip",
+                                        "WinZip26.nocomp.multi.z01"); //min split size is 64k so no compression used
+        }
+        [Fact]
+        public void WinZip26_X_BZip2_ArchiveFileRead()
+        {
+            ArchiveFileRead("WinZip26_BZip2.zipx");
+        }
+        [Fact]
+        public void WinZip26_X_Lzma_ArchiveFileRead()
+        {
+            ArchiveFileRead("WinZip26_LZMA.zipx");
+        }
+        [Fact]
+        public void WinZip26_X_Multi_ArchiveFileRead()
+        {
+            ArchiveStreamMultiRead(null, "WinZip26.nocomp.multi.zipx",
+                                        "WinZip26.nocomp.multi.zx01"); //min split size is 64k so no compression used
+        }
+        [Fact]
        public void Zip_Deflate_Streamed2_ArchiveFileRead()
        {
            ArchiveFileRead("Zip.deflate.dd-.zip");
@@ -107,6 +134,75 @@ namespace SharpCompress.Test.Zip
        {
            ArchiveFileRead("Zip.deflate.zip");
        }
+        //will detect and load other files
+        [Fact]
+        public void Zip_Deflate_Multi_ArchiveFirstFileRead()
+        {
+            ArchiveFileRead("WinZip26.nocomp.multi.zip");
+            //"WinZip26.nocomp.multi.z01"
+        }
+        //will detect and load other files
+        [Fact]
+        public void ZipX_Deflate_Multi_ArchiveFirstFileRead()
+        {
+            ArchiveFileRead("WinZip26.nocomp.multi.zipx");
+                            //"WinZip26.nocomp.multi.zx01"
+        }
+        [Fact]
+        public void Zip_GetParts()
+        {
+            //uses first part to search for all parts and compares against this array
+            ArchiveGetParts(new string[] {
+                "Infozip.nocomp.multi.zip",
+                "Infozip.nocomp.multi.z01"});
+        }
+        [Fact]
+        public void ZipX_GetParts()
+        {
+            //uses first part to search for all parts and compares against this array
+            ArchiveGetParts(new string[] {
+                "WinZip26.nocomp.multi.zipx",
+                "WinZip26.nocomp.multi.zx01"});
+        }
+        [Fact]
+        public void Zip_GetPartsSplit()
+        {
+            //uses first part to search for all parts and compares against this array
+            ArchiveGetParts(new string[] {
+                "Zip.deflate.split.001",
+                "Zip.deflate.split.002",
+                "Zip.deflate.split.003",
+                "Zip.deflate.split.004",
+                "Zip.deflate.split.005",
+                "Zip.deflate.split.006"});
+        }
+        //will detect and load other files
+        [Fact]
+        public void Zip_Deflate_Split_ArchiveFirstFileRead()
+        {
+            ArchiveFileRead("Zip.deflate.split.001");
+                            //"Zip.deflate.split.002",
+                            //"Zip.deflate.split.003",
+                            //"Zip.deflate.split.004",
+                            //"Zip.deflate.split.005",
+                            //"Zip.deflate.split.006"
+        }
+        [Fact]
+        public void Zip_Deflate_Split_ArchiveFileRead()
+        {
+            ArchiveStreamMultiRead(null, "Zip.deflate.split.001",
+                                        "Zip.deflate.split.002",
+                                        "Zip.deflate.split.003",
+                                        "Zip.deflate.split.004",
+                                        "Zip.deflate.split.005",
+                                        "Zip.deflate.split.006");
+        }
+        [Fact]
+        public void Zip_InfoZip_Multi_ArchiveFileRead()
+        {
+            ArchiveStreamMultiRead(null, "Infozip.nocomp.multi.zip",
+                                        "Infozip.nocomp.multi.z01"); //min split size is 64k so no compression used
+        }
        [Fact]
        public void Zip_Deflate64_ArchiveFileRead()
        {
@@ -160,7 +256,7 @@ namespace SharpCompress.Test.Zip

            using (var archive = ZipArchive.Open(unmodified))
            {
-                var entry = archive.Entries.Single(x => x.Key.EndsWith("jpg"));
+                var entry = archive.Entries.Single(x => x.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase));
                archive.RemoveEntry(entry);

                WriterOptions writerOptions = new ZipWriterOptions(CompressionType.Deflate);
@@ -219,10 +315,10 @@ namespace SharpCompress.Test.Zip

            using (ZipArchive vfs = (ZipArchive)ArchiveFactory.Open(scratchPath))
            {
-                var e = vfs.Entries.First(v => v.Key.EndsWith("jpg"));
+                var e = vfs.Entries.First(v => v.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase));
                vfs.RemoveEntry(e);
-                Assert.Null(vfs.Entries.FirstOrDefault(v => v.Key.EndsWith("jpg")));
-                Assert.Null(((IArchive)vfs).Entries.FirstOrDefault(v => v.Key.EndsWith("jpg")));
+                Assert.Null(vfs.Entries.FirstOrDefault(v => v.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase)));
+                Assert.Null(((IArchive)vfs).Entries.FirstOrDefault(v => v.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase)));
            }
        }

@@ -262,7 +358,7 @@ namespace SharpCompress.Test.Zip
            foreach (var file in Directory.EnumerateFiles(ORIGINAL_FILES_PATH, "*.*", SearchOption.AllDirectories))
            {
                var newFileName = file.Substring(ORIGINAL_FILES_PATH.Length);
-                if (newFileName.StartsWith(Path.DirectorySeparatorChar.ToString()))
+                if (newFileName.StartsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.OrdinalIgnoreCase))
                {
                    newFileName = newFileName.Substring(1);
                }
@@ -290,13 +386,35 @@ namespace SharpCompress.Test.Zip
            Directory.Delete(SCRATCH_FILES_PATH, true);
        }

+        /// <summary>
+        /// Creates an empty zip file and attempts to read it right afterwards.
+        /// Ensures that parsing file headers works even in that case
+        /// </summary>
+        [Fact]
+        public void Zip_Create_Empty_And_Read()
+        {
+            var archive = ZipArchive.Create();
+
+            var archiveStream = new MemoryStream();
+
+            archive.SaveTo(archiveStream, CompressionType.LZMA);
+
+            archiveStream.Position = 0;
+
+            var readArchive = ArchiveFactory.Open(archiveStream);
+
+            var count = readArchive.Entries.Count();
+
+            Assert.Equal(0, count);
+        }
+
        [Fact]
        public void Zip_Create_New_Add_Remove()
        {
            foreach (var file in Directory.EnumerateFiles(ORIGINAL_FILES_PATH, "*.*", SearchOption.AllDirectories))
            {
                var newFileName = file.Substring(ORIGINAL_FILES_PATH.Length);
-                if (newFileName.StartsWith(Path.DirectorySeparatorChar.ToString()))
+                if (newFileName.StartsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.OrdinalIgnoreCase))
                {
                    newFileName = newFileName.Substring(1);
                }
@@ -314,7 +432,7 @@ namespace SharpCompress.Test.Zip
            {
                archive.AddAllFromDirectory(SCRATCH_FILES_PATH);
                archive.RemoveEntry(archive.Entries.Single(x => x.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase)));
-                Assert.Null(archive.Entries.FirstOrDefault(x => x.Key.EndsWith("jpg")));
+                Assert.Null(archive.Entries.FirstOrDefault(x => x.Key.EndsWith("jpg", StringComparison.OrdinalIgnoreCase)));
            }
            Directory.Delete(SCRATCH_FILES_PATH, true);
        }
@@ -496,7 +614,7 @@ namespace SharpCompress.Test.Zip

            using (IWriter zipWriter = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
            {
-                zipWriter.Write("foo.txt", new MemoryStream(new byte[0]));
+                zipWriter.Write("foo.txt", new MemoryStream(Array.Empty<byte>()));
                zipWriter.Write("foo2.txt", new MemoryStream(new byte[10]));
            }

@@ -564,5 +682,36 @@ namespace SharpCompress.Test.Zip
                }
            }
        }
+
+        [Fact]
+        public void Zip_LongComment_Read()
+        {
+            string zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.LongComment.zip");
+
+            using (ZipArchive za = ZipArchive.Open(zipPath))
+            {
+                var count = za.Entries.Count;
+                Assert.Equal(1, count);
+            }
+        }
+
+        [Fact]
+        public void Zip_Zip64_CompressedSizeExtraOnly_Read()
+        {
+            string zipPath = Path.Combine(TEST_ARCHIVES_PATH, "Zip.zip64.compressedonly.zip");
+
+            using (ZipArchive za = ZipArchive.Open(zipPath))
+            {
+                var firstEntry = za.Entries.First(x => x.Key == "test/test.txt");
+
+                using (var memoryStream = new MemoryStream())
+                using (var firstStream = firstEntry.OpenEntryStream())
+                {
+                    firstStream.CopyTo(memoryStream);
+                    Assert.Equal(15, memoryStream.Length);
+                }
+            }
+        }
+
    }
 }
--- a/tests/SharpCompress.Test/Zip/ZipReaderTests.cs
+++ b/tests/SharpCompress.Test/Zip/ZipReaderTests.cs
@@ -269,12 +269,40 @@ namespace SharpCompress.Test.Zip
            VerifyFiles();
        }

+        [Fact]
+        public void Zip_Deflate_ZipCrypto_Read()
+        {
+            int count = 0;
+            using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "zipcrypto.zip")))
+            using (var reader = ZipReader.Open(stream, new ReaderOptions()
+            {
+                Password = "test"
+            }))
+            {
+                while (reader.MoveToNextEntry())
+                {
+                    if (!reader.Entry.IsDirectory)
+                    {
+                        Assert.Equal(CompressionType.None, reader.Entry.CompressionType);
+                        reader.WriteEntryToDirectory(SCRATCH_FILES_PATH,
+                                                     new ExtractionOptions()
+                                                     {
+                                                         ExtractFullPath = true,
+                                                         Overwrite = true
+                                                     });
+                        count++;
+                    }
+                }
+            }
+            Assert.Equal(8, count);
+        }
+
        [Fact]
        public void TestSharpCompressWithEmptyStream()
        {
            var expected = new Tuple<string, byte[]>[]
            {
-                new Tuple<string, byte[]>("foo.txt", new byte[0]),
+                new Tuple<string, byte[]>("foo.txt", Array.Empty<byte>()),
                new Tuple<string, byte[]>("foo2.txt", new byte[10])
            };

--- a/tests/TestArchives/Archives/7Zip.BZip2.split.001
+++ b/tests/TestArchives/Archives/7Zip.BZip2.split.001
--- a/tests/TestArchives/Archives/7Zip.BZip2.split.002
+++ b/tests/TestArchives/Archives/7Zip.BZip2.split.002
--- a/tests/TestArchives/Archives/7Zip.BZip2.split.003
+++ b/tests/TestArchives/Archives/7Zip.BZip2.split.003
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
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
Adam Hathcock	403baf05a6	Mark for 0.28	2021-02-14 13:07:35 +00:00
Adam Hathcock	a51b56339a	Fix complete entry check for RAR files.	2021-02-14 13:00:43 +00:00
Adam Hathcock	f48a6d47dc	Merge pull request #571 from Erior/feature/540 Proposal fixing Extra bytes written when setting zip64	2021-02-14 12:54:17 +00:00
Adam Hathcock	5b52463e4c	Merge pull request #570 from Erior/feature/555 Propsal for handling Zip with long comment	2021-02-14 12:52:42 +00:00
Adam Hathcock	6f08bb72d8	Merge pull request #569 from BrendanGrant/improve_how_missing_parts_are_handled Improve how missing parts are handled	2021-02-14 12:49:49 +00:00
Lars Vahlenberg	045093f453	Linux is case sensitive with files names	2021-02-14 10:26:26 +01:00
Lars Vahlenberg	566c49ce53	Proposal Zip64 requires version 4.5 Number of disks is 4 bytes and not 8	2021-02-14 02:42:32 +01:00
Lars Vahlenberg	d1d2758ee0	Propsal for handling Zip with long comment	2021-02-13 23:57:03 +01:00
Brendan Grant	5b86c40d5b	Properly detect if RAR is complete at the end or not	2021-02-13 13:34:57 -06:00
Brendan Grant	53393e744e	Supporting reading contents of incomplete files	2021-02-13 13:33:43 -06:00
Adam Hathcock	2dd17e3882	Be explicit about zip64 extra field sizes. Formatting	2021-02-13 07:05:53 +00:00
Adam Hathcock	c4f7433584	Merge pull request #567 from Nanook/master Zip64 Header and Size fix	2021-02-13 06:58:41 +00:00
Adam Hathcock	9405a7cf4b	Merge pull request #568 from Bond-009/stackalloc Use stackallocs where possible/sensible	2021-02-13 06:39:32 +00:00
Bond_009	cd677440ce	Use stackallocs where possible/sensible	2021-02-12 20:20:15 +01:00
Craig Greenhill	c06f4bc5a8	Zip64 Header and Size fix	2021-02-11 09:37:59 +00:00
Adam Hathcock	4a7337b223	Merge pull request #563 from adamhathcock/add-reader-test-gzip Fix Rewindable stream Length and add GZip Reader tests	2021-01-13 15:13:34 +00:00
Adam Hathcock	1d8afb817e	Bump version	2021-01-13 14:41:25 +00:00
Adam Hathcock	0f06c3d934	Fix rewindable stream to expose length	2021-01-13 14:40:36 +00:00
Adam Hathcock	9d5cb8d119	Add GZip Reader tests	2021-01-13 10:42:59 +00:00