From 806c1a8126f52ab7c68cade505e0107728aeeeeb Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Sat, 28 Dec 2019 22:38:18 +0000
Subject: [PATCH] V0.13.2 (#8)

* Refactored diffing strategy pipeline categories

* fixed bug in textnodefilter

* Code clean up

* 0.13.2 done
---
 .editorconfig                                 |  16 --
 CHANGELOG.md                                  |   9 +
 src/.editorconfig                             | 227 ++++++++++++++++++
 .../Core/AttributeComparisonSourceTest.cs     |   6 +-
 .../Core/AttributeComparisonTest.cs           |   1 +
 .../Core/ComparisonSourceTest.cs              |   2 +-
 .../Core/DiffingEngineTestBase.cs             |   2 +-
 .../Core/HtmlDifferenceEngineTest.cs          |  11 +-
 .../Core/SourceCollectionTest.cs              |   2 +
 .../Core/SourceMapTest.cs                     |   2 +
 .../DiffBuilderTest.cs                        |   4 +-
 .../DiffingTestBase.cs                        |   6 +-
 .../DiffingTestFixture.cs                     |   3 +-
 .../ShouldlyTestExtensions.cs                 |   1 +
 .../AttributeComparerTest.cs                  |   2 +
 .../AttributeNameMatcherTest.cs               |   8 +-
 .../BooleanAttributeComparerTest.cs           |   9 +-
 .../ClassAttributeComparerTest.cs             |   2 +
 .../IgnoreAttributeComparerTest.cs            |   2 +
 .../IgnoreDiffAttributesFilterTest.cs         |   2 +
 .../PostfixedAttributeMatcherTest.cs          |   4 +-
 .../StyleAttributeComparerTest.cs             |   7 +-
 .../IgnoreCommentsFilterTest.cs               |   2 +
 .../Strategies/DiffingStrategyPipelineTest.cs |  96 ++++----
 .../CssSelectorElementMatcherTest.cs          |  10 +-
 .../IgnoreElementComparerTest.cs              |   5 +-
 .../ForwardSearchingNodeMatcherTest.cs        |   5 +-
 .../NodeStrategies/NodeComparerTest.cs        |   2 +
 .../NodeStrategies/OneToOneNodeMatcherTest.cs |   6 +-
 .../StyleSheetTextNodeComparerTest.cs         |   9 +-
 .../TextNodeComparerTest.cs                   |   6 +-
 .../TextNodeStrategies/TextNodeFilterTest.cs  |  22 +-
 src/AngleSharp.Diffing.sln                    |   5 -
 .../AngleSharp.Diffing.csproj                 |   2 +-
 .../Core/AttributeComparison.cs               |  10 +-
 .../Core/AttributeComparisonSource.cs         |  23 +-
 src/AngleSharp.Diffing/Core/CompareResult.cs  |  10 +
 src/AngleSharp.Diffing/Core/Comparison.cs     |  36 ++-
 .../Core/ComparisonSource.cs                  |  81 +++++--
 src/AngleSharp.Diffing/Core/DiffContext.cs    |  31 ++-
 src/AngleSharp.Diffing/Core/DiffResult.cs     |  13 +-
 src/AngleSharp.Diffing/Core/DiffTarget.cs     |  28 +++
 src/AngleSharp.Diffing/Core/Diffs/AttrDiff.cs |   6 +
 src/AngleSharp.Diffing/Core/Diffs/DiffBase.cs |  15 ++
 .../Core/Diffs/MissingAttrDiff.cs             |   8 +-
 .../Core/Diffs/MissingDiffBase.cs             |  12 +
 .../Core/Diffs/MissingNodeDiff.cs             |   6 +
 src/AngleSharp.Diffing/Core/Diffs/NodeDiff.cs |   6 +
 .../Core/Diffs/UnexpectedAttrDiff.cs          |   6 +
 .../Core/Diffs/UnexpectedDiffBase.cs          |  11 +
 .../Core/Diffs/UnexpectedNodeDiff.cs          |   6 +
 src/AngleSharp.Diffing/Core/FilterDecision.cs |  19 ++
 .../Core/HtmlDifferenceEngine.cs              |  15 +-
 .../Core/IComparisonSource.cs                 |  12 +
 src/AngleSharp.Diffing/Core/IDiff.cs          |   3 +
 src/AngleSharp.Diffing/Core/IDiffContext.cs   |  18 +-
 .../Core/SourceCollection.cs                  |  28 ++-
 .../Core/SourceCollectionRemovePredicate.cs   |   7 +
 src/AngleSharp.Diffing/Core/SourceMap.cs      |  45 +++-
 .../Core/SourceMapRemovePredicate.cs          |   7 +
 src/AngleSharp.Diffing/Core/SourceType.cs     |   9 +
 src/AngleSharp.Diffing/DiffBuilder.cs         |  29 ++-
 .../Extensions/CollectionExtensions.cs        |  12 +-
 .../Extensions/ElementExtensions.cs           |  54 ++++-
 .../Extensions/EmptyHtmlCollection.cs         |  15 ++
 .../Extensions/EnumExtensions.cs              |   6 +
 .../Extensions/NodeExtensions.cs              |  30 +++
 .../Extensions/NodeListExtensions.cs          |  18 +-
 .../Extensions/NodeNotFoundException.cs       |  25 --
 src/AngleSharp.Diffing/HtmlDiffer.cs          |  56 ++++-
 .../AttributeStrategies/AttributeComparer.cs  |  13 +-
 .../AttributeNameMatcher.cs                   |  13 +-
 .../BooleanAttributeComparer.cs               |  25 +-
 .../BooleanAttributeComparision.cs            |   9 +
 .../ClassAttributeComparer.cs                 |  16 +-
 ...iffingStrategyPipelineBuilderExtensions.cs |  20 +-
 .../IgnoreAttributeComparer.cs                |  10 +-
 .../IgnoreDiffAttributesFilter.cs             |  12 +-
 .../PostfixedAttributeMatcher.cs              |  16 +-
 .../StyleAttributeComparer.cs                 |  12 +-
 .../CommentStrategies/CommentComparer.cs      |  11 +-
 ...iffingStrategyPipelineBuilderExtensions.cs |   8 +-
 .../CommentStrategies/IgnoreCommentsFilter.cs |  14 +-
 .../Strategies/CompareStrategy.cs             |  16 ++
 .../Strategies/DiffingStrategyPipeline.cs     |  98 +++-----
 ...iffingStrategyPipelineBuilderExtensions.cs |   3 +-
 .../CssSelectorElementMatcher.cs              |  20 +-
 ...SelectorReturnedTooManyResultsException.cs |  16 ++
 ...iffingStrategyPipelineBuilderExtensions.cs |   7 +-
 .../ElementStrategies/ElementComparer.cs      |  11 +-
 .../IgnoreElementComparer.cs                  |  15 +-
 .../Strategies/FilterStrategy.cs              |  17 ++
 .../Strategies/IDiffingStrategyCollection.cs  |  30 +--
 .../Strategies/MatchStrategy.cs               |  22 ++
 ...iffingStrategyPipelineBuilderExtensions.cs |   7 +-
 .../ForwardSearchingNodeMatcher.cs            |  13 +-
 .../NodeStrategies/OneToOneNodeMatcher.cs     |  13 +-
 .../Strategies/StrategyType.cs                |  17 ++
 ...iffingStrategyPipelineBuilderExtensions.cs |   7 +-
 .../StyleSheetTextNodeComparer.cs             |  13 +-
 .../TextNodeStrategies/TextNodeComparer.cs    |  23 +-
 .../TextNodeStrategies/TextNodeFilter.cs      |  30 ++-
 .../TextNodeStrategies/WhitespaceOption.cs    |  13 +
 103 files changed, 1414 insertions(+), 370 deletions(-)
 delete mode 100644 .editorconfig
 create mode 100644 src/.editorconfig
 create mode 100644 src/AngleSharp.Diffing/Core/SourceCollectionRemovePredicate.cs
 create mode 100644 src/AngleSharp.Diffing/Core/SourceMapRemovePredicate.cs
 delete mode 100644 src/AngleSharp.Diffing/Extensions/NodeNotFoundException.cs
 create mode 100644 src/AngleSharp.Diffing/Strategies/CompareStrategy.cs
 create mode 100644 src/AngleSharp.Diffing/Strategies/FilterStrategy.cs
 create mode 100644 src/AngleSharp.Diffing/Strategies/MatchStrategy.cs
 create mode 100644 src/AngleSharp.Diffing/Strategies/StrategyType.cs

diff --git a/.editorconfig b/.editorconfig
deleted file mode 100644
index b8b7013..0000000
--- a/.editorconfig
+++ /dev/null
@@ -1,16 +0,0 @@
-# http://editorconfig.org
-root = true
-
-[*]
-indent_style = space
-indent_size = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-
-[*.csproj]
-indent_style = space
-indent_size = 2
-
-# CS1591: Missing XML comment for publicly visible type or member
-dotnet_diagnostic.CS1591.severity = suggestion
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bed5753..771792b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# 0.13.2
+
+Released on Thursday, December 27, 2019.
+
+- Added code documentation to all public methods.
+- Refactored IDiffingStrategyCollection's methods to take a `StrategyType strategyType = StrategyType.Specialized` as input instead of `bool isSpecialized* = true` argument.
+- Fixed bug where `TextNodeFilter` would not give `<style>` and `<script>` the `WhitespaceOption.Preserve` by default.
+- Fixed bug where `IgnoreElementComparer` would not change a current decision to SKip if it was Same.
+
 # 0.13.1
 
 Released on Thursday, December 26, 2019.
diff --git a/src/.editorconfig b/src/.editorconfig
new file mode 100644
index 0000000..8dea088
--- /dev/null
+++ b/src/.editorconfig
@@ -0,0 +1,227 @@
+# Remove the line below if you want to inherit .editorconfig settings from higher directories
+root = true
+
+# C# files
+[*.cs]
+
+#### Core EditorConfig Options ####
+
+# Indentation and spacing
+indent_size = 4
+indent_style = space
+tab_width = 4
+trim_trailing_whitespace = true
+
+# New line preferences
+end_of_line = crlf
+insert_final_newline = false
+
+#### .NET Coding Conventions ####
+
+# Organize usings
+dotnet_separate_import_directive_groups = true
+dotnet_sort_system_directives_first = true
+
+# this. and Me. preferences
+dotnet_style_qualification_for_event = false:silent
+dotnet_style_qualification_for_field = false:silent
+dotnet_style_qualification_for_method = false:silent
+dotnet_style_qualification_for_property = false:silent
+
+# Language keywords vs BCL types preferences
+dotnet_style_predefined_type_for_locals_parameters_members = true:silent
+dotnet_style_predefined_type_for_member_access = true:silent
+
+# Parentheses preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:silent
+dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:silent
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary:silent
+dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:silent
+
+# Modifier preferences
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent
+
+# Expression-level preferences
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_prefer_auto_properties = true:silent
+dotnet_style_prefer_compound_assignment = true:suggestion
+dotnet_style_prefer_conditional_expression_over_assignment = true:silent
+dotnet_style_prefer_conditional_expression_over_return = true:silent
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
+dotnet_style_prefer_inferred_tuple_names = true:suggestion
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
+
+# Field preferences
+dotnet_style_readonly_field = true:suggestion
+
+# Parameter preferences
+dotnet_code_quality_unused_parameters = all:suggestion
+
+#### C# Coding Conventions ####
+
+# var preferences
+csharp_style_var_elsewhere = true:silent
+csharp_style_var_for_built_in_types = true:silent
+csharp_style_var_when_type_is_apparent = true:silent
+
+# Expression-bodied members
+csharp_style_expression_bodied_accessors = true:silent
+csharp_style_expression_bodied_constructors = true:silent
+csharp_style_expression_bodied_indexers = true:silent
+csharp_style_expression_bodied_lambdas = true:silent
+csharp_style_expression_bodied_local_functions = true:silent
+csharp_style_expression_bodied_methods = true:silent
+csharp_style_expression_bodied_operators = true:silent
+csharp_style_expression_bodied_properties = true:silent
+
+# Pattern matching preferences
+csharp_style_pattern_matching_over_as_with_null_check = true:warning
+csharp_style_pattern_matching_over_is_with_cast_check = true:warning
+csharp_style_prefer_switch_expression = true:suggestion
+
+# Null-checking preferences
+csharp_style_conditional_delegate_call = true:suggestion
+
+# Modifier preferences
+csharp_prefer_static_local_function = true:suggestion
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:silent
+
+# Code-block preferences
+csharp_prefer_braces = when_multiline:silent
+csharp_prefer_simple_using_statement = true:suggestion
+
+# Expression-level preferences
+csharp_prefer_simple_default_expression = true:suggestion
+csharp_style_deconstructed_variable_declaration = true:suggestion
+csharp_style_inlined_variable_declaration = true:warning
+csharp_style_pattern_local_over_anonymous_function = true:suggestion
+csharp_style_prefer_index_operator = true:suggestion
+csharp_style_prefer_range_operator = true:suggestion
+csharp_style_throw_expression = true:suggestion
+csharp_style_unused_value_assignment_preference = discard_variable:suggestion
+csharp_style_unused_value_expression_statement_preference = discard_variable:silent
+
+# 'using' directive preferences
+csharp_using_directive_placement = outside_namespace:suggestion
+
+#### C# Formatting Rules ####
+
+# New line preferences
+csharp_new_line_before_catch = true
+csharp_new_line_before_else = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_open_brace = all
+csharp_new_line_between_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_case_contents_when_block = false
+csharp_indent_labels = no_change
+csharp_indent_switch_labels = true
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_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_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+
+# Wrapping preferences
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = false
+
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.static_field_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.static_field_should_be_pascal_case.symbols = static_field
+dotnet_naming_rule.static_field_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.const_field_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.const_field_should_be_pascal_case.symbols = const_field
+dotnet_naming_rule.const_field_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.private_or_internal_field_should_be_fields_begin_with__.severity = suggestion
+dotnet_naming_rule.private_or_internal_field_should_be_fields_begin_with__.symbols = private_or_internal_field
+dotnet_naming_rule.private_or_internal_field_should_be_fields_begin_with__.style = fields_begin_with__
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.static_field.applicable_kinds = field
+dotnet_naming_symbols.static_field.applicable_accessibilities = public, internal, private, protected, protected_internal
+dotnet_naming_symbols.static_field.required_modifiers = static
+
+dotnet_naming_symbols.private_or_internal_field.applicable_kinds = field
+dotnet_naming_symbols.private_or_internal_field.applicable_accessibilities = internal, private
+dotnet_naming_symbols.private_or_internal_field.required_modifiers = 
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal
+dotnet_naming_symbols.types.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+dotnet_naming_symbols.const_field.applicable_kinds = field
+dotnet_naming_symbols.const_field.applicable_accessibilities = *
+dotnet_naming_symbols.const_field.required_modifiers = const
+
+# Naming styles
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.fields_begin_with__.required_prefix = _
+dotnet_naming_style.fields_begin_with__.required_suffix = 
+dotnet_naming_style.fields_begin_with__.word_separator = 
+dotnet_naming_style.fields_begin_with__.capitalization = camel_case
diff --git a/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonSourceTest.cs b/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonSourceTest.cs
index f3c3635..8daa7ff 100644
--- a/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonSourceTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonSourceTest.cs
@@ -1,5 +1,7 @@
-using Shouldly;
-using System;
+using System;
+
+using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Core
diff --git a/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonTest.cs b/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonTest.cs
index 0579170..e9288c9 100644
--- a/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Core/AttributeComparisonTest.cs
@@ -1,4 +1,5 @@
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Core
diff --git a/src/AngleSharp.Diffing.Tests/Core/ComparisonSourceTest.cs b/src/AngleSharp.Diffing.Tests/Core/ComparisonSourceTest.cs
index d756706..506671f 100644
--- a/src/AngleSharp.Diffing.Tests/Core/ComparisonSourceTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Core/ComparisonSourceTest.cs
@@ -1,5 +1,5 @@
-using System;
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Core
diff --git a/src/AngleSharp.Diffing.Tests/Core/DiffingEngineTestBase.cs b/src/AngleSharp.Diffing.Tests/Core/DiffingEngineTestBase.cs
index 2e3a9a2..6af1904 100644
--- a/src/AngleSharp.Diffing.Tests/Core/DiffingEngineTestBase.cs
+++ b/src/AngleSharp.Diffing.Tests/Core/DiffingEngineTestBase.cs
@@ -27,7 +27,7 @@ protected static HtmlDiffer CreateHtmlDiffer(
             );
         }
 
-        class MockDiffingStrategy : IDiffingStrategy
+        private class MockDiffingStrategy : IDiffingStrategy
         {
             private readonly Func<ComparisonSource, FilterDecision>? _nodeFilter;
             private readonly Func<AttributeComparisonSource, FilterDecision>? _attrFilter;
diff --git a/src/AngleSharp.Diffing.Tests/Core/HtmlDifferenceEngineTest.cs b/src/AngleSharp.Diffing.Tests/Core/HtmlDifferenceEngineTest.cs
index ffe786b..302f713 100644
--- a/src/AngleSharp.Diffing.Tests/Core/HtmlDifferenceEngineTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Core/HtmlDifferenceEngineTest.cs
@@ -1,10 +1,13 @@
 using System;
 using System.Collections.Generic;
-using AngleSharp.Dom;
+using System.Linq;
+
 using AngleSharp.Diffing.Strategies.NodeStrategies;
+using AngleSharp.Dom;
+
 using Shouldly;
+
 using Xunit;
-using System.Linq;
 
 namespace AngleSharp.Diffing.Core
 {
@@ -296,7 +299,7 @@ public void OnlyOnePartHasChildNodes(string control, string test, Type expectedD
             results.Count.ShouldBe(2);
             results[0].ShouldBeOfType<NodeDiff>();
             results[1].ShouldBeOfType(expectedDiffType);
-        }      
+        }
 
         [Fact(DisplayName = "Comparison sources have their type set correctly")]
         public void ComparisonSourcesHaveCorrectType()
@@ -400,7 +403,9 @@ private static IEnumerable<AttributeComparison> AttributeNameMatcher(IDiffContex
             foreach (var ctrlAttrSrc in controlAttrs)
             {
                 if (testAttrs.Contains(ctrlAttrSrc.Attribute.Name))
+                {
                     yield return new AttributeComparison(ctrlAttrSrc, testAttrs[ctrlAttrSrc.Attribute.Name]);
+                }
             }
         }
 
diff --git a/src/AngleSharp.Diffing.Tests/Core/SourceCollectionTest.cs b/src/AngleSharp.Diffing.Tests/Core/SourceCollectionTest.cs
index 82de674..2109c9a 100644
--- a/src/AngleSharp.Diffing.Tests/Core/SourceCollectionTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Core/SourceCollectionTest.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Linq;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Core
diff --git a/src/AngleSharp.Diffing.Tests/Core/SourceMapTest.cs b/src/AngleSharp.Diffing.Tests/Core/SourceMapTest.cs
index 6a2344e..4ad690c 100644
--- a/src/AngleSharp.Diffing.Tests/Core/SourceMapTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Core/SourceMapTest.cs
@@ -1,6 +1,8 @@
 using System;
 using System.Linq;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Core
diff --git a/src/AngleSharp.Diffing.Tests/DiffBuilderTest.cs b/src/AngleSharp.Diffing.Tests/DiffBuilderTest.cs
index 984211f..8d973c2 100644
--- a/src/AngleSharp.Diffing.Tests/DiffBuilderTest.cs
+++ b/src/AngleSharp.Diffing.Tests/DiffBuilderTest.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Linq;
+
 using AngleSharp.Diffing.Core;
-using AngleSharp.Diffing.Strategies;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing
diff --git a/src/AngleSharp.Diffing.Tests/DiffingTestBase.cs b/src/AngleSharp.Diffing.Tests/DiffingTestBase.cs
index c0c0d0d..7c5150d 100644
--- a/src/AngleSharp.Diffing.Tests/DiffingTestBase.cs
+++ b/src/AngleSharp.Diffing.Tests/DiffingTestBase.cs
@@ -1,8 +1,8 @@
 using System.Collections.Generic;
-using AngleSharp;
-using AngleSharp.Dom;
-using AngleSharp.Html.Parser;
+
 using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
+
 using Xunit;
 
 namespace AngleSharp.Diffing
diff --git a/src/AngleSharp.Diffing.Tests/DiffingTestFixture.cs b/src/AngleSharp.Diffing.Tests/DiffingTestFixture.cs
index ab9c454..afe756f 100644
--- a/src/AngleSharp.Diffing.Tests/DiffingTestFixture.cs
+++ b/src/AngleSharp.Diffing.Tests/DiffingTestFixture.cs
@@ -1,5 +1,4 @@
-using AngleSharp;
-using AngleSharp.Dom;
+using AngleSharp.Dom;
 using AngleSharp.Html.Parser;
 
 namespace AngleSharp.Diffing
diff --git a/src/AngleSharp.Diffing.Tests/ShouldlyTestExtensions.cs b/src/AngleSharp.Diffing.Tests/ShouldlyTestExtensions.cs
index 07a9761..c0d9891 100644
--- a/src/AngleSharp.Diffing.Tests/ShouldlyTestExtensions.cs
+++ b/src/AngleSharp.Diffing.Tests/ShouldlyTestExtensions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+
 using Shouldly;
 
 namespace AngleSharp.Diffing
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeComparerTest.cs
index dd5dcab..86feb93 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeComparerTest.cs
@@ -1,5 +1,7 @@
 using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeNameMatcherTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeNameMatcherTest.cs
index 9a81657..1a12bdf 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeNameMatcherTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/AttributeNameMatcherTest.cs
@@ -1,12 +1,10 @@
-using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+
 using AngleSharp.Diffing;
 using AngleSharp.Diffing.Core;
-using AngleSharp.Dom;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/BooleanAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/BooleanAttributeComparerTest.cs
index e7a6721..f42201e 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/BooleanAttributeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/BooleanAttributeComparerTest.cs
@@ -1,7 +1,10 @@
-using AngleSharp.Diffing.Core;
-using Shouldly;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
+
+using AngleSharp.Diffing.Core;
+
+using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/ClassAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/ClassAttributeComparerTest.cs
index 07e90be..2958a7d 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/ClassAttributeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/ClassAttributeComparerTest.cs
@@ -1,5 +1,7 @@
 using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreAttributeComparerTest.cs
index 3950efe..dd8a01e 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreAttributeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreAttributeComparerTest.cs
@@ -1,6 +1,8 @@
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Strategies.AttributeStrategies;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.IgnoreStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreDiffAttributesFilterTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreDiffAttributesFilterTest.cs
index 2ed4117..209d9f2 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreDiffAttributesFilterTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/IgnoreDiffAttributesFilterTest.cs
@@ -1,5 +1,7 @@
 using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/PostfixedAttributeMatcherTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/PostfixedAttributeMatcherTest.cs
index b594c82..f5eed79 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/PostfixedAttributeMatcherTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/PostfixedAttributeMatcherTest.cs
@@ -1,8 +1,10 @@
 using System.Collections.Generic;
 using System.Linq;
+
 using AngleSharp.Diffing.Core;
-using AngleSharp.Dom;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/StyleAttributeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/StyleAttributeComparerTest.cs
index ae183ca..320f781 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/StyleAttributeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/AttributeStrategies/StyleAttributeComparerTest.cs
@@ -1,10 +1,7 @@
 using AngleSharp.Diffing.Core;
+
 using Shouldly;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/CommentStrategies/IgnoreCommentsFilterTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/CommentStrategies/IgnoreCommentsFilterTest.cs
index 7a876dd..c35ccef 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/CommentStrategies/IgnoreCommentsFilterTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/CommentStrategies/IgnoreCommentsFilterTest.cs
@@ -1,5 +1,7 @@
 using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.CommentStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/DiffingStrategyPipelineTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/DiffingStrategyPipelineTest.cs
index 3eb427c..a1dc1c1 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/DiffingStrategyPipelineTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/DiffingStrategyPipelineTest.cs
@@ -1,8 +1,10 @@
 using System;
 using System.Linq;
+
 using AngleSharp.Diffing.Core;
-using AngleSharp.Dom;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies
@@ -37,10 +39,10 @@ public void Test001(FilterDecision expected)
         {
             var sut = new DiffingStrategyPipeline();
 
-            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), isSpecializedFilter: true);
-            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => expected, isSpecializedFilter: true);
-            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), isSpecializedFilter: true);
-            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => expected, isSpecializedFilter: true);
+            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), StrategyType.Specialized);
+            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => expected, StrategyType.Specialized);
+            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), StrategyType.Specialized);
+            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => expected, StrategyType.Specialized);
 
             sut.Filter(new ComparisonSource()).ShouldBe(expected);
             sut.Filter(new AttributeComparisonSource()).ShouldBe(expected);
@@ -53,10 +55,10 @@ public void Test002(FilterDecision expected)
         {
             var sut = new DiffingStrategyPipeline();
 
-            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => expected, isSpecializedFilter: false);
-            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), isSpecializedFilter: false);
-            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => expected, isSpecializedFilter: false);
-            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), isSpecializedFilter: false);
+            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => expected, StrategyType.Generalized);
+            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), StrategyType.Generalized);
+            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => expected, StrategyType.Generalized);
+            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), StrategyType.Generalized);
 
             sut.Filter(new ComparisonSource()).ShouldBe(expected);
             sut.Filter(new AttributeComparisonSource()).ShouldBe(expected);
@@ -69,10 +71,10 @@ public void Test003(FilterDecision expected)
         {
             var sut = new DiffingStrategyPipeline();
 
-            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => expected, isSpecializedFilter: true);
-            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), isSpecializedFilter: false);
-            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => expected, isSpecializedFilter: true);
-            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), isSpecializedFilter: false);
+            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => expected, StrategyType.Specialized);
+            sut.AddFilter((in ComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), StrategyType.Generalized);
+            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => expected, StrategyType.Specialized);
+            sut.AddFilter((in AttributeComparisonSource s, FilterDecision currentDecision) => NegateDecision(expected), StrategyType.Generalized);
 
             sut.Filter(new ComparisonSource()).ShouldBe(expected);
             sut.Filter(new AttributeComparisonSource()).ShouldBe(expected);
@@ -96,8 +98,8 @@ public void Test61()
         {
             var sourceColllection = ToSourceCollection("<p></p><span></span>", ComparisonSourceType.Control);
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, isSpecializedMatcher: true);
-            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[1], t[1]) }, isSpecializedMatcher: true);
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, StrategyType.Specialized);
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[1], t[1]) }, StrategyType.Specialized);
 
             var result = sut.Match(DummyContext, sourceColllection, sourceColllection).ToList();
 
@@ -110,8 +112,8 @@ public void Test71()
         {
             var sourceMap = ToSourceMap(@"<p foo=""bar"" baz=""bum""></p>");
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, isSpecializedMatcher: true);
-            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["baz"], t["baz"]) }, isSpecializedMatcher: true);
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, StrategyType.Specialized);
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["baz"], t["baz"]) }, StrategyType.Specialized);
 
             var result = sut.Match(DummyContext, sourceMap, sourceMap).ToList();
 
@@ -124,8 +126,8 @@ public void Test62()
         {
             var sourceColllection = ToSourceCollection("<p></p><span></span>", ComparisonSourceType.Control);
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, isSpecializedMatcher: false);
-            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[1], t[1]) }, isSpecializedMatcher: false);
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, StrategyType.Generalized);
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[1], t[1]) }, StrategyType.Generalized);
 
             var result = sut.Match(DummyContext, sourceColllection, sourceColllection).ToList();
 
@@ -138,8 +140,8 @@ public void Test72()
         {
             var sourceMap = ToSourceMap(@"<p foo=""bar"" baz=""bum""></p>");
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, isSpecializedMatcher: false);
-            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["baz"], t["baz"]) }, isSpecializedMatcher: false);
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, StrategyType.Generalized);
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["baz"], t["baz"]) }, StrategyType.Generalized);
 
             var result = sut.Match(DummyContext, sourceMap, sourceMap).ToList();
 
@@ -152,8 +154,8 @@ public void Test62123()
         {
             var sourceColllection = ToSourceCollection("<p></p><span></span>", ComparisonSourceType.Control);
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, isSpecializedMatcher: false);
-            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[1], t[1]) }, isSpecializedMatcher: true);
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, StrategyType.Generalized);
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[1], t[1]) }, StrategyType.Specialized);
 
             var result = sut.Match(DummyContext, sourceColllection, sourceColllection).ToList();
 
@@ -166,8 +168,8 @@ public void Test74342()
         {
             var sourceMap = ToSourceMap(@"<p foo=""bar"" baz=""bum""></p>");
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, isSpecializedMatcher: false);
-            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["baz"], t["baz"]) }, isSpecializedMatcher: true);
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, StrategyType.Generalized);
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["baz"], t["baz"]) }, StrategyType.Specialized);
 
             var result = sut.Match(DummyContext, sourceMap, sourceMap).ToList();
 
@@ -192,10 +194,10 @@ public void Test8(CompareResult first, CompareResult final)
         {
             var sut = new DiffingStrategyPipeline();
 
-            sut.AddComparer((in Comparison c, CompareResult current) => first, isSpecializedComparer: true);
-            sut.AddComparer((in Comparison c, CompareResult current) => final, isSpecializedComparer: true);
-            sut.AddComparer((in AttributeComparison c, CompareResult current) => first, isSpecializedComparer: true);
-            sut.AddComparer((in AttributeComparison c, CompareResult current) => final, isSpecializedComparer: true);
+            sut.AddComparer((in Comparison c, CompareResult current) => first, StrategyType.Specialized);
+            sut.AddComparer((in Comparison c, CompareResult current) => final, StrategyType.Specialized);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => first, StrategyType.Specialized);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => final, StrategyType.Specialized);
 
             sut.Compare(new Comparison()).ShouldBe(final);
             sut.Compare(new AttributeComparison()).ShouldBe(final);
@@ -208,10 +210,10 @@ public void Test12321(CompareResult first, CompareResult final)
         {
             var sut = new DiffingStrategyPipeline();
 
-            sut.AddComparer((in Comparison c, CompareResult current) => final, isSpecializedComparer: false);
-            sut.AddComparer((in Comparison c, CompareResult current) => first, isSpecializedComparer: false);
-            sut.AddComparer((in AttributeComparison c, CompareResult current) => final, isSpecializedComparer: false);
-            sut.AddComparer((in AttributeComparison c, CompareResult current) => first, isSpecializedComparer: false);
+            sut.AddComparer((in Comparison c, CompareResult current) => final, StrategyType.Generalized);
+            sut.AddComparer((in Comparison c, CompareResult current) => first, StrategyType.Generalized);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => final, StrategyType.Generalized);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => first, StrategyType.Generalized);
 
             sut.Compare(new Comparison()).ShouldBe(final);
             sut.Compare(new AttributeComparison()).ShouldBe(final);
@@ -224,10 +226,10 @@ public void Test8314(CompareResult first, CompareResult final)
         {
             var sut = new DiffingStrategyPipeline();
 
-            sut.AddComparer((in Comparison c, CompareResult current) => first, isSpecializedComparer: false);
-            sut.AddComparer((in Comparison c, CompareResult current) => final, isSpecializedComparer: true);
-            sut.AddComparer((in AttributeComparison c, CompareResult current) => first, isSpecializedComparer: false);
-            sut.AddComparer((in AttributeComparison c, CompareResult current) => final, isSpecializedComparer: true);
+            sut.AddComparer((in Comparison c, CompareResult current) => first, StrategyType.Generalized);
+            sut.AddComparer((in Comparison c, CompareResult current) => final, StrategyType.Specialized);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => first, StrategyType.Generalized);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => final, StrategyType.Specialized);
 
             sut.Compare(new Comparison()).ShouldBe(final);
             sut.Compare(new AttributeComparison()).ShouldBe(final);
@@ -239,7 +241,7 @@ public void Test101()
             var controlSources = ToSourceCollection("<p></p>", ComparisonSourceType.Control);
             var testSources = ToSourceCollection("<p></p>", ComparisonSourceType.Test);
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, isSpecializedMatcher: true);
+            sut.AddMatcher((ctx, s, t) => new[] { new Comparison(s[0], t[0]) }, StrategyType.Specialized);
 
             var result = sut.Match(DummyContext, controlSources, testSources).ToList();
 
@@ -253,7 +255,7 @@ public void Test102()
             var controlSources = ToSourceMap(@"<p foo=""bar""></p>", ComparisonSourceType.Control);
             var testSources = ToSourceMap(@"<p foo=""bar""></p>", ComparisonSourceType.Test);
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, isSpecializedMatcher: true);
+            sut.AddMatcher((ctx, s, t) => new[] { new AttributeComparison(s["foo"], t["foo"]) }, StrategyType.Specialized);
 
             var result = sut.Match(DummyContext, controlSources, testSources).ToList();
 
@@ -272,11 +274,11 @@ public void Test201()
         public void Test202()
         {
             var sutWithAttrMatcher = new DiffingStrategyPipeline();
-            sutWithAttrMatcher.AddMatcher((ctx, s, t) => Array.Empty<AttributeComparison>(), false);
+            sutWithAttrMatcher.AddMatcher((ctx, s, t) => Array.Empty<AttributeComparison>(), StrategyType.Generalized);
             sutWithAttrMatcher.HasMatchers.ShouldBeFalse();
 
             var sutWithNodeMatcher = new DiffingStrategyPipeline();
-            sutWithNodeMatcher.AddMatcher((ctx, s, t) => Array.Empty<Comparison>(), false);
+            sutWithNodeMatcher.AddMatcher((ctx, s, t) => Array.Empty<Comparison>(), StrategyType.Generalized);
             sutWithNodeMatcher.HasMatchers.ShouldBeFalse();
         }
 
@@ -284,8 +286,8 @@ public void Test202()
         public void Test203()
         {
             var sut = new DiffingStrategyPipeline();
-            sut.AddMatcher((ctx, s, t) => Array.Empty<AttributeComparison>(), false);
-            sut.AddMatcher((ctx, s, t) => Array.Empty<Comparison>(), false);
+            sut.AddMatcher((ctx, s, t) => Array.Empty<AttributeComparison>(), StrategyType.Generalized);
+            sut.AddMatcher((ctx, s, t) => Array.Empty<Comparison>(), StrategyType.Generalized);
             sut.HasMatchers.ShouldBeTrue();
         }
 
@@ -300,11 +302,11 @@ public void Test301()
         public void Test302()
         {
             var sutWithAttrComparer = new DiffingStrategyPipeline();
-            sutWithAttrComparer.AddComparer((in AttributeComparison c, CompareResult current) => current, isSpecializedComparer: false);
+            sutWithAttrComparer.AddComparer((in AttributeComparison c, CompareResult current) => current, StrategyType.Generalized);
             sutWithAttrComparer.HasComparers.ShouldBeFalse();
 
             var sutWithNodeComparer = new DiffingStrategyPipeline();
-            sutWithNodeComparer.AddComparer((in Comparison c, CompareResult current) => current, isSpecializedComparer: false);
+            sutWithNodeComparer.AddComparer((in Comparison c, CompareResult current) => current, StrategyType.Generalized);
             sutWithNodeComparer.HasComparers.ShouldBeFalse();
         }
 
@@ -312,8 +314,8 @@ public void Test302()
         public void Test303()
         {
             var sut = new DiffingStrategyPipeline();
-            sut.AddComparer((in AttributeComparison c, CompareResult current) => current, isSpecializedComparer: false);
-            sut.AddComparer((in Comparison c, CompareResult current) => current, isSpecializedComparer: false);
+            sut.AddComparer((in AttributeComparison c, CompareResult current) => current, StrategyType.Generalized);
+            sut.AddComparer((in Comparison c, CompareResult current) => current, StrategyType.Generalized);
             sut.HasComparers.ShouldBeTrue();
         }
     }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/CssSelectorElementMatcherTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/CssSelectorElementMatcherTest.cs
index 42a812c..d700701 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/CssSelectorElementMatcherTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/CssSelectorElementMatcherTest.cs
@@ -1,12 +1,10 @@
-using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Core;
-using AngleSharp.Diffing.Strategies.NodeStrategies;
+using AngleSharp.Dom;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.ElementStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreElementComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreElementComparerTest.cs
index f947cbd..c905ef0 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreElementComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/ElementStrategies/IgnoreElementComparerTest.cs
@@ -1,5 +1,7 @@
-using AngleSharp.Diffing.Core;
+using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.ElementStrategies
@@ -33,6 +35,7 @@ public void Test002(string controlHtml)
         {
             var comparison = ToComparison(controlHtml, "<p></p>");
 
+            IgnoreElementComparer.Compare(comparison, CompareResult.Same).ShouldBe(CompareResult.Skip);
             IgnoreElementComparer.Compare(comparison, CompareResult.Different).ShouldBe(CompareResult.Skip);
         }
     }
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/ForwardSearchingNodeMatcherTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/ForwardSearchingNodeMatcherTest.cs
index 29afbd7..8e63e6e 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/ForwardSearchingNodeMatcherTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/ForwardSearchingNodeMatcherTest.cs
@@ -1,7 +1,10 @@
 using System.Linq;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.NodeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/NodeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/NodeComparerTest.cs
index 56216b4..dc6b3e2 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/NodeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/NodeComparerTest.cs
@@ -1,6 +1,8 @@
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Strategies.ElementStrategies;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.NodeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/OneToOneNodeMatcherTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/OneToOneNodeMatcherTest.cs
index 767aeaa..2dc8148 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/OneToOneNodeMatcherTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/NodeStrategies/OneToOneNodeMatcherTest.cs
@@ -1,8 +1,10 @@
 using System.Linq;
+
 using AngleSharp.Diffing.Core;
-using Xunit;
+
 using Shouldly;
-using AngleSharp.Dom;
+
+using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.NodeStrategies
 {
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/StyleSheetTextNodeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/StyleSheetTextNodeComparerTest.cs
index 575c479..5ab2e27 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/StyleSheetTextNodeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/StyleSheetTextNodeComparerTest.cs
@@ -1,10 +1,7 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using AngleSharp.Diffing.Core;
+using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.TextNodeStrategies
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeComparerTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeComparerTest.cs
index 5cb4542..0cbc178 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeComparerTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeComparerTest.cs
@@ -1,5 +1,7 @@
 using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.TextNodeStrategies
@@ -51,8 +53,8 @@ public void Test7(string whitespace)
             var sut = new TextNodeComparer(WhitespaceOption.Normalize);
             var normalText = "text";
             var whitespaceText = $"{whitespace}text{whitespace}";
-            var c1 = ToComparison(normalText    , normalText);
-            var c2 = ToComparison(normalText    , whitespaceText);
+            var c1 = ToComparison(normalText, normalText);
+            var c2 = ToComparison(normalText, whitespaceText);
             var c3 = ToComparison(whitespaceText, normalText);
             var c4 = ToComparison(whitespaceText, whitespaceText);
 
diff --git a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeFilterTest.cs b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeFilterTest.cs
index d610838..491b9df 100644
--- a/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeFilterTest.cs
+++ b/src/AngleSharp.Diffing.Tests/Strategies/TextNodeStrategies/TextNodeFilterTest.cs
@@ -1,5 +1,7 @@
-using AngleSharp.Diffing.Core;
+using AngleSharp.Diffing.Core;
+
 using Shouldly;
+
 using Xunit;
 
 namespace AngleSharp.Diffing.Strategies.TextNodeStrategies
@@ -53,21 +55,27 @@ public void Test4x(string html)
             sut.Filter(source, FilterDecision.Exclude).ShouldBe(FilterDecision.Exclude);
         }
 
-        [Fact(DisplayName = "If parent node is <pre> element, the implicit option is Preserved")]
-        public void Test5()
+        [Theory(DisplayName = "If parent node is <pre>, <script>, or <style> element, the implicit option is Preserved")]
+        [InlineData("pre")]
+        [InlineData("style")]
+        [InlineData("script")]
+        public void Test5(string tag)
         {
             var sut = new TextNodeFilter(WhitespaceOption.Normalize);
-            var pre = ToComparisonSource("<pre> \n\t </pre>");
+            var pre = ToComparisonSource($"<{tag}> \n\t </{tag}>");
             var source = new ComparisonSource(pre.Node.FirstChild, 0, pre.Path, ComparisonSourceType.Control);
 
             sut.Filter(source, FilterDecision.Keep).ShouldBe(FilterDecision.Keep);
         }
 
-        [Fact(DisplayName = "If parent node is <pre> element with a diff:whitespace, the option is take from the attribute")]
-        public void Test51()
+        [Theory(DisplayName = "If parent node is <pre>, <script>, or <style> element with a diff:whitespace, the option is take from the attribute")]
+        [InlineData("pre")]
+        [InlineData("style")]
+        [InlineData("script")]
+        public void Test51(string tag)
         {
             var sut = new TextNodeFilter(WhitespaceOption.Normalize);
-            var pre = ToComparisonSource("<pre diff:whitespace=\"RemoveWhitespaceNodes\"> \n\t </pre>");
+            var pre = ToComparisonSource($"<{tag} diff:whitespace=\"RemoveWhitespaceNodes\"> \n\t </{tag}>");
             var source = new ComparisonSource(pre.Node.FirstChild, 0, pre.Path, ComparisonSourceType.Control);
 
             sut.Filter(source, FilterDecision.Keep).ShouldBe(FilterDecision.Exclude);
diff --git a/src/AngleSharp.Diffing.sln b/src/AngleSharp.Diffing.sln
index 697ede5..c93f6cd 100644
--- a/src/AngleSharp.Diffing.sln
+++ b/src/AngleSharp.Diffing.sln
@@ -15,11 +15,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		..\build.ps1 = ..\build.ps1
 		..\CHANGELOG.md = ..\CHANGELOG.md
 		Directory.Build.props = Directory.Build.props
-	EndProjectSection
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{166F21F6-7277-4948-830B-59FA32F8A74D}"
-	ProjectSection(SolutionItems) = preProject
-		..\CHANGELOG.md = ..\CHANGELOG.md
 		..\README.md = ..\README.md
 	EndProjectSection
 EndProject
diff --git a/src/AngleSharp.Diffing/AngleSharp.Diffing.csproj b/src/AngleSharp.Diffing/AngleSharp.Diffing.csproj
index a2e7a38..63ece10 100644
--- a/src/AngleSharp.Diffing/AngleSharp.Diffing.csproj
+++ b/src/AngleSharp.Diffing/AngleSharp.Diffing.csproj
@@ -4,7 +4,7 @@
     <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(Configuration)'=='Release'">
+  <PropertyGroup>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
 
diff --git a/src/AngleSharp.Diffing/Core/AttributeComparison.cs b/src/AngleSharp.Diffing/Core/AttributeComparison.cs
index 586ded7..64811dc 100644
--- a/src/AngleSharp.Diffing/Core/AttributeComparison.cs
+++ b/src/AngleSharp.Diffing/Core/AttributeComparison.cs
@@ -1,6 +1,7 @@
-using AngleSharp.Dom;
 using System;
 
+using AngleSharp.Dom;
+
 namespace AngleSharp.Diffing.Core
 {
     /// <summary>
@@ -36,13 +37,16 @@ public AttributeComparison(in AttributeComparisonSource control, in AttributeCom
             => ((IElement)Control.ElementSource.Node, (IElement)Test.ElementSource.Node);
 
         #region Equals and HashCode
-        #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+        /// <inheritdoc/>
         public bool Equals(AttributeComparison other) => Control.Equals(other.Control) && Test.Equals(other.Test);
+        /// <inheritdoc/>
         public override bool Equals(object? obj) => obj is AttributeComparison other && Equals(other);
+        /// <inheritdoc/>
         public override int GetHashCode() => (Control, Test).GetHashCode();
+        /// <inheritdoc/>
         public static bool operator ==(AttributeComparison left, AttributeComparison right) => left.Equals(right);
+        /// <inheritdoc/>
         public static bool operator !=(AttributeComparison left, AttributeComparison right) => !left.Equals(right);
-        #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
         #endregion
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/AttributeComparisonSource.cs b/src/AngleSharp.Diffing/Core/AttributeComparisonSource.cs
index 469162f..88450d9 100644
--- a/src/AngleSharp.Diffing/Core/AttributeComparisonSource.cs
+++ b/src/AngleSharp.Diffing/Core/AttributeComparisonSource.cs
@@ -1,10 +1,14 @@
-using AngleSharp.Dom;
-using AngleSharp.Diffing.Extensions;
 using System;
 using System.Diagnostics.CodeAnalysis;
 
+using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
+
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents an attribute that can be a source in a comparison.
+    /// </summary>
     public readonly struct AttributeComparisonSource : IEquatable<AttributeComparisonSource>, IComparisonSource
     {
         /// <summary>
@@ -27,10 +31,16 @@ namespace AngleSharp.Diffing.Core
         /// </summary>
         public ComparisonSourceType SourceType { get; }
 
+        /// <summary>
+        /// Creates an instance of the <see cref="AttributeComparisonSource"/>.
+        /// </summary>
+        /// <param name="attributeName">Name of the attribute.</param>
+        /// <param name="elementSource">The source of the element the attribute belongs to.</param>
         [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
         public AttributeComparisonSource(string attributeName, in ComparisonSource elementSource)
         {
-            if (string.IsNullOrEmpty(attributeName)) throw new ArgumentNullException(nameof(attributeName));
+            if (string.IsNullOrEmpty(attributeName))
+                throw new ArgumentNullException(nameof(attributeName));
             if (!elementSource.Node.TryGetAttr(attributeName, out var attribute))
                 throw new ArgumentException("The comparison source does not contain an element or the specified attribute is missing on the element.", nameof(elementSource));
 
@@ -41,13 +51,16 @@ public AttributeComparisonSource(string attributeName, in ComparisonSource eleme
         }
 
         #region Equals and HashCode
-#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+        /// <inheritdoc/>
         public bool Equals(AttributeComparisonSource other) => Object.ReferenceEquals(Attribute, other.Attribute) && Path.Equals(other.Path, StringComparison.Ordinal) && ElementSource.Equals(other.ElementSource);
+        /// <inheritdoc/>
         public override int GetHashCode() => (Attribute, ElementSource).GetHashCode();
+        /// <inheritdoc/>
         public override bool Equals(object? obj) => obj is AttributeComparisonSource other && Equals(other);
+        /// <inheritdoc/>
         public static bool operator ==(AttributeComparisonSource left, AttributeComparisonSource right) => left.Equals(right);
+        /// <inheritdoc/>
         public static bool operator !=(AttributeComparisonSource left, AttributeComparisonSource right) => !left.Equals(right);
-#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
         #endregion
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/CompareResult.cs b/src/AngleSharp.Diffing/Core/CompareResult.cs
index a7d5031..4ec46ea 100644
--- a/src/AngleSharp.Diffing/Core/CompareResult.cs
+++ b/src/AngleSharp.Diffing/Core/CompareResult.cs
@@ -1,5 +1,8 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a result of a comparison.
+    /// </summary>
     public enum CompareResult
     {
         /// <summary>
@@ -16,8 +19,15 @@ public enum CompareResult
         Skip
     }
 
+    /// <summary>
+    /// Helper methods for <see cref="CompareResult"/>
+    /// </summary>
     public static class CompareResultExtensions
     {
+        /// <summary>
+        /// Checks if a <see cref="CompareResult"/> is either a <see cref="CompareResult.Same"/> or <see cref="CompareResult.Skip"/>.
+        /// </summary>
+        /// <param name="compareResult">The compare result</param>
         public static bool IsSameOrSkip(this CompareResult compareResult) => compareResult == CompareResult.Same || compareResult == CompareResult.Skip;
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/Comparison.cs b/src/AngleSharp.Diffing/Core/Comparison.cs
index 59cd2b3..554fc2e 100644
--- a/src/AngleSharp.Diffing/Core/Comparison.cs
+++ b/src/AngleSharp.Diffing/Core/Comparison.cs
@@ -1,7 +1,8 @@
 using System;
-using AngleSharp.Dom;
-using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Core
 {
@@ -11,18 +12,38 @@ namespace AngleSharp.Diffing.Core
     [DebuggerDisplay("Control: {Control.Path} | Test: {Test.Path}")]
     public readonly struct Comparison : IEquatable<Comparison>
     {
+        /// <summary>
+        /// Gets the control source in the comparison.
+        /// </summary>
         public ComparisonSource Control { get; }
 
+        /// <summary>
+        /// Gets the test source in the comparison
+        /// </summary>
         public ComparisonSource Test { get; }
 
+        /// <summary>
+        /// Gets whether the control and test nodes are of the same type and has the same name.
+        /// </summary>
+        public bool AreNodeTypesEqual => Control.Node.NodeType == Test.Node.NodeType && Control.Node.NodeName == Test.Node.NodeName;
+
+        /// <summary>
+        /// Creates a new comparison.
+        /// </summary>
+        /// <param name="control">The control source in the comparison.</param>
+        /// <param name="test">The tes tsource in the comparison.</param>
         public Comparison(in ComparisonSource control, in ComparisonSource test)
         {
             Control = control;
             Test = test;
         }
 
-        public bool AreNodeTypesEqual() => Control.Node.NodeType == Test.Node.NodeType && Control.Node.NodeName == Test.Node.NodeName;
-
+        /// <summary>
+        /// Try to get the control and test node as the <typeparamref name="TNode"/> type.
+        /// Returns true if both test and control node is of type <typeparamref name="TNode"/>, false otherwise.
+        /// </summary>
+        /// <typeparam name="TNode">THe type of node to try to retrieve.</typeparam>
+        /// <returns>Returns true if both test and control node is of type <typeparamref name="TNode"/>, false otherwise.</returns>
         public bool TryGetNodesAsType<TNode>([NotNullWhen(true)]out TNode? controlNode, [NotNullWhen(true)]out TNode? testNode) where TNode : class, INode
         {
             if (Control.Node is TNode ctrl && Test.Node is TNode test)
@@ -40,13 +61,16 @@ public bool TryGetNodesAsType<TNode>([NotNullWhen(true)]out TNode? controlNode,
         }
 
         #region Equals and HashCode
-        #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+        /// <inheritdoc/>
         public bool Equals(Comparison other) => Control.Equals(other.Control) && Test.Equals(other.Test);
+        /// <inheritdoc/>
         public override bool Equals(object? obj) => obj is Comparison other && Equals(other);
+        /// <inheritdoc/>
         public override int GetHashCode() => (Control, Test).GetHashCode();
+        /// <inheritdoc/>
         public static bool operator ==(Comparison left, Comparison right) => left.Equals(right);
+        /// <inheritdoc/>
         public static bool operator !=(Comparison left, Comparison right) => !left.Equals(right);
-        #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
         #endregion
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/ComparisonSource.cs b/src/AngleSharp.Diffing/Core/ComparisonSource.cs
index 2211a84..eb08bc4 100644
--- a/src/AngleSharp.Diffing/Core/ComparisonSource.cs
+++ b/src/AngleSharp.Diffing/Core/ComparisonSource.cs
@@ -1,34 +1,61 @@
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using AngleSharp.Dom;
-using AngleSharp.Diffing.Extensions;
 using System.Linq;
 
+using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
+
 namespace AngleSharp.Diffing.Core
 {
-    [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
+    /// <summary>
+    /// Represents a node source in a comparison.
+    /// </summary>    
     [DebuggerDisplay("{Index} : {Path}")]
     public readonly struct ComparisonSource : IEquatable<ComparisonSource>, IComparisonSource
     {
         private readonly int _hashCode;
 
+        /// <summary>
+        /// Gets the character used as a separator in paths.
+        /// </summary>
         public const char PathSeparatorChar = '>';
 
+        /// <summary>
+        /// Gets the node represented by the source.
+        /// </summary>
         public INode Node { get; }
 
+        /// <summary>
+        /// Gets the node's absolute index/position in the DOM tree.
+        /// </summary>
         public int Index { get; }
 
+        /// <inheritdoc/>
         public string Path { get; }
 
+        /// <inheritdoc/>
         public ComparisonSourceType SourceType { get; }
 
+        /// <summary>
+        /// Creates a <see cref="ComparisonSource"/>.
+        /// </summary>
+        /// <param name="node">The node of the source.</param>
+        /// <param name="sourceType">The source type.</param>
         public ComparisonSource(INode node, ComparisonSourceType sourceType)
             : this(node, GetNodeIndex(node), CalculateParentPath(node), sourceType) { }
 
+        /// <summary>
+        /// Creates a <see cref="ComparisonSource"/>.
+        /// </summary>
+        /// <param name="node">The node of the source.</param>
+        /// <param name="index">The node's absolute index/position in the DOM tree</param>
+        /// <param name="parentsPath">The path to the parent node in the DOM tree.</param>
+        /// <param name="sourceType">The source type.</param>
         public ComparisonSource(INode node, int index, string parentsPath, ComparisonSourceType sourceType)
         {
-            if (node is null) throw new ArgumentNullException(nameof(node));
+            if (node is null)
+                throw new ArgumentNullException(nameof(node));
 
             var pathSegment = GetNodePathSegment(node);
             Node = node;
@@ -41,6 +68,30 @@ public ComparisonSource(INode node, int index, string parentsPath, ComparisonSou
             _hashCode = (Node, Index, Path, SourceType).GetHashCode();
         }
 
+        /// <summary>
+        /// Create the last part of the node's path.
+        /// </summary>
+        /// <param name="node"></param>
+        /// <returns></returns>
+        [SuppressMessage("Globalization", "CA1308:Normalize strings to uppercase", Justification = "Path should be in lower case")]
+        public static string GetNodePathSegment(INode node)
+        {
+            var index = GetPathIndex(node);
+            return $"{node.NodeName.ToLowerInvariant()}({index})";
+        }
+
+        /// <summary>
+        /// Combines a parent path with a path segment.
+        /// </summary>
+        public static string CombinePath(string parentPath, string path)
+        {
+            if (string.IsNullOrWhiteSpace(parentPath))
+                return path;
+            if (string.IsNullOrWhiteSpace(path))
+                return parentPath;
+            return $"{parentPath} {PathSeparatorChar} {path}";
+        }
+
         private static int GetNodeIndex(INode node)
         {
             if (node.TryGetNodeIndex(out var index))
@@ -74,32 +125,22 @@ private static int GetPathIndex(INode node)
             {
                 if (ReferenceEquals(childNodes[index], node))
                     return result;
-                if(childNodes[index] is IParentNode)
+                if (childNodes[index] is IParentNode)
                     result += 1;
             }
             throw new InvalidOperationException("Unexpected node tree state. The node was not found in its parents child nodes collection.");
         }
 
-        public static string GetNodePathSegment(INode node)
-        {
-            var index = GetPathIndex(node);
-            return $"{node.NodeName.ToLowerInvariant()}({index})";
-        }
-
-        public static string CombinePath(string parentPath, string path)
-        {
-            if(string.IsNullOrWhiteSpace(parentPath))
-                return path;
-            if(string.IsNullOrWhiteSpace(path))
-                return parentPath;
-            return $"{parentPath} {PathSeparatorChar} {path}";
-        }
-
         #region Equals and HashCode
+        /// <inheritdoc/>
         public bool Equals(ComparisonSource other) => Object.ReferenceEquals(Node, other.Node) && Index == other.Index && Path.Equals(other.Path, StringComparison.Ordinal) && SourceType == other.SourceType;
+        /// <inheritdoc/>
         public override int GetHashCode() => _hashCode;
+        /// <inheritdoc/>
         public override bool Equals(object? obj) => obj is ComparisonSource other && Equals(other);
+        /// <inheritdoc/>
         public static bool operator ==(ComparisonSource left, ComparisonSource right) => left.Equals(right);
+        /// <inheritdoc/>
         public static bool operator !=(ComparisonSource left, ComparisonSource right) => !left.Equals(right);
         #endregion
     }
diff --git a/src/AngleSharp.Diffing/Core/DiffContext.cs b/src/AngleSharp.Diffing/Core/DiffContext.cs
index e20e497..04e3b48 100644
--- a/src/AngleSharp.Diffing/Core/DiffContext.cs
+++ b/src/AngleSharp.Diffing/Core/DiffContext.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Core
 {
@@ -19,8 +20,10 @@ internal class DiffContext : IDiffContext
 
         public DiffContext(SourceCollection controlSources, SourceCollection testSources)
         {
-            if (controlSources.Count > 0 && controlSources[0].Node.GetRoot() is IElement r1) { _controlRoot = r1; }
-            if (testSources.Count > 0 && testSources[0].Node.GetRoot() is IElement r2) { _testRoot = r2; }
+            if (controlSources.Count > 0 && controlSources[0].Node.GetRoot() is IElement r1)
+            { _controlRoot = r1; }
+            if (testSources.Count > 0 && testSources[0].Node.GetRoot() is IElement r2)
+            { _testRoot = r2; }
         }
 
         public DiffContext(IElement? controlRoot, IElement? testRoot)
@@ -29,24 +32,30 @@ public DiffContext(IElement? controlRoot, IElement? testRoot)
             _testRoot = testRoot;
         }
 
-        public IHtmlCollection<IElement> QueryControlRoot(string selector)
+        public IHtmlCollection<IElement> QueryControlNodes(string selector)
         {
-            if (_controlRoot is null) return EmptyHtmlCollection<IElement>.Empty;
+            if (_controlRoot is null)
+                return EmptyHtmlCollection<IElement>.Empty;
             return _controlRoot.QuerySelectorAll(selector);
         }
 
-        public IHtmlCollection<IElement> QueryTestRoot(string selector)
+        public IHtmlCollection<IElement> QueryTestNodes(string selector)
         {
-            if (_testRoot is null) return EmptyHtmlCollection<IElement>.Empty;
+            if (_testRoot is null)
+                return EmptyHtmlCollection<IElement>.Empty;
             return _testRoot.QuerySelectorAll(selector);
         }
 
         internal IEnumerable<IDiff> GetDiffsFromUnmatched()
         {
-            foreach (var source in MissingSources) yield return new MissingNodeDiff(source);
-            foreach (var source in UnexpectedSources) yield return new UnexpectedNodeDiff(source);
-            foreach (var source in MissingAttributeSources) yield return new MissingAttrDiff(source);
-            foreach (var source in UnexpectedAttributeSources) yield return new UnexpectedAttrDiff(source);
+            foreach (var source in MissingSources)
+                yield return new MissingNodeDiff(source);
+            foreach (var source in UnexpectedSources)
+                yield return new UnexpectedNodeDiff(source);
+            foreach (var source in MissingAttributeSources)
+                yield return new MissingAttrDiff(source);
+            foreach (var source in UnexpectedAttributeSources)
+                yield return new UnexpectedAttrDiff(source);
         }
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/DiffResult.cs b/src/AngleSharp.Diffing/Core/DiffResult.cs
index 5e14787..5a8a922 100644
--- a/src/AngleSharp.Diffing/Core/DiffResult.cs
+++ b/src/AngleSharp.Diffing/Core/DiffResult.cs
@@ -1,10 +1,21 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents the result of a comparison.
+    /// </summary>
     public enum DiffResult
     {
-        None,
+        /// <summary>
+        /// Used when the sources in a comparison are different.
+        /// </summary>
         Different,
+        /// <summary>
+        /// Used when the test source in a comparison is missing.
+        /// </summary>
         Missing,
+        /// <summary>
+        /// Used when the test source in a comparison is was not expected.
+        /// </summary>
         Unexpected
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/DiffTarget.cs b/src/AngleSharp.Diffing/Core/DiffTarget.cs
index 748a96f..edcedc0 100644
--- a/src/AngleSharp.Diffing/Core/DiffTarget.cs
+++ b/src/AngleSharp.Diffing/Core/DiffTarget.cs
@@ -2,18 +2,46 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represent a target of a comparison.
+    /// </summary>
     public enum DiffTarget
     {
+        /// <summary>
+        /// The target is not known.
+        /// </summary>
         None,
+        /// <summary>
+        /// The target is an attribute.
+        /// </summary>
         Attribute,
+        /// <summary>
+        /// The target is a comment.
+        /// </summary>
         Comment,
+        /// <summary>
+        /// The target is an element.
+        /// </summary>
         Element,
+        /// <summary>
+        /// The target is a node.
+        /// </summary>
         Node,
+        /// <summary>
+        /// The target is a text node.
+        /// </summary>
         Text
     }
 
+    /// <summary>
+    /// Helper methods for working with <see cref="DiffTarget"/>.
+    /// </summary>
     public static class NodeTypeExtensions
     {
+        /// <summary>
+        /// Gets the diff target based on the node type.
+        /// </summary>
+        /// <param name="nodeType">Mode type to get the diff target off.</param>
         public static DiffTarget ToDiffTarget(this NodeType nodeType)
         {
             return nodeType switch
diff --git a/src/AngleSharp.Diffing/Core/Diffs/AttrDiff.cs b/src/AngleSharp.Diffing/Core/Diffs/AttrDiff.cs
index a4c5447..a345089 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/AttrDiff.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/AttrDiff.cs
@@ -2,9 +2,15 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents an attribute difference
+    /// </summary>
     [DebuggerDisplay("Attribute diff: Control = {Control.Path}, Test = {Test.Path}")]
     public class AttrDiff : DiffBase<AttributeComparisonSource>
     {
+        /// <summary>
+        /// Creates an <see cref="AttrDiff"/>.
+        /// </summary>
         public AttrDiff(in AttributeComparison comparison) : base(comparison.Control, comparison.Test, DiffTarget.Attribute)
         {
         }
diff --git a/src/AngleSharp.Diffing/Core/Diffs/DiffBase.cs b/src/AngleSharp.Diffing/Core/Diffs/DiffBase.cs
index ba0e702..2ef9034 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/DiffBase.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/DiffBase.cs
@@ -1,15 +1,30 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a difference found during comparison.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public abstract class DiffBase<T> : IDiff where T : struct
     {
+        /// <summary>
+        /// Gets the control source in the comparison.
+        /// </summary>
         public T Control { get; }
 
+        /// <summary>
+        /// Gets the test source in the comparison.
+        /// </summary>
         public T Test { get; }
 
+        /// <inheritdoc/>
         public DiffResult Result { get; }
 
+        /// <inheritdoc/>
         public DiffTarget Target { get; }
 
+        /// <summary>
+        /// Instantiate the <see cref="DiffBase{T}"/>
+        /// </summary>
         protected DiffBase(in T control, in T test, DiffTarget target)
         {
             Control = control;
diff --git a/src/AngleSharp.Diffing/Core/Diffs/MissingAttrDiff.cs b/src/AngleSharp.Diffing/Core/Diffs/MissingAttrDiff.cs
index 3e0245e..f9d56ab 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/MissingAttrDiff.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/MissingAttrDiff.cs
@@ -2,10 +2,16 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a missing attribute in a test node.
+    /// </summary>
     [DebuggerDisplay("Missing Attribute: Control = {Control.Path}")]
     public class MissingAttrDiff : MissingDiffBase<AttributeComparisonSource>
     {
-        internal MissingAttrDiff(in AttributeComparisonSource control) : base(control, DiffTarget.Attribute)
+        /// <summary>
+        /// Creates a <see cref="MissingAttrDiff"/>.
+        /// </summary>
+        public MissingAttrDiff(in AttributeComparisonSource control) : base(control, DiffTarget.Attribute)
         {
         }
     }
diff --git a/src/AngleSharp.Diffing/Core/Diffs/MissingDiffBase.cs b/src/AngleSharp.Diffing/Core/Diffs/MissingDiffBase.cs
index 787c99f..5af1090 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/MissingDiffBase.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/MissingDiffBase.cs
@@ -1,13 +1,25 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a missing node or attribute in the test DOM tree.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public abstract class MissingDiffBase<T> : IDiff where T : struct
     {
+        /// <summary>
+        /// Gets the control source that has the missing item.
+        /// </summary>
         public T Control { get; }
 
+        /// <inheritdoc/>
         public DiffResult Result { get; }
 
+        /// <inheritdoc/>
         public DiffTarget Target { get; }
 
+        /// <summary>
+        /// Create a <see cref="MissingDiffBase{T}"/>
+        /// </summary>
         protected MissingDiffBase(in T control, DiffTarget target)
         {
             Control = control;
diff --git a/src/AngleSharp.Diffing/Core/Diffs/MissingNodeDiff.cs b/src/AngleSharp.Diffing/Core/Diffs/MissingNodeDiff.cs
index 266de16..2c2c580 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/MissingNodeDiff.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/MissingNodeDiff.cs
@@ -2,9 +2,15 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a missing node in the test DOM tree.
+    /// </summary>
     [DebuggerDisplay("Missing {Target}: Control = {Control.Path}")]
     public class MissingNodeDiff : MissingDiffBase<ComparisonSource>
     {
+        /// <summary>
+        /// Creates a <see cref="MissingNodeDiff"></see>.
+        /// </summary>
         public MissingNodeDiff(in ComparisonSource control) : base(control, control.Node.NodeType.ToDiffTarget())
         {
         }
diff --git a/src/AngleSharp.Diffing/Core/Diffs/NodeDiff.cs b/src/AngleSharp.Diffing/Core/Diffs/NodeDiff.cs
index 9c7efd2..fee5fc2 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/NodeDiff.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/NodeDiff.cs
@@ -2,9 +2,15 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a difference between two nodes.
+    /// </summary>
     [DebuggerDisplay("{Target} diff: Control = {Control.Path}, Test = {Test.Path}")]
     public class NodeDiff : DiffBase<ComparisonSource>
     {
+        /// <summary>
+        /// Creates a <see cref="NodeDiff"/>.
+        /// </summary>
         public NodeDiff(in Comparison comparison) : base(comparison.Control, comparison.Test, comparison.Control.Node.NodeType.ToDiffTarget())
         {
         }
diff --git a/src/AngleSharp.Diffing/Core/Diffs/UnexpectedAttrDiff.cs b/src/AngleSharp.Diffing/Core/Diffs/UnexpectedAttrDiff.cs
index a30a926..331cb48 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/UnexpectedAttrDiff.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/UnexpectedAttrDiff.cs
@@ -2,9 +2,15 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents an unexpected attribute found in the test DOM tree.
+    /// </summary>
     [DebuggerDisplay("Unexpected Attribute: Test = {Test.Path}")]
     public class UnexpectedAttrDiff : UnexpectedDiffBase<AttributeComparisonSource>
     {
+        /// <summary>
+        /// Creates a <see cref="UnexpectedAttrDiff"/>.
+        /// </summary>
         public UnexpectedAttrDiff(in AttributeComparisonSource test) : base(test, DiffTarget.Attribute)
         {
         }
diff --git a/src/AngleSharp.Diffing/Core/Diffs/UnexpectedDiffBase.cs b/src/AngleSharp.Diffing/Core/Diffs/UnexpectedDiffBase.cs
index c164c6c..81cc4f6 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/UnexpectedDiffBase.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/UnexpectedDiffBase.cs
@@ -1,14 +1,25 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents an unexpected node or attribute in the test DOM tree.
+    /// </summary>
     public abstract class UnexpectedDiffBase<T> : IDiff where T : struct
     {
+        /// <summary>
+        /// The source of the unexpected item in the test DOM tree.
+        /// </summary>
         public T Test { get; }
 
+        /// <inheritdoc/>
         public DiffResult Result { get; }
 
+        /// <inheritdoc/>
         public DiffTarget Target { get; }
 
+        /// <summary>
+        /// Creates a <see cref="UnexpectedDiffBase{T}"/>.
+        /// </summary>
         protected UnexpectedDiffBase(in T test, DiffTarget target)
         {
             Test = test;
diff --git a/src/AngleSharp.Diffing/Core/Diffs/UnexpectedNodeDiff.cs b/src/AngleSharp.Diffing/Core/Diffs/UnexpectedNodeDiff.cs
index b7add51..f68119f 100644
--- a/src/AngleSharp.Diffing/Core/Diffs/UnexpectedNodeDiff.cs
+++ b/src/AngleSharp.Diffing/Core/Diffs/UnexpectedNodeDiff.cs
@@ -2,9 +2,15 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents an unexpected node in the test DOM tree.
+    /// </summary>
     [DebuggerDisplay("Unexpected {Target}: Test = {Test.Path}")]
     public class UnexpectedNodeDiff : UnexpectedDiffBase<ComparisonSource>
     {
+        /// <summary>
+        /// Creates a <see cref="UnexpectedNodeDiff"/>.
+        /// </summary>
         public UnexpectedNodeDiff(in ComparisonSource test) : base(test, test.Node.NodeType.ToDiffTarget())
         {
         }
diff --git a/src/AngleSharp.Diffing/Core/FilterDecision.cs b/src/AngleSharp.Diffing/Core/FilterDecision.cs
index d7b57f0..a039a6a 100644
--- a/src/AngleSharp.Diffing/Core/FilterDecision.cs
+++ b/src/AngleSharp.Diffing/Core/FilterDecision.cs
@@ -1,14 +1,33 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a filter decision made by a filter.
+    /// </summary>
     public enum FilterDecision
     {
+        /// <summary>
+        /// Indicates the node or attribute should be part of the comparison.
+        /// </summary>
         Keep = 0,
+        /// <summary>
+        /// Indicates the node or attribute should be excluded from the comparison.
+        /// </summary>
         Exclude
     }
 
+    /// <summary>
+    /// Helper methods for <see cref="FilterDecision"/>.
+    /// </summary>
     public static class FilterDecisionExtensions
     {
+        /// <summary>
+        /// Gets whether the <see cref="FilterDecision"/> is <see cref="FilterDecision.Exclude"/>.
+        /// </summary>
         public static bool IsExclude(this FilterDecision decision) => decision == FilterDecision.Exclude;
+
+        /// <summary>
+        /// Gets whether the <see cref="FilterDecision"/> is <see cref="FilterDecision.Keep"/>.
+        /// </summary>
         public static bool IsKeep(this FilterDecision decision) => decision == FilterDecision.Keep;
     }
 }
diff --git a/src/AngleSharp.Diffing/Core/HtmlDifferenceEngine.cs b/src/AngleSharp.Diffing/Core/HtmlDifferenceEngine.cs
index 3acdf93..e4b6a2d 100644
--- a/src/AngleSharp.Diffing/Core/HtmlDifferenceEngine.cs
+++ b/src/AngleSharp.Diffing/Core/HtmlDifferenceEngine.cs
@@ -1,11 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents the engine that drives the diffing/comparison of two DOM trees.
+    /// </summary>
     public class HtmlDifferenceEngine
     {
         private readonly IDiffingStrategy _diffingStrategy;
@@ -14,6 +18,9 @@ public class HtmlDifferenceEngine
 
         private DiffContext Context { get; }
 
+        /// <summary>
+        /// Creates a diffing engine which will perform a comparison of the control and test sources, using the provided strategies.
+        /// </summary>
         public HtmlDifferenceEngine(IDiffingStrategy diffingStrategy, SourceCollection controlSources, SourceCollection testSources)
         {
             _diffingStrategy = diffingStrategy ?? throw new ArgumentNullException(nameof(diffingStrategy));
@@ -22,6 +29,9 @@ public HtmlDifferenceEngine(IDiffingStrategy diffingStrategy, SourceCollection c
             Context = new DiffContext(controlSources, testSources);
         }
 
+        /// <summary>
+        /// Executes the comparison and returns any differences found.
+        /// </summary>
         public IEnumerable<IDiff> Compare()
         {
             var diffs = Compare(_controlSources, _testSources);
@@ -112,7 +122,8 @@ private IEnumerable<IDiff> CompareElement(in Comparison comparison)
 
         private IEnumerable<IDiff> CompareElementAttributes(in Comparison comparison)
         {
-            if (!comparison.Control.Node.HasAttributes() && !comparison.Test.Node.HasAttributes()) return Array.Empty<IDiff>();
+            if (!comparison.Control.Node.HasAttributes() && !comparison.Test.Node.HasAttributes())
+                return Array.Empty<IDiff>();
 
             var controlAttrs = new SourceMap(comparison.Control);
             var testAttrs = new SourceMap(comparison.Test);
diff --git a/src/AngleSharp.Diffing/Core/IComparisonSource.cs b/src/AngleSharp.Diffing/Core/IComparisonSource.cs
index d9436fe..564f32b 100644
--- a/src/AngleSharp.Diffing/Core/IComparisonSource.cs
+++ b/src/AngleSharp.Diffing/Core/IComparisonSource.cs
@@ -1,8 +1,20 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a node or attribute that can be one part of a comparison.
+    /// </summary>
     public interface IComparisonSource
     {
+        /// <summary>
+        /// Gets the path to the node or attribute. The format is similar to a
+        /// CSS selector, where the <c>(n)</c> in <c>node(n)</c> represents the items
+        /// position in the DOM tree, relative to other items.
+        /// </summary>
         string Path { get; }
+
+        /// <summary>
+        /// Gets whether the source is from the control or test DOM tree.
+        /// </summary>
         ComparisonSourceType SourceType { get; }
     }
 }
\ No newline at end of file
diff --git a/src/AngleSharp.Diffing/Core/IDiff.cs b/src/AngleSharp.Diffing/Core/IDiff.cs
index 5186d5c..108033a 100644
--- a/src/AngleSharp.Diffing/Core/IDiff.cs
+++ b/src/AngleSharp.Diffing/Core/IDiff.cs
@@ -1,5 +1,8 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents a difference in a comparison.
+    /// </summary>
     public interface IDiff
     {
         /// <summary>
diff --git a/src/AngleSharp.Diffing/Core/IDiffContext.cs b/src/AngleSharp.Diffing/Core/IDiffContext.cs
index be92396..41c85e0 100644
--- a/src/AngleSharp.Diffing/Core/IDiffContext.cs
+++ b/src/AngleSharp.Diffing/Core/IDiffContext.cs
@@ -2,9 +2,23 @@
 
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// The diffing context provides access to the control and test DOM tree during diffing.
+    /// </summary>
     public interface IDiffContext
     {
-        IHtmlCollection<IElement> QueryControlRoot(string selector);
-        IHtmlCollection<IElement> QueryTestRoot(string selector);
+        /// <summary>
+        /// Query the control nodes using a CSS selector.
+        /// </summary>
+        /// <param name="cssSelector">The CSS selector to use in the query.</param>
+        /// <returns>A <see cref="IHtmlCollection{IElement}"/></returns>
+        IHtmlCollection<IElement> QueryControlNodes(string cssSelector);
+
+        /// <summary>
+        /// Query the test nodes using a CSS selector.
+        /// </summary>
+        /// <param name="cssSelector">The CSS selector to use in the query.</param>
+        /// <returns>A <see cref="IHtmlCollection{IElement}"/></returns>
+        IHtmlCollection<IElement> QueryTestNodes(string cssSelector);
     }
 }
\ No newline at end of file
diff --git a/src/AngleSharp.Diffing/Core/SourceCollection.cs b/src/AngleSharp.Diffing/Core/SourceCollection.cs
index 25e6688..80b4d1b 100644
--- a/src/AngleSharp.Diffing/Core/SourceCollection.cs
+++ b/src/AngleSharp.Diffing/Core/SourceCollection.cs
@@ -5,8 +5,9 @@
 
 namespace AngleSharp.Diffing.Core
 {
-    public delegate FilterDecision SourceCollectionRemovePredicate(in ComparisonSource source);
-
+    /// <summary>
+    /// Represents a collection of <see cref="ComparisonSource"/> sources in a comparison.
+    /// </summary>
     public class SourceCollection : IEnumerable<ComparisonSource>
     {
         private const int SOURCE_REMOVED = -1;
@@ -16,10 +17,19 @@ public class SourceCollection : IEnumerable<ComparisonSource>
         private readonly int[] _status;
         private IReadOnlyList<ComparisonSource> _sources;
 
+        /// <summary>
+        /// Gets the type of the sources in the collection.
+        /// </summary>
         public ComparisonSourceType SourceType { get; }
 
+        /// <summary>
+        /// Gets the number of items in the collection.
+        /// </summary>
         public int Count { get; private set; }
 
+        /// <summary>
+        /// Gets the source at the specified index.
+        /// </summary>
         public ComparisonSource this[int index]
         {
             get
@@ -30,17 +40,25 @@ public ComparisonSource this[int index]
             }
         }
 
+        /// <summary>
+        /// Creates a new <see cref="SourceCollection"/>.
+        /// </summary>
         public SourceCollection(ComparisonSourceType sourceType, IEnumerable<ComparisonSource> sources) : this(sourceType, sources.ToArray()) { }
-        
+
+        /// <summary>
+        /// Creates a new <see cref="SourceCollection"/>.
+        /// </summary>
         public SourceCollection(ComparisonSourceType sourceType, IReadOnlyList<ComparisonSource> sources)
         {
             SourceType = sourceType;
             _sources = sources;
             _status = new int[_sources.Count];
             Count = _sources.Count;
-            //EnsureSourcesAreInCorrectOrder();
         }
 
+        /// <summary>
+        /// Gets all the unmatched sources in the collection, starting from the specified index (default: 0).
+        /// </summary>
         public IEnumerable<ComparisonSource> GetUnmatched(int startIndex = 0)
         {
             for (int i = startIndex; i < _sources.Count; i++)
@@ -53,6 +71,7 @@ public IEnumerable<ComparisonSource> GetUnmatched(int startIndex = 0)
             yield break;
         }
 
+        /// <inheritdoc/>
         public IEnumerator<ComparisonSource> GetEnumerator()
         {
             for (int i = 0; i < _sources.Count; i++)
@@ -68,6 +87,7 @@ public IEnumerator<ComparisonSource> GetEnumerator()
             yield break;
         }
 
+        /// <inheritdoc/>
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
         /// <summary>
diff --git a/src/AngleSharp.Diffing/Core/SourceCollectionRemovePredicate.cs b/src/AngleSharp.Diffing/Core/SourceCollectionRemovePredicate.cs
new file mode 100644
index 0000000..c27fb07
--- /dev/null
+++ b/src/AngleSharp.Diffing/Core/SourceCollectionRemovePredicate.cs
@@ -0,0 +1,7 @@
+namespace AngleSharp.Diffing.Core
+{
+    /// <summary>
+    /// Predicate used to remove matched nodes from a source collection.
+    /// </summary>
+    public delegate FilterDecision SourceCollectionRemovePredicate(in ComparisonSource source);
+}
diff --git a/src/AngleSharp.Diffing/Core/SourceMap.cs b/src/AngleSharp.Diffing/Core/SourceMap.cs
index 385c812..35450cf 100644
--- a/src/AngleSharp.Diffing/Core/SourceMap.cs
+++ b/src/AngleSharp.Diffing/Core/SourceMap.cs
@@ -2,22 +2,33 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+
 using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Core
 {
-    public delegate FilterDecision SourceMapRemovePredicate(in AttributeComparisonSource source);
-
+    /// <summary>
+    /// Represents a map of <see cref="AttributeComparisonSource"/> sources.
+    /// </summary>
     [SuppressMessage("Naming", "CA1710:Identifiers should have correct suffix")]
     public class SourceMap : IEnumerable<AttributeComparisonSource>
     {
         private readonly HashSet<string> _matched = new HashSet<string>();
         private readonly Dictionary<string, AttributeComparisonSource> _sources = new Dictionary<string, AttributeComparisonSource>();
 
+        /// <summary>
+        /// Gets the type of the sources in the collection.
+        /// </summary>
         public ComparisonSourceType SourceType { get; }
 
+        /// <summary>
+        /// Gets the number of items in the map.
+        /// </summary>
         public int Count => _sources.Count;
 
+        /// <summary>
+        /// Gets the <see cref="AttributeComparisonSource"/> with the specified <paramref name="name"/>.
+        /// </summary>
         public AttributeComparisonSource this[string name]
         {
             get
@@ -26,6 +37,9 @@ public AttributeComparisonSource this[string name]
             }
         }
 
+        /// <summary>
+        /// Creates a <see cref="SourceMap"/>.
+        /// </summary>
         public SourceMap(in ComparisonSource elementSource)
         {
             if (elementSource.Node is IElement element)
@@ -42,28 +56,48 @@ public SourceMap(in ComparisonSource elementSource)
             }
         }
 
+        /// <summary>
+        /// Checks whether the map contains a source with the specified <paramref name="name"/>.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
         public bool Contains(string name) => _sources.ContainsKey(name);
 
+        /// <summary>
+        /// Checks whether the source with the name <paramref name="name"/> has been matched.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
         public bool IsUnmatched(string name) => !_matched.Contains(name);
 
+        /// <summary>
+        /// Gets all the unmatched sources in the map.
+        /// </summary>
         public IEnumerable<AttributeComparisonSource> GetUnmatched()
         {
             foreach (var source in _sources.Values)
             {
-                if (!_matched.Contains(source.Attribute.Name)) yield return source;
+                if (!_matched.Contains(source.Attribute.Name))
+                    yield return source;
             }
         }
 
+        /// <inheritdoc/>
         public IEnumerator<AttributeComparisonSource> GetEnumerator() => _sources.Values.GetEnumerator();
 
+        /// <inheritdoc/>
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
+        /// <summary>
+        /// Removes a source from the map.
+        /// </summary>
         public void Remove(SourceMapRemovePredicate predicate)
         {
             var removeQueue = new Queue<string>(Count);
             foreach (var source in _sources.Values)
             {
-                if (predicate(source) == FilterDecision.Exclude) removeQueue.Enqueue(source.Attribute.Name);
+                if (predicate(source) == FilterDecision.Exclude)
+                    removeQueue.Enqueue(source.Attribute.Name);
             }
             foreach (var name in removeQueue)
             {
@@ -71,6 +105,9 @@ public void Remove(SourceMapRemovePredicate predicate)
             }
         }
 
+        /// <summary>
+        /// Mark a source as matched.
+        /// </summary>
         public void MarkAsMatched(in AttributeComparisonSource source)
         {
             _matched.Add(source.Attribute.Name);
diff --git a/src/AngleSharp.Diffing/Core/SourceMapRemovePredicate.cs b/src/AngleSharp.Diffing/Core/SourceMapRemovePredicate.cs
new file mode 100644
index 0000000..e412616
--- /dev/null
+++ b/src/AngleSharp.Diffing/Core/SourceMapRemovePredicate.cs
@@ -0,0 +1,7 @@
+namespace AngleSharp.Diffing.Core
+{
+    /// <summary>
+    /// Represents a delegate for removing sources from a <see cref="SourceMap"/>.
+    /// </summary>
+    public delegate FilterDecision SourceMapRemovePredicate(in AttributeComparisonSource source);
+}
diff --git a/src/AngleSharp.Diffing/Core/SourceType.cs b/src/AngleSharp.Diffing/Core/SourceType.cs
index 3c58886..fbdeaa3 100644
--- a/src/AngleSharp.Diffing/Core/SourceType.cs
+++ b/src/AngleSharp.Diffing/Core/SourceType.cs
@@ -1,8 +1,17 @@
 namespace AngleSharp.Diffing.Core
 {
+    /// <summary>
+    /// Represents the source type in a comparison.
+    /// </summary>
     public enum ComparisonSourceType
     {
+        /// <summary>
+        /// The source type is a control node or attribute.
+        /// </summary>
         Control,
+        /// <summary>
+        /// The source type is a test node or attribute.
+        /// </summary>
         Test
     }
 }
diff --git a/src/AngleSharp.Diffing/DiffBuilder.cs b/src/AngleSharp.Diffing/DiffBuilder.cs
index 08a09e2..dc5ba92 100644
--- a/src/AngleSharp.Diffing/DiffBuilder.cs
+++ b/src/AngleSharp.Diffing/DiffBuilder.cs
@@ -1,12 +1,16 @@
 using System;
 using System.Collections.Generic;
-using AngleSharp.Dom;
-using AngleSharp.Html.Parser;
+
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Strategies;
+using AngleSharp.Dom;
+using AngleSharp.Html.Parser;
 
 namespace AngleSharp.Diffing
 {
+    /// <summary>
+    /// Use the <see cref="DiffBuilder"/> to easily set up a comparison of a control and test DOM tree.
+    /// </summary>
     public class DiffBuilder
     {
         private readonly IBrowsingContext _context;
@@ -16,8 +20,14 @@ public class DiffBuilder
         private string _control = string.Empty;
         private string _test = string.Empty;
 
+        /// <summary>
+        /// Gets or sets the control markup string.
+        /// </summary>
         public string Control { get => _control; set => _control = value ?? throw new ArgumentNullException(nameof(Control)); }
 
+        /// <summary>
+        /// Gets or sets the test markup string.
+        /// </summary>
         public string Test { get => _test; set => _test = value ?? throw new ArgumentNullException(nameof(Test)); }
 
         private DiffBuilder(string control)
@@ -29,17 +39,26 @@ private DiffBuilder(string control)
             _document = _context.OpenNewAsync().Result;
         }
 
+        /// <summary>
+        /// Creates a <see cref="DiffBuilder"/> with the provided control markup.
+        /// </summary>
         public static DiffBuilder Compare(string control)
         {
             return new DiffBuilder(control);
         }
 
+        /// <summary>
+        /// Sets the <see cref="Test"/> markup used during comparison.
+        /// </summary>
         public DiffBuilder WithTest(string test)
         {
             Test = test;
             return this;
         }
 
+        /// <summary>
+        /// Add any options/strategies that should be used during comparison.
+        /// </summary>
         public DiffBuilder WithOptions(Action<IDiffingStrategyCollection> registerOptions)
         {
             _diffStrategy = new DiffingStrategyPipeline();
@@ -47,6 +66,9 @@ public DiffBuilder WithOptions(Action<IDiffingStrategyCollection> registerOption
             return this;
         }
 
+        /// <summary>
+        /// Execute the comparison operation and returns any differences found.
+        /// </summary>
         public IEnumerable<IDiff> Build()
         {
             if (_diffStrategy is null)
@@ -61,6 +83,9 @@ public IEnumerable<IDiff> Build()
             return new HtmlDifferenceEngine(_diffStrategy, controls, tests).Compare();
         }
 
+        /// <summary>
+        /// Parse the provided markup into a AngleSharp DOM tree.
+        /// </summary>
         protected INodeList Parse(string html)
         {
             return _htmlParser.ParseFragment(html, _document.Body);
diff --git a/src/AngleSharp.Diffing/Extensions/CollectionExtensions.cs b/src/AngleSharp.Diffing/Extensions/CollectionExtensions.cs
index 1c3edbb..4bcf3fd 100644
--- a/src/AngleSharp.Diffing/Extensions/CollectionExtensions.cs
+++ b/src/AngleSharp.Diffing/Extensions/CollectionExtensions.cs
@@ -3,12 +3,20 @@
 
 namespace AngleSharp.Diffing.Extensions
 {
+    /// <summary>
+    /// Helper methods for <see cref="ICollection{T}"/>.
+    /// </summary>
     public static class CollectionExtensions
     {
+        /// <summary>
+        /// Adds a range of items to the target.
+        /// </summary>
         public static void AddRange<T>(this ICollection<T> target, IEnumerable<T> source)
         {
-            if (target is null) throw new ArgumentNullException(nameof(target));
-            if (source is null) throw new ArgumentNullException(nameof(source));
+            if (target is null)
+                throw new ArgumentNullException(nameof(target));
+            if (source is null)
+                throw new ArgumentNullException(nameof(source));
 
             foreach (var item in source)
             {
diff --git a/src/AngleSharp.Diffing/Extensions/ElementExtensions.cs b/src/AngleSharp.Diffing/Extensions/ElementExtensions.cs
index 5357a4d..9547f49 100644
--- a/src/AngleSharp.Diffing/Extensions/ElementExtensions.cs
+++ b/src/AngleSharp.Diffing/Extensions/ElementExtensions.cs
@@ -1,12 +1,20 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+
 using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Extensions
 {
+    /// <summary>
+    /// Helper methods for <see cref="IElement"/> types.
+    /// </summary>
     public static class ElementExtensions
     {
+        /// <summary>
+        /// Try to get an attribute value off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue(this IElement element, string attributeName, out bool result)
         {
             return TryGetAttrValue(element, attributeName, ParseBoolAttribute, out result);
@@ -14,6 +22,10 @@ public static bool TryGetAttrValue(this IElement element, string attributeName,
             static bool ParseBoolAttribute(string boolValue) => string.IsNullOrWhiteSpace(boolValue) || bool.Parse(boolValue);
         }
 
+        /// <summary>
+        /// Try to get an attribute value off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue(this IElement element, string attributeName, [NotNullWhen(true)]out string result)
         {
             return TryGetAttrValue(element, attributeName, GetStringAttrValue, out result);
@@ -21,6 +33,10 @@ public static bool TryGetAttrValue(this IElement element, string attributeName,
             static string GetStringAttrValue(string value) => value;
         }
 
+        /// <summary>
+        /// Try to get an attribute value off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue<T>(this IElement element, string attributeName, out T result) where T : System.Enum
         {
             return TryGetAttrValue(element, attributeName, ParseEnum, out result);
@@ -28,10 +44,16 @@ public static bool TryGetAttrValue<T>(this IElement element, string attributeNam
             static T ParseEnum(string enumValue) => (T)Enum.Parse(typeof(T), enumValue, true);
         }
 
+        /// <summary>
+        /// Try to get an attribute value off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue<T>(this IElement element, string attributeName, Func<string, T> resultFunc, [NotNullWhen(true)] out T result)
         {
-            if (element is null) throw new ArgumentNullException(nameof(element));
-            if (resultFunc is null) throw new ArgumentNullException(nameof(resultFunc));
+            if (element is null)
+                throw new ArgumentNullException(nameof(element));
+            if (resultFunc is null)
+                throw new ArgumentNullException(nameof(resultFunc));
 
             if (element.Attributes[attributeName] is IAttr optAttr)
             {
@@ -47,16 +69,30 @@ public static bool TryGetAttrValue<T>(this IElement element, string attributeNam
             }
         }
 
+        /// <summary>
+        /// Try to get an inline diff option off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static TEnum GetInlineOptionOrDefault<TEnum>(this IElement startElement, string optionName, TEnum defaultValue)
             where TEnum : System.Enum => GetInlineOptionOrDefault(startElement, optionName, x => x.Parse<TEnum>(), defaultValue);
 
+        /// <summary>
+        /// Try to get an inline diff option off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool GetInlineOptionOrDefault(this IElement startElement, string optionName, bool defaultValue)
             => GetInlineOptionOrDefault(startElement, optionName, x => string.IsNullOrWhiteSpace(x) || bool.Parse(x), defaultValue);
 
+        /// <summary>
+        /// Try to get an inline diff option off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static T GetInlineOptionOrDefault<T>(this IElement startElement, string optionName, Func<string, T> resultFunc, T defaultValue)
         {
-            if (startElement is null) throw new ArgumentNullException(nameof(startElement));
-            if (resultFunc is null) throw new ArgumentNullException(nameof(resultFunc));
+            if (startElement is null)
+                throw new ArgumentNullException(nameof(startElement));
+            if (resultFunc is null)
+                throw new ArgumentNullException(nameof(resultFunc));
 
             var element = startElement;
 
@@ -72,11 +108,16 @@ public static T GetInlineOptionOrDefault<T>(this IElement startElement, string o
             return defaultValue;
         }
 
+        /// <summary>
+        /// Try to get the index of the node in its parent's ChildNodes list.
+        /// Returns true if index was found. False otherwise.
+        /// </summary>
         public static bool TryGetNodeIndex(this INode node, [NotNullWhen(true)]out int index)
         {
             index = -1;
 
-            if (node.ParentElement is null) return false;
+            if (node.ParentElement is null)
+                return false;
 
             var parentElement = node.ParentElement;
 
@@ -92,6 +133,9 @@ public static bool TryGetNodeIndex(this INode node, [NotNullWhen(true)]out int i
             return false;
         }
 
+        /// <summary>
+        /// Gets all parents of a node, starting with the nearest node. 
+        /// </summary>
         public static IEnumerable<INode> GetParents(this INode node)
         {
             var parent = node.Parent;
diff --git a/src/AngleSharp.Diffing/Extensions/EmptyHtmlCollection.cs b/src/AngleSharp.Diffing/Extensions/EmptyHtmlCollection.cs
index e8ec729..fe6a669 100644
--- a/src/AngleSharp.Diffing/Extensions/EmptyHtmlCollection.cs
+++ b/src/AngleSharp.Diffing/Extensions/EmptyHtmlCollection.cs
@@ -2,24 +2,39 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+
 using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Extensions
 {
+    /// <summary>
+    /// Represents an empty <see cref="IHtmlCollection{T}"/>.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class EmptyHtmlCollection<T> : IHtmlCollection<T> where T : IElement
     {
+        /// <inheritdoc/>
         [SuppressMessage("Design", "CA1065:Do not raise exceptions in unexpected locations")]
         public T this[int index] => throw new IndexOutOfRangeException();
 
+        /// <inheritdoc/>
         [SuppressMessage("Design", "CA1065:Do not raise exceptions in unexpected locations")]
         public T this[string id] => throw new IndexOutOfRangeException();
 
+        /// <inheritdoc/>
         public int Length => 0;
 
+        private EmptyHtmlCollection() { }
+
+        /// <inheritdoc/>
         public IEnumerator<T> GetEnumerator() { yield break; }
 
+        /// <inheritdoc/>
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
+        /// <summary>
+        /// Gets an instance of the <see cref="EmptyHtmlCollection{T}"/>.
+        /// </summary>
         public static readonly IHtmlCollection<T> Empty = new EmptyHtmlCollection<T>();
     }
 }
diff --git a/src/AngleSharp.Diffing/Extensions/EnumExtensions.cs b/src/AngleSharp.Diffing/Extensions/EnumExtensions.cs
index 03e4bc4..555cb1f 100644
--- a/src/AngleSharp.Diffing/Extensions/EnumExtensions.cs
+++ b/src/AngleSharp.Diffing/Extensions/EnumExtensions.cs
@@ -2,8 +2,14 @@
 
 namespace AngleSharp.Diffing.Extensions
 {
+    /// <summary>
+    /// Helper methods for enums
+    /// </summary>
     public static class EnumExtensions
     {
+        /// <summary>
+        /// Parse a string to an enum.
+        /// </summary>
         public static TEnum Parse<TEnum>(this string enumString) where TEnum : System.Enum
         {
             return (TEnum)Enum.Parse(typeof(TEnum), enumString, true);
diff --git a/src/AngleSharp.Diffing/Extensions/NodeExtensions.cs b/src/AngleSharp.Diffing/Extensions/NodeExtensions.cs
index b3b783f..dabcf1b 100644
--- a/src/AngleSharp.Diffing/Extensions/NodeExtensions.cs
+++ b/src/AngleSharp.Diffing/Extensions/NodeExtensions.cs
@@ -1,16 +1,27 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
+
 using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Extensions
 {
+    /// <summary>
+    /// Helper methods for working with AngleSharp nodes.
+    /// </summary>
     public static class NodeExtensions
     {
+        /// <summary>
+        /// Gets whether the <paramref name="node"/> has attributes.
+        /// </summary>
         public static bool HasAttributes(this INode node)
         {
             return node is IElement element && element.Attributes.Length > 0;
         }
 
+        /// <summary>
+        /// Try to get an attribute with the <paramref name="attributeName"/> from the <paramref name="node"/>.
+        /// Returns true if the attribute exists, false otherwise.
+        /// </summary>
         public static bool TryGetAttr(this INode node, string attributeName, [NotNullWhen(true)]out IAttr? attribute)
         {
             if (node is IElement element && element.HasAttribute(attributeName))
@@ -25,6 +36,10 @@ public static bool TryGetAttr(this INode node, string attributeName, [NotNullWhe
             }
         }
 
+        /// <summary>
+        /// Try to get an attribute value off of an node.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue(this INode node, string attributeName, out bool result)
         {
 #pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
@@ -33,6 +48,10 @@ public static bool TryGetAttrValue(this INode node, string attributeName, out bo
             return node is IElement element && element.TryGetAttrValue(attributeName, out result);
         }
 
+        /// <summary>
+        /// Try to get an attribute value off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue(this INode node, string attributeName, [NotNullWhen(true)]out string result)
         {
 #pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
@@ -41,6 +60,10 @@ public static bool TryGetAttrValue(this INode node, string attributeName, [NotNu
             return node is IElement element && element.TryGetAttrValue(attributeName, out result);
         }
 
+        /// <summary>
+        /// Try to get an attribute value off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue<T>(this INode node, string attributeName, out T result) where T : System.Enum
         {
 #pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
@@ -49,6 +72,10 @@ public static bool TryGetAttrValue<T>(this INode node, string attributeName, out
             return node is IElement element && element.TryGetAttrValue(attributeName, out result);
         }
 
+        /// <summary>
+        /// Try to get an attribute value off of an element.
+        /// Returns true when the attribute was found, false otherwise.
+        /// </summary>
         public static bool TryGetAttrValue<T>(this INode node, string attributeName, Func<string, T> resultFunc, [NotNullWhen(true)] out T result)
         {
 #pragma warning disable CS8653 // A default expression introduces a null value for a type parameter.
@@ -57,6 +84,9 @@ public static bool TryGetAttrValue<T>(this INode node, string attributeName, Fun
             return node is IElement element && element.TryGetAttrValue(attributeName, resultFunc, out result);
         }
 
+        /// <summary>
+        /// Gets whether two nodes is of the same type (NodeType) and has the same name (NodeName).
+        /// </summary>
         public static bool IsSameTypeAs(this INode node, INode other)
         {
             return node.NodeType.Equals(other.NodeType) && node.NodeName.Equals(other.NodeName, StringComparison.Ordinal);
diff --git a/src/AngleSharp.Diffing/Extensions/NodeListExtensions.cs b/src/AngleSharp.Diffing/Extensions/NodeListExtensions.cs
index 54a9dc8..d2f6cd0 100644
--- a/src/AngleSharp.Diffing/Extensions/NodeListExtensions.cs
+++ b/src/AngleSharp.Diffing/Extensions/NodeListExtensions.cs
@@ -1,20 +1,31 @@
 using System;
 using System.Collections.Generic;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing
 {
+    /// <summary>
+    /// Helper methods for working with AngleSharp types.
+    /// </summary>
     public static class AngleSharpDomExtensions
     {
+        /// <summary>
+        /// Creates a source collection from a node list.
+        /// </summary>
         public static SourceCollection ToSourceCollection(this IEnumerable<INode> nodelist, ComparisonSourceType sourceType, string path = "")
         {
             return new SourceCollection(sourceType, nodelist.ToComparisonSourceList(sourceType, path));
         }
 
+        /// <summary>
+        /// Creates a comparison source list from a node list.
+        /// </summary>
         public static IEnumerable<ComparisonSource> ToComparisonSourceList(this IEnumerable<INode> nodes, ComparisonSourceType sourceType, string path = "")
         {
-            if (nodes is null) throw new ArgumentNullException(nameof(nodes));
+            if (nodes is null)
+                throw new ArgumentNullException(nameof(nodes));
 
             var index = 0;
             foreach (var node in nodes)
@@ -25,6 +36,9 @@ public static IEnumerable<ComparisonSource> ToComparisonSourceList(this IEnumera
             yield break;
         }
 
+        /// <summary>
+        /// Creates a comparison source from a node.
+        /// </summary>
         public static ComparisonSource ToComparisonSource(this INode node, int index, ComparisonSourceType sourceType, string path = "")
             => new ComparisonSource(node, index, path, sourceType);
     }
diff --git a/src/AngleSharp.Diffing/Extensions/NodeNotFoundException.cs b/src/AngleSharp.Diffing/Extensions/NodeNotFoundException.cs
deleted file mode 100644
index fa740df..0000000
--- a/src/AngleSharp.Diffing/Extensions/NodeNotFoundException.cs
+++ /dev/null
@@ -1,25 +0,0 @@
-using System;
-using System.Runtime.Serialization;
-
-namespace AngleSharp.Diffing.Extensions
-{
-    [Serializable]
-    public class NodeNotFoundException : Exception
-    {
-        public NodeNotFoundException()
-        {
-        }
-
-        public NodeNotFoundException(string message) : base(message)
-        {
-        }
-
-        public NodeNotFoundException(string message, Exception innerException) : base(message, innerException)
-        {
-        }
-
-        protected NodeNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context)
-        {
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/AngleSharp.Diffing/HtmlDiffer.cs b/src/AngleSharp.Diffing/HtmlDiffer.cs
index 68c5532..be55cde 100644
--- a/src/AngleSharp.Diffing/HtmlDiffer.cs
+++ b/src/AngleSharp.Diffing/HtmlDiffer.cs
@@ -1,11 +1,15 @@
 using System;
 using System.Collections.Generic;
+
 using AngleSharp.Diffing.Core;
 using AngleSharp.Dom;
 using AngleSharp.Html.Parser;
 
 namespace AngleSharp.Diffing
 {
+    /// <summary>
+    /// Represents a reusable HTML differ, that can be configured and used to perform multiple different comparisons. 
+    /// </summary>
     public class HtmlDiffer
     {
         private readonly IBrowsingContext _context;
@@ -13,6 +17,10 @@ public class HtmlDiffer
         private readonly IDocument _document;
         private readonly IDiffingStrategy _diffingStrategy;
 
+        /// <summary>
+        /// Creates a <see cref="HtmlDiffer"/> with the provided strategy.
+        /// </summary>
+        /// <param name="diffingStrategy"></param>
         public HtmlDiffer(IDiffingStrategy diffingStrategy)
         {
             _diffingStrategy = diffingStrategy ?? throw new ArgumentNullException(nameof(diffingStrategy));
@@ -22,42 +30,67 @@ public HtmlDiffer(IDiffingStrategy diffingStrategy)
             _document = _context.OpenNewAsync().Result;
         }
 
+        /// <summary>
+        /// Performs a comparison of the provided <paramref name="controlMarkup"/> and <paramref name="testMarkup"/>.
+        /// </summary>
         public IEnumerable<IDiff> Compare(string controlMarkup, string testMarkup)
         {
-            if (controlMarkup is null) throw new ArgumentNullException(nameof(controlMarkup));
-            if (testMarkup is null) throw new ArgumentNullException(nameof(testMarkup));
+            if (controlMarkup is null)
+                throw new ArgumentNullException(nameof(controlMarkup));
+            if (testMarkup is null)
+                throw new ArgumentNullException(nameof(testMarkup));
 
             return Compare(Parse(controlMarkup), Parse(testMarkup));
         }
 
+        /// <summary>
+        /// Performs a comparison of the provided <paramref name="controlNode"/> and <paramref name="testNodes"/>.
+        /// </summary>
         public IEnumerable<IDiff> Compare(INode controlNode, IEnumerable<INode> testNodes)
         {
-            if (controlNode is null) throw new ArgumentNullException(nameof(controlNode));
-            if (testNodes is null) throw new ArgumentNullException(nameof(testNodes));
+            if (controlNode is null)
+                throw new ArgumentNullException(nameof(controlNode));
+            if (testNodes is null)
+                throw new ArgumentNullException(nameof(testNodes));
 
             return Compare(new[] { controlNode }, testNodes);
         }
 
+        /// <summary>
+        /// Performs a comparison of the provided <paramref name="controlNodes"/> and <paramref name="testNode"/>.
+        /// </summary>
         public IEnumerable<IDiff> Compare(IEnumerable<INode> controlNodes, INode testNode)
         {
-            if (controlNodes is null) throw new ArgumentNullException(nameof(controlNodes));
-            if (testNode is null) throw new ArgumentNullException(nameof(testNode));
+            if (controlNodes is null)
+                throw new ArgumentNullException(nameof(controlNodes));
+            if (testNode is null)
+                throw new ArgumentNullException(nameof(testNode));
 
             return Compare(controlNodes, new[] { testNode });
         }
 
+        /// <summary>
+        /// Performs a comparison of the provided <paramref name="controlNode"/> and <paramref name="testNode"/>.
+        /// </summary>
         public IEnumerable<IDiff> Compare(INode controlNode, INode testNode)
         {
-            if (controlNode is null) throw new ArgumentNullException(nameof(controlNode));
-            if (testNode is null) throw new ArgumentNullException(nameof(testNode));
+            if (controlNode is null)
+                throw new ArgumentNullException(nameof(controlNode));
+            if (testNode is null)
+                throw new ArgumentNullException(nameof(testNode));
 
             return Compare(new[] { controlNode }, new[] { testNode });
         }
 
+        /// <summary>
+        /// Performs a comparison of the provided <paramref name="controlNodes"/> and <paramref name="testNodes"/>.
+        /// </summary>
         public IEnumerable<IDiff> Compare(IEnumerable<INode> controlNodes, IEnumerable<INode> testNodes)
         {
-            if (controlNodes is null) throw new ArgumentNullException(nameof(controlNodes));
-            if (testNodes is null) throw new ArgumentNullException(nameof(testNodes));
+            if (controlNodes is null)
+                throw new ArgumentNullException(nameof(controlNodes));
+            if (testNodes is null)
+                throw new ArgumentNullException(nameof(testNodes));
 
             var controlSources = controlNodes.ToSourceCollection(ComparisonSourceType.Control);
             var testSources = testNodes.ToSourceCollection(ComparisonSourceType.Test);
@@ -65,6 +98,9 @@ public IEnumerable<IDiff> Compare(IEnumerable<INode> controlNodes, IEnumerable<I
             return new HtmlDifferenceEngine(_diffingStrategy, controlSources, testSources).Compare();
         }
 
+        /// <summary>
+        /// Parse the markup into a AngleSharp DOM tree.
+        /// </summary>
         protected INodeList Parse(string html)
         {
             return _htmlParser.ParseFragment(html, _document.Body);
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeComparer.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeComparer.cs
index 8582bff..a653369 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeComparer.cs
@@ -1,9 +1,13 @@
 using System;
 using System.Text.RegularExpressions;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// The logic for comparing attributes.
+    /// </summary>
     public static class AttributeComparer
     {
         private const string IGNORE_CASE_POSTFIX = ":ignorecase";
@@ -11,15 +15,20 @@ public static class AttributeComparer
         private const string IGNORE_CASE_REGEX_POSTFIX = IGNORE_CASE_POSTFIX + REGEX_POSTFIX;
         private const string REGEX_IGNORE_CASE_POSTFIX = REGEX_POSTFIX + IGNORE_CASE_POSTFIX;
 
+        /// <summary>
+        /// Attribute compare strategy.
+        /// </summary>
         public static CompareResult Compare(in AttributeComparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
 
             var (ignoreCase, isRegexValueCompare) = GetComparisonModifiers(comparison);
 
             var hasSameName = CompareAttributeNames(comparison, ignoreCase, isRegexValueCompare);
 
-            if(!hasSameName) return CompareResult.Different;
+            if (!hasSameName)
+                return CompareResult.Different;
 
             var hasSameValue = isRegexValueCompare
                 ? CompareAttributeValuesByRegex(comparison, ignoreCase)
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeNameMatcher.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeNameMatcher.cs
index 50e2284..89331b4 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeNameMatcher.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/AttributeNameMatcher.cs
@@ -1,15 +1,24 @@
 using System;
 using System.Collections.Generic;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Attribute name matcher strategy
+    /// </summary>
     public static class AttributeNameMatcher
     {
+        /// <summary>
+        /// Attribute name matcher strategy.
+        /// </summary>
         public static IEnumerable<AttributeComparison> Match(IDiffContext context, SourceMap controlSources, SourceMap testSources)
         {
-            if (controlSources is null) throw new ArgumentNullException(nameof(controlSources));
-            if (testSources is null) throw new ArgumentNullException(nameof(testSources));
+            if (controlSources is null)
+                throw new ArgumentNullException(nameof(controlSources));
+            if (testSources is null)
+                throw new ArgumentNullException(nameof(testSources));
 
             foreach (var control in controlSources.GetUnmatched())
             {
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparer.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparer.cs
index 3cb861c..1f43522 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparer.cs
@@ -1,10 +1,14 @@
 using System;
 using System.Collections.Generic;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Boolean attribute comparer strategy.
+    /// </summary>
     public class BooleanAttributeComparer
     {
         private static readonly HashSet<string> BooleanAttributesSet = new HashSet<string>()
@@ -36,20 +40,33 @@ public class BooleanAttributeComparer
             "typemustmatch"
         };
 
+        /// <summary>
+        /// Gets a collection of names of all attributes the strategy considers as boolean attributes.
+        /// </summary>        
         public static IReadOnlyCollection<string> BooleanAttributes => BooleanAttributesSet;
 
         private readonly BooleanAttributeComparision _mode;
 
+        /// <summary>
+        /// Creates a instance of the <see cref="BooleanAttributeComparer"/>.
+        /// </summary>
+        /// <param name="mode"></param>
         public BooleanAttributeComparer(BooleanAttributeComparision mode)
         {
             _mode = mode;
         }
 
+        /// <summary>
+        /// The boolean attribute comparer strategy.
+        /// </summary>
         public CompareResult Compare(in AttributeComparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
-            if (!IsAttributeNamesEqual(comparison)) return CompareResult.Different;
-            if (!BooleanAttributesSet.Contains(comparison.Control.Attribute.Name)) return currentDecision;
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
+            if (!IsAttributeNamesEqual(comparison))
+                return CompareResult.Different;
+            if (!BooleanAttributesSet.Contains(comparison.Control.Attribute.Name))
+                return currentDecision;
 
             var hasSameValue = _mode == BooleanAttributeComparision.Strict
                 ? CompareStrict(comparison)
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparision.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparision.cs
index 0c47274..e6ebdaf 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparision.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/BooleanAttributeComparision.cs
@@ -1,8 +1,17 @@
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Controls the type of comparison performed by the <see cref="BooleanAttributeComparer"/>.
+    /// </summary>
     public enum BooleanAttributeComparision
     {
+        /// <summary>
+        /// Tells the <see cref="BooleanAttributeComparer"/> to just assert that a boolean attribute exists, independent of its value.
+        /// </summary>
         Loose,
+        /// <summary>
+        /// Tells the <see cref="BooleanAttributeComparer"/> to verify that the attribute is both a boolean attribute and that its value is legal.
+        /// </summary>
         Strict
     }
 }
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/ClassAttributeComparer.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/ClassAttributeComparer.cs
index 94339e2..bd65a54 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/ClassAttributeComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/ClassAttributeComparer.cs
@@ -1,20 +1,30 @@
 using System;
 using System.Linq;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Represents the class attribute comparer strategy.
+    /// </summary>
     public static class ClassAttributeComparer
     {
         private const string CLASS_ATTRIBUTE_NAME = "class";
 
+        /// <summary>
+        /// The class attribute comparer strategy.
+        /// </summary>
         public static CompareResult Compare(in AttributeComparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
-            if (!IsClassAttributes(comparison)) return currentDecision;
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
+            if (!IsClassAttributes(comparison))
+                return currentDecision;
 
             var (ctrlElm, testElm) = comparison.GetAttributeElements();
-            if (ctrlElm.ClassList.Length != testElm.ClassList.Length) return CompareResult.Different;
+            if (ctrlElm.ClassList.Length != testElm.ClassList.Length)
+                return CompareResult.Different;
 
             return ctrlElm.ClassList.All(x => testElm.ClassList.Contains(x))
                 ? CompareResult.Same
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
index 82c0d84..bfc9f9a 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -1,7 +1,11 @@
+using AngleSharp.Diffing.Strategies;
 using AngleSharp.Diffing.Strategies.AttributeStrategies;
 
 namespace AngleSharp.Diffing
 {
+    /// <summary>
+    /// Helper methods for registering strategies.
+    /// </summary>
     public static partial class DiffingStrategyPipelineBuilderExtensions
     {
         /// <summary>
@@ -9,7 +13,7 @@ public static partial class DiffingStrategyPipelineBuilderExtensions
         /// </summary>
         public static IDiffingStrategyCollection IgnoreDiffAttributes(this IDiffingStrategyCollection builder)
         {
-            builder.AddFilter(IgnoreDiffAttributesFilter.Filter, true);
+            builder.AddFilter(IgnoreDiffAttributesFilter.Filter, StrategyType.Specialized);
             return builder;
         }
 
@@ -18,7 +22,7 @@ public static IDiffingStrategyCollection IgnoreDiffAttributes(this IDiffingStrat
         /// </summary>
         public static IDiffingStrategyCollection AddAttributeNameMatcher(this IDiffingStrategyCollection builder)
         {
-            builder.AddMatcher(AttributeNameMatcher.Match, isSpecializedMatcher: false);
+            builder.AddMatcher(AttributeNameMatcher.Match, StrategyType.Generalized);
             return builder;
         }
 
@@ -27,9 +31,9 @@ public static IDiffingStrategyCollection AddAttributeNameMatcher(this IDiffingSt
         /// </summary>
         public static IDiffingStrategyCollection AddAttributeComparer(this IDiffingStrategyCollection builder)
         {
-            builder.AddMatcher(PostfixedAttributeMatcher.Match, isSpecializedMatcher: true);
-            builder.AddComparer(AttributeComparer.Compare, isSpecializedComparer: false);
-            builder.AddComparer(IgnoreAttributeComparer.Compare, isSpecializedComparer: true);
+            builder.AddMatcher(PostfixedAttributeMatcher.Match, StrategyType.Specialized);
+            builder.AddComparer(AttributeComparer.Compare, StrategyType.Generalized);
+            builder.AddComparer(IgnoreAttributeComparer.Compare, StrategyType.Specialized);
             return builder;
         }
 
@@ -38,7 +42,7 @@ public static IDiffingStrategyCollection AddAttributeComparer(this IDiffingStrat
         /// </summary>
         public static IDiffingStrategyCollection AddClassAttributeComparer(this IDiffingStrategyCollection builder)
         {
-            builder.AddComparer(ClassAttributeComparer.Compare, isSpecializedComparer: true);
+            builder.AddComparer(ClassAttributeComparer.Compare, StrategyType.Specialized);
             return builder;
         }
 
@@ -47,7 +51,7 @@ public static IDiffingStrategyCollection AddClassAttributeComparer(this IDiffing
         /// </summary>
         public static IDiffingStrategyCollection AddBooleanAttributeComparer(this IDiffingStrategyCollection builder, BooleanAttributeComparision booleanAttributeComparision)
         {
-            builder.AddComparer(new BooleanAttributeComparer(booleanAttributeComparision).Compare, isSpecializedComparer: true);
+            builder.AddComparer(new BooleanAttributeComparer(booleanAttributeComparision).Compare, StrategyType.Specialized);
             return builder;
         }
 
@@ -56,7 +60,7 @@ public static IDiffingStrategyCollection AddBooleanAttributeComparer(this IDiffi
         /// </summary>
         public static IDiffingStrategyCollection AddStyleAttributeComparer(this IDiffingStrategyCollection builder)
         {
-            builder.AddComparer(StyleAttributeComparer.Compare, isSpecializedComparer: true);
+            builder.AddComparer(StyleAttributeComparer.Compare, StrategyType.Specialized);
             return builder;
         }
     }
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreAttributeComparer.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreAttributeComparer.cs
index 26f2c03..0a5267c 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreAttributeComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreAttributeComparer.cs
@@ -1,15 +1,23 @@
 using System;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Represents the ignore attribute comparer.
+    /// </summary>
     public static class IgnoreAttributeComparer
     {
         private const string DIFF_IGNORE_POSTFIX = ":ignore";
 
+        /// <summary>
+        /// The ignore attribute comparer.
+        /// </summary>
         public static CompareResult Compare(in AttributeComparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
 
             return comparison.Control.Attribute.Name.EndsWith(DIFF_IGNORE_POSTFIX, StringComparison.OrdinalIgnoreCase)
                 ? CompareResult.Same
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreDiffAttributesFilter.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreDiffAttributesFilter.cs
index b049647..f4d73c8 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreDiffAttributesFilter.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/IgnoreDiffAttributesFilter.cs
@@ -1,15 +1,23 @@
-using System;
+using System;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Represents the ignore diff attribute filter.
+    /// </summary>
     public static class IgnoreDiffAttributesFilter
     {
         private const string DiffAttributePrefix = "diff:";
 
+        /// <summary>
+        /// The ignore diff attribute filter.
+        /// </summary>
         public static FilterDecision Filter(in AttributeComparisonSource source, FilterDecision currentDecision)
         {
-            if (currentDecision.IsExclude()) return currentDecision;
+            if (currentDecision.IsExclude())
+                return currentDecision;
 
             if (source.Attribute.Name.StartsWith(DiffAttributePrefix, StringComparison.OrdinalIgnoreCase))
                 return FilterDecision.Exclude;
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/PostfixedAttributeMatcher.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/PostfixedAttributeMatcher.cs
index 226c994..0533f5b 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/PostfixedAttributeMatcher.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/PostfixedAttributeMatcher.cs
@@ -1,10 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Represents the post fixed attribute matcher.
+    /// </summary>
     public static class PostfixedAttributeMatcher
     {
         private readonly static string[] POSTFIXES = new string[] {
@@ -13,15 +17,21 @@ public static class PostfixedAttributeMatcher
             ":regex"
         };
 
+        /// <summary>
+        /// The post fixed attribute matcher.
+        /// </summary>
         public static IEnumerable<AttributeComparison> Match(IDiffContext context, SourceMap controlSources, SourceMap testSources)
         {
-            if (controlSources is null) throw new ArgumentNullException(nameof(controlSources));
-            if (testSources is null) throw new ArgumentNullException(nameof(testSources));
+            if (controlSources is null)
+                throw new ArgumentNullException(nameof(controlSources));
+            if (testSources is null)
+                throw new ArgumentNullException(nameof(testSources));
 
             foreach (var control in controlSources.GetUnmatched())
             {
                 var ctrlName = control.Attribute.Name;
-                if (!NameHasPostfixSeparator(ctrlName)) continue;
+                if (!NameHasPostfixSeparator(ctrlName))
+                    continue;
 
                 ctrlName = RemovePostfixFromName(ctrlName);
 
diff --git a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/StyleAttributeComparer.cs b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/StyleAttributeComparer.cs
index 2eff19f..c703457 100644
--- a/src/AngleSharp.Diffing/Strategies/AttributeStrategies/StyleAttributeComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/AttributeStrategies/StyleAttributeComparer.cs
@@ -1,15 +1,23 @@
 using System;
-using AngleSharp.Diffing.Core;
+
 using AngleSharp.Css.Dom;
+using AngleSharp.Diffing.Core;
 using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.AttributeStrategies
 {
+    /// <summary>
+    /// Represents the style attribute comparer strategy.
+    /// </summary>
     public static class StyleAttributeComparer
     {
+        /// <summary>
+        /// The style attribute comparer strategy.
+        /// </summary>
         public static CompareResult Compare(in AttributeComparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
 
             return IsStyleAttributeComparison(comparison)
                 ? CompareElementStyle(comparison)
diff --git a/src/AngleSharp.Diffing/Strategies/CommentStrategies/CommentComparer.cs b/src/AngleSharp.Diffing/Strategies/CommentStrategies/CommentComparer.cs
index f2240d8..b4d8b64 100644
--- a/src/AngleSharp.Diffing/Strategies/CommentStrategies/CommentComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/CommentStrategies/CommentComparer.cs
@@ -3,12 +3,19 @@
 
 namespace AngleSharp.Diffing.Strategies.CommentStrategies
 {
+    /// <summary>
+    /// Represents the comment comparer strategy.
+    /// </summary>
     public static class CommentComparer
     {
+        /// <summary>
+        /// The comment comparer strategy.
+        /// </summary>
         public static CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
-            return comparison.Control.Node.NodeType == NodeType.Comment && comparison.AreNodeTypesEqual()
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
+            return comparison.Control.Node.NodeType == NodeType.Comment && comparison.AreNodeTypesEqual
                 ? CompareResult.Same
                 : CompareResult.Different;
         }
diff --git a/src/AngleSharp.Diffing/Strategies/CommentStrategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/CommentStrategies/DiffingStrategyPipelineBuilderExtensions.cs
index 14fd97e..c2a88c0 100644
--- a/src/AngleSharp.Diffing/Strategies/CommentStrategies/DiffingStrategyPipelineBuilderExtensions.cs
+++ b/src/AngleSharp.Diffing/Strategies/CommentStrategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -1,3 +1,4 @@
+using AngleSharp.Diffing.Strategies;
 using AngleSharp.Diffing.Strategies.CommentStrategies;
 
 namespace AngleSharp.Diffing
@@ -9,16 +10,17 @@ public static partial class DiffingStrategyPipelineBuilderExtensions
         /// </summary>
         public static IDiffingStrategyCollection IgnoreComments(this IDiffingStrategyCollection builder)
         {
-            builder.AddFilter(IgnoreCommentsFilter.Filter, true);
+            builder.AddFilter(IgnoreCommentsFilter.Filter, StrategyType.Specialized);
             return builder;
         }
 
         /// <summary>
-        /// Enables the basic comment comparer, that checks if two nodes are comment nodes.
+        /// Enables the basic comment comparer, that checks if two nodes are comment nodes. It does not check the
+        /// content of the comment.
         /// </summary>
         public static IDiffingStrategyCollection AddCommentComparer(this IDiffingStrategyCollection builder)
         {
-            builder.AddComparer(CommentComparer.Compare, isSpecializedComparer: false);
+            builder.AddComparer(CommentComparer.Compare, StrategyType.Generalized);
             return builder;
         }
     }
diff --git a/src/AngleSharp.Diffing/Strategies/CommentStrategies/IgnoreCommentsFilter.cs b/src/AngleSharp.Diffing/Strategies/CommentStrategies/IgnoreCommentsFilter.cs
index c6c34f6..56c1cba 100644
--- a/src/AngleSharp.Diffing/Strategies/CommentStrategies/IgnoreCommentsFilter.cs
+++ b/src/AngleSharp.Diffing/Strategies/CommentStrategies/IgnoreCommentsFilter.cs
@@ -1,15 +1,23 @@
-using AngleSharp.Dom;
 using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.CommentStrategies
 {
+    /// <summary>
+    /// Represents the ignore comment filter strategy.
+    /// </summary>
     public static class IgnoreCommentsFilter
     {
+        /// <summary>
+        /// The ignore comment filter strategy.
+        /// </summary>
         public static FilterDecision Filter(in ComparisonSource source, FilterDecision currentDecision)
         {
-            if (currentDecision.IsExclude()) return currentDecision;
+            if (currentDecision.IsExclude())
+                return currentDecision;
 
-            if (source.Node.NodeType == NodeType.Comment) return FilterDecision.Exclude;
+            if (source.Node.NodeType == NodeType.Comment)
+                return FilterDecision.Exclude;
 
             return currentDecision;
         }
diff --git a/src/AngleSharp.Diffing/Strategies/CompareStrategy.cs b/src/AngleSharp.Diffing/Strategies/CompareStrategy.cs
new file mode 100644
index 0000000..7041920
--- /dev/null
+++ b/src/AngleSharp.Diffing/Strategies/CompareStrategy.cs
@@ -0,0 +1,16 @@
+using AngleSharp.Diffing.Core;
+
+namespace AngleSharp.Diffing.Strategies
+{
+    /// <summary>
+    /// Represent a comparison strategy that takes matched nodes or attributes and perform a comparison of them.
+    ///
+    /// If the comparer does not have an opinion on whether two matched nodes or attributes are the same, it should
+    /// just return the current decision provided via the <paramref name="currentDecision"/> input parameter.
+    /// </summary>
+    /// <typeparam name="TComparison">The type of comparison to perform, i.e. either <see cref="AttributeComparison"/> or <see cref="Comparison"/>.</typeparam>
+    /// <param name="comparison">The comparison.</param>
+    /// <param name="currentDecision">The current decision from any previous comparer or the initial decision.</param>
+    /// <returns>The compare result.</returns>
+    public delegate CompareResult CompareStrategy<TComparison>(in TComparison comparison, CompareResult currentDecision);
+}
diff --git a/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipeline.cs b/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipeline.cs
index 29713b1..684d5c7 100644
--- a/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipeline.cs
+++ b/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipeline.cs
@@ -1,13 +1,13 @@
 using System.Collections.Generic;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies
 {
-
-    public delegate FilterDecision FilterStrategy<TSource>(in TSource source, FilterDecision currentDecision);
-    public delegate IEnumerable<TComparison> MatchStrategy<in TSources, out TComparison>(IDiffContext context, TSources controlSources, TSources testSources);
-    public delegate CompareResult CompareStrategy<TComparison>(in TComparison comparison, CompareResult currentDecision);
-
+    /// <summary>
+    /// Represents a <see cref="IDiffingStrategy"/> and a <see cref="IDiffingStrategyCollection"/>.
+    /// Use the pipeline to invoke the strategies registered within it as a pipeline, one at the time.
+    /// </summary>
     public class DiffingStrategyPipeline : IDiffingStrategy, IDiffingStrategyCollection
     {
         private readonly List<FilterStrategy<ComparisonSource>> _nodeFilters = new List<FilterStrategy<ComparisonSource>>();
@@ -17,12 +17,23 @@ public class DiffingStrategyPipeline : IDiffingStrategy, IDiffingStrategyCollect
         private readonly List<CompareStrategy<Comparison>> _nodeComparers = new List<CompareStrategy<Comparison>>();
         private readonly List<CompareStrategy<AttributeComparison>> _attrComparers = new List<CompareStrategy<AttributeComparison>>();
 
+        /// <summary>
+        /// Gets whether the pipeline have any matchers registered.
+        /// </summary>
         public bool HasMatchers => _nodeMatchers.Count > 0 && _attrsMatchers.Count > 0;
+
+        /// <summary>
+        /// Gets whether the pipeline has any comparers registered.
+        /// </summary>
         public bool HasComparers => _nodeComparers.Count > 0 && _attrComparers.Count > 0;
 
+        /// <inheritdoc/>
         public FilterDecision Filter(in ComparisonSource comparisonSource) => Filter(comparisonSource, _nodeFilters);
+
+        /// <inheritdoc/>
         public FilterDecision Filter(in AttributeComparisonSource attributeComparisonSource) => Filter(attributeComparisonSource, _attrsFilters);
 
+        /// <inheritdoc/>
         public IEnumerable<Comparison> Match(IDiffContext context, SourceCollection controlSources, SourceCollection testSources)
         {
             foreach (var matcher in _nodeMatchers)
@@ -35,6 +46,8 @@ public IEnumerable<Comparison> Match(IDiffContext context, SourceCollection cont
                 }
             }
         }
+
+        /// <inheritdoc/>
         public IEnumerable<AttributeComparison> Match(IDiffContext context, SourceMap controlAttrSources, SourceMap testAttrSources)
         {
             foreach (var matcher in _attrsMatchers)
@@ -48,99 +61,66 @@ public IEnumerable<AttributeComparison> Match(IDiffContext context, SourceMap co
             }
         }
 
+        /// <inheritdoc/>
         public CompareResult Compare(in Comparison comparison) => Compare(comparison, _nodeComparers, CompareResult.Different);
+
+        /// <inheritdoc/>
         public CompareResult Compare(in AttributeComparison comparison) => Compare(comparison, _attrComparers, CompareResult.Different);
 
-        /// <summary>
-        /// Adds a node filter to the pipeline.
-        /// Specialized filters always execute after any generalized filters in the pipeline.
-        /// That enables them to correct for the generic filters decision.
-        /// </summary>
-        /// <param name="filterStrategy"></param>
-        /// <param name="isSpecializedFilter">true if <paramref name="filterStrategy"/> is a specialized filter, false if it is a generalized filter</param>
-        public IDiffingStrategyCollection AddFilter(FilterStrategy<ComparisonSource> filterStrategy, bool isSpecializedFilter)
+        /// <inheritdoc/>
+        public IDiffingStrategyCollection AddFilter(FilterStrategy<ComparisonSource> filterStrategy, StrategyType strategyType)
         {
-            if (isSpecializedFilter)
+            if (strategyType == StrategyType.Specialized)
                 _nodeFilters.Add(filterStrategy);
             else
                 _nodeFilters.Insert(0, filterStrategy);
             return this;
         }
 
-        /// <summary>
-        /// Adds an attribute filter to the pipeline.
-        /// Specialized filters always execute after any generalized filters in the pipeline.
-        /// That enables them to correct for the generic filters decision.
-        /// </summary>
-        /// <param name="filterStrategy"></param>
-        /// <param name="isSpecializedFilter">true if <paramref name="filterStrategy"/> is a specialized filter, false if it is a generalized filter</param>
-        public IDiffingStrategyCollection AddFilter(FilterStrategy<AttributeComparisonSource> filterStrategy, bool isSpecializedFilter)
+        /// <inheritdoc/>
+        public IDiffingStrategyCollection AddFilter(FilterStrategy<AttributeComparisonSource> filterStrategy, StrategyType strategyType)
         {
-            if (isSpecializedFilter)
+            if (strategyType == StrategyType.Specialized)
                 _attrsFilters.Add(filterStrategy);
             else
                 _attrsFilters.Insert(0, filterStrategy);
             return this;
         }
 
-        /// <summary>
-        /// Adds a node matcher to the pipeline.
-        /// Specialized matchers always execute before any generalized matchers in the pipeline.
-        /// This enables the special matchers to handle special matching cases before the more simple generalized matchers process the rest.
-        /// </summary>
-        /// <param name="matchStrategy"></param>
-        /// <param name="isSpecializedMatcher">true if <paramref name="matchStrategy"/> is a specialized matcher, false if it is a generalized matcher</param>
-        public IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceCollection, Comparison> matchStrategy, bool isSpecializedMatcher)
+        /// <inheritdoc/>
+        public IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceCollection, Comparison> matchStrategy, StrategyType strategyType)
         {
-            if (isSpecializedMatcher)
+            if (strategyType == StrategyType.Specialized)
                 _nodeMatchers.Insert(0, matchStrategy);
             else
                 _nodeMatchers.Add(matchStrategy);
             return this;
         }
 
-        /// <summary>
-        /// Adds an attribute matcher to the pipeline.
-        /// Specialized matchers always execute before any generalized matchers in the pipeline.
-        /// This enables the special matchers to handle special matching cases before the more simple generalized matchers process the rest.
-        /// </summary>
-        /// <param name="matchStrategy"></param>
-        /// <param name="isSpecializedMatcher">true if <paramref name="matchStrategy"/> is a specialized matcher, false if it is a generalized matcher</param>
-        public IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceMap, AttributeComparison> matchStrategy, bool isSpecializedMatcher)
+        /// <inheritdoc/>
+        public IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceMap, AttributeComparison> matchStrategy, StrategyType strategyType)
         {
-            if (isSpecializedMatcher)
+            if (strategyType == StrategyType.Specialized)
                 _attrsMatchers.Insert(0, matchStrategy);
             else
                 _attrsMatchers.Add(matchStrategy);
             return this;
         }
 
-        /// <summary>
-        /// Adds a node comparer to the pipeline.
-        /// Specialized comparers always execute after any generalized comparers in the pipeline.
-        /// That enables them to correct for the generic comparers decision.
-        /// </summary>
-        /// <param name="compareStrategy"></param>
-        /// <param name="isSpecializedComparer">true if <paramref name="compareStrategy"/> is a specialized comparer, false if it is a generalized comparer</param>
-        public IDiffingStrategyCollection AddComparer(CompareStrategy<Comparison> compareStrategy, bool isSpecializedComparer)
+        /// <inheritdoc/>
+        public IDiffingStrategyCollection AddComparer(CompareStrategy<Comparison> compareStrategy, StrategyType strategyType)
         {
-            if (isSpecializedComparer)
+            if (strategyType == StrategyType.Specialized)
                 _nodeComparers.Add(compareStrategy);
             else
                 _nodeComparers.Insert(0, compareStrategy);
             return this;
         }
 
-        /// <summary>
-        /// Adds a attribute comparer to the pipeline.
-        /// Specialized comparers always execute after any generalized comparers in the pipeline.
-        /// That enables them to correct for the generic comparers decision.
-        /// </summary>
-        /// <param name="compareStrategy"></param>
-        /// <param name="isSpecializedComparer">true if <paramref name="compareStrategy"/> is a specialized comparer, false if it is a generalized comparer</param>
-        public IDiffingStrategyCollection AddComparer(CompareStrategy<AttributeComparison> compareStrategy, bool isSpecializedComparer)
+        /// <inheritdoc/>
+        public IDiffingStrategyCollection AddComparer(CompareStrategy<AttributeComparison> compareStrategy, StrategyType strategyType)
         {
-            if (isSpecializedComparer)
+            if (strategyType == StrategyType.Specialized)
                 _attrComparers.Add(compareStrategy);
             else
                 _attrComparers.Insert(0, compareStrategy);
diff --git a/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipelineBuilderExtensions.cs
index 5d4b685..3bd094a 100644
--- a/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipelineBuilderExtensions.cs
+++ b/src/AngleSharp.Diffing/Strategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -1,3 +1,4 @@
+using AngleSharp.Diffing.Strategies;
 using AngleSharp.Diffing.Strategies.AttributeStrategies;
 using AngleSharp.Diffing.Strategies.TextNodeStrategies;
 
@@ -16,7 +17,7 @@ public static IDiffingStrategyCollection AddDefaultOptions(this IDiffingStrategy
                 .AddSearchingNodeMatcher()
                 .AddCssSelectorMatcher()
                 .AddAttributeNameMatcher()
-                .AddElementComparer()                
+                .AddElementComparer()
                 .AddIgnoreElementSupport()
                 .AddStyleSheetComparer()
                 .AddTextComparer(WhitespaceOption.Normalize, ignoreCase: false)
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/CssSelectorElementMatcher.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/CssSelectorElementMatcher.cs
index 801c248..60ddf9c 100644
--- a/src/AngleSharp.Diffing/Strategies/ElementStrategies/CssSelectorElementMatcher.cs
+++ b/src/AngleSharp.Diffing/Strategies/ElementStrategies/CssSelectorElementMatcher.cs
@@ -1,23 +1,33 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.ElementStrategies
 {
+    /// <summary>
+    /// Represents the CSS selector element matcher.
+    /// </summary>
     public static class CssSelectorElementMatcher
     {
         private const string DIFF_MATCH_ATTR_NAME = "diff:match";
 
+        /// <summary>
+        /// The CSS selector element matcher.
+        /// </summary>
         public static IEnumerable<Comparison> Match(IDiffContext context,
                                                     SourceCollection controlSources,
                                                     SourceCollection testSources)
         {
-            if (context is null) throw new ArgumentNullException(nameof(context));
-            if (controlSources is null) throw new ArgumentNullException(nameof(controlSources));
-            if (testSources is null) throw new ArgumentNullException(nameof(testSources));
+            if (context is null)
+                throw new ArgumentNullException(nameof(context));
+            if (controlSources is null)
+                throw new ArgumentNullException(nameof(controlSources));
+            if (testSources is null)
+                throw new ArgumentNullException(nameof(testSources));
 
             foreach (var control in controlSources.GetUnmatched())
             {
@@ -36,7 +46,7 @@ public static IEnumerable<Comparison> Match(IDiffContext context,
 
         private static bool TryGetTestNode(IDiffContext context, string cssSelector, [NotNullWhen(true)]out INode? testNode)
         {
-            var searchResult = context.QueryTestRoot(cssSelector);
+            var searchResult = context.QueryTestNodes(cssSelector);
 
             testNode = searchResult.Length switch
             {
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffMatchSelectorReturnedTooManyResultsException.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffMatchSelectorReturnedTooManyResultsException.cs
index f1a137f..82fc98b 100644
--- a/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffMatchSelectorReturnedTooManyResultsException.cs
+++ b/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffMatchSelectorReturnedTooManyResultsException.cs
@@ -3,21 +3,37 @@
 
 namespace AngleSharp.Diffing.Strategies.ElementStrategies
 {
+    /// <summary>
+    /// Exception thrown when a the <see cref="CssSelectorElementMatcher"/> cannot find the
+    /// test node specified in the control node.
+    /// </summary>
     [Serializable]
     public class DiffMatchSelectorReturnedTooManyResultsException : Exception
     {
+        /// <summary>
+        /// Creates a <see cref="DiffMatchSelectorReturnedTooManyResultsException"/>.
+        /// </summary>
         public DiffMatchSelectorReturnedTooManyResultsException()
         {
         }
 
+        /// <summary>
+        /// Creates a <see cref="DiffMatchSelectorReturnedTooManyResultsException"/>.
+        /// </summary>
         public DiffMatchSelectorReturnedTooManyResultsException(string message) : base(message)
         {
         }
 
+        /// <summary>
+        /// Creates a <see cref="DiffMatchSelectorReturnedTooManyResultsException"/>.
+        /// </summary>
         public DiffMatchSelectorReturnedTooManyResultsException(string message, Exception innerException) : base(message, innerException)
         {
         }
 
+        /// <summary>
+        /// Creates a <see cref="DiffMatchSelectorReturnedTooManyResultsException"/>.
+        /// </summary>
         protected DiffMatchSelectorReturnedTooManyResultsException(SerializationInfo info, StreamingContext context) : base(info, context)
         {
         }
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffingStrategyPipelineBuilderExtensions.cs
index bca477d..a853542 100644
--- a/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffingStrategyPipelineBuilderExtensions.cs
+++ b/src/AngleSharp.Diffing/Strategies/ElementStrategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -1,3 +1,4 @@
+using AngleSharp.Diffing.Strategies;
 using AngleSharp.Diffing.Strategies.ElementStrategies;
 
 namespace AngleSharp.Diffing
@@ -9,7 +10,7 @@ public static partial class DiffingStrategyPipelineBuilderExtensions
         /// </summary>
         public static IDiffingStrategyCollection AddElementComparer(this IDiffingStrategyCollection builder)
         {
-            builder.AddComparer(ElementComparer.Compare, isSpecializedComparer: false);
+            builder.AddComparer(ElementComparer.Compare, StrategyType.Generalized);
             return builder;
         }
 
@@ -18,7 +19,7 @@ public static IDiffingStrategyCollection AddElementComparer(this IDiffingStrateg
         /// </summary>
         public static IDiffingStrategyCollection AddCssSelectorMatcher(this IDiffingStrategyCollection builder)
         {
-            builder.AddMatcher(CssSelectorElementMatcher.Match, isSpecializedMatcher: true);
+            builder.AddMatcher(CssSelectorElementMatcher.Match, StrategyType.Specialized);
             return builder;
         }
 
@@ -29,7 +30,7 @@ public static IDiffingStrategyCollection AddCssSelectorMatcher(this IDiffingStra
         /// <returns></returns>
         public static IDiffingStrategyCollection AddIgnoreElementSupport(this IDiffingStrategyCollection builder)
         {
-            builder.AddComparer(IgnoreElementComparer.Compare, isSpecializedComparer: true);
+            builder.AddComparer(IgnoreElementComparer.Compare, StrategyType.Specialized);
             return builder;
         }
     }
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/ElementComparer.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/ElementComparer.cs
index 94ab4f0..61e1dc7 100644
--- a/src/AngleSharp.Diffing/Strategies/ElementStrategies/ElementComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/ElementStrategies/ElementComparer.cs
@@ -3,12 +3,19 @@
 
 namespace AngleSharp.Diffing.Strategies.ElementStrategies
 {
+    /// <summary>
+    /// Represents the element comparer strategy.
+    /// </summary>
     public static class ElementComparer
     {
+        /// <summary>
+        /// The element comparer strategy.
+        /// </summary>
         public static CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
-            return comparison.Control.Node.NodeType == NodeType.Element && comparison.AreNodeTypesEqual()
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
+            return comparison.Control.Node.NodeType == NodeType.Element && comparison.AreNodeTypesEqual
                 ? CompareResult.Same
                 : CompareResult.Different;
         }
diff --git a/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreElementComparer.cs b/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreElementComparer.cs
index 1b9e308..0fec016 100644
--- a/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreElementComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/ElementStrategies/IgnoreElementComparer.cs
@@ -1,16 +1,23 @@
-using AngleSharp.Dom;
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.ElementStrategies
 {
+    /// <summary>
+    /// Represents the ignore element comparer.
+    /// </summary>
     public static class IgnoreElementComparer
     {
         private const string DIFF_IGNORE_ATTRIBUTE = "diff:ignore";
 
+        /// <summary>
+        /// The ignore element comparer.
+        /// </summary>
         public static CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            if (currentDecision == CompareResult.Skip)
+                return currentDecision;
 
             return ControlHasTruthyIgnoreAttribute(comparison)
                 ? CompareResult.Skip
@@ -20,8 +27,8 @@ public static CompareResult Compare(in Comparison comparison, CompareResult curr
         private static bool ControlHasTruthyIgnoreAttribute(in Comparison comparison)
         {
             return comparison.Control.Node is IElement element &&
-                   element.TryGetAttrValue(DIFF_IGNORE_ATTRIBUTE, out bool shouldIgnore) &&
-                   shouldIgnore;
+                    element.TryGetAttrValue(DIFF_IGNORE_ATTRIBUTE, out bool shouldIgnore) &&
+                    shouldIgnore;
         }
     }
 }
diff --git a/src/AngleSharp.Diffing/Strategies/FilterStrategy.cs b/src/AngleSharp.Diffing/Strategies/FilterStrategy.cs
new file mode 100644
index 0000000..b3a42e3
--- /dev/null
+++ b/src/AngleSharp.Diffing/Strategies/FilterStrategy.cs
@@ -0,0 +1,17 @@
+using AngleSharp.Diffing.Core;
+
+namespace AngleSharp.Diffing.Strategies
+{
+    /// <summary>
+    /// Represents a filter that will inspect the <typeparamref name="TSource"/> source and decide whether or not
+    /// it should be included in the comparison.
+    ///
+    /// If the filter does not have an opinion on whether source should be included or not, it should
+    /// just return the current decision provided via the <paramref name="currentDecision"/> input parameter.
+    /// </summary>
+    /// <typeparam name="TSource">The type of source to inspect, i.e. either a <see cref="AttributeComparisonSource"/> or a <see cref="ComparisonSource"/>.</typeparam>
+    /// <param name="source">The source node or attribute.</param>
+    /// <param name="currentDecision">The current decision from any previous filter or the initial decision.</param>
+    /// <returns>A filter decision.</returns>
+    public delegate FilterDecision FilterStrategy<TSource>(in TSource source, FilterDecision currentDecision);
+}
diff --git a/src/AngleSharp.Diffing/Strategies/IDiffingStrategyCollection.cs b/src/AngleSharp.Diffing/Strategies/IDiffingStrategyCollection.cs
index c46bd20..349607d 100644
--- a/src/AngleSharp.Diffing/Strategies/IDiffingStrategyCollection.cs
+++ b/src/AngleSharp.Diffing/Strategies/IDiffingStrategyCollection.cs
@@ -1,8 +1,10 @@
 using AngleSharp.Diffing.Core;
-using AngleSharp.Diffing.Strategies;
 
-namespace AngleSharp.Diffing
+namespace AngleSharp.Diffing.Strategies
 {
+    /// <summary>
+    /// Represents a collection of diffing strategies.
+    /// </summary>
     public interface IDiffingStrategyCollection
     {
         /// <summary>
@@ -11,47 +13,47 @@ public interface IDiffingStrategyCollection
         /// That enables them to correct for the generic comparers decision.
         /// </summary>
         /// <param name="compareStrategy"></param>
-        /// <param name="isSpecializedComparer">true if <paramref name="compareStrategy"/> is a specialized comparer, false if it is a generalized comparer</param>
-        IDiffingStrategyCollection AddComparer(CompareStrategy<AttributeComparison> compareStrategy, bool isSpecializedComparer = true);
+        /// <param name="strategyType">true if <paramref name="compareStrategy"/> is a specialized comparer, false if it is a generalized comparer.</param>
+        IDiffingStrategyCollection AddComparer(CompareStrategy<AttributeComparison> compareStrategy, StrategyType strategyType = StrategyType.Specialized);
         /// <summary>
         /// Adds a node comparer to the pipeline.
         /// Specialized comparers always execute after any generalized comparers in the pipeline.
         /// That enables them to correct for the generic comparers decision.
         /// </summary>
         /// <param name="compareStrategy"></param>
-        /// <param name="isSpecializedComparer">true if <paramref name="compareStrategy"/> is a specialized comparer, false if it is a generalized comparer</param>
-        IDiffingStrategyCollection AddComparer(CompareStrategy<Comparison> compareStrategy, bool isSpecializedComparer = true);
+        /// <param name="strategyType">true if <paramref name="compareStrategy"/> is a specialized comparer, false if it is a generalized comparer.</param>
+        IDiffingStrategyCollection AddComparer(CompareStrategy<Comparison> compareStrategy, StrategyType strategyType = StrategyType.Specialized);
         /// <summary>
         /// Adds an attribute filter to the pipeline.
         /// Specialized filters always execute after any generalized filters in the pipeline.
         /// That enables them to correct for the generic filters decision.
         /// </summary>
         /// <param name="filterStrategy"></param>
-        /// <param name="isSpecializedFilter">true if <paramref name="filterStrategy"/> is a specialized filter, false if it is a generalized filter</param>
-        IDiffingStrategyCollection AddFilter(FilterStrategy<AttributeComparisonSource> filterStrategy, bool isSpecializedFilter = true);
+        /// <param name="strategyType">true if <paramref name="filterStrategy"/> is a specialized filter, false if it is a generalized filter.</param>
+        IDiffingStrategyCollection AddFilter(FilterStrategy<AttributeComparisonSource> filterStrategy, StrategyType strategyType = StrategyType.Specialized);
         /// <summary>
         /// Adds a node filter to the pipeline.
         /// Specialized filters always execute after any generalized filters in the pipeline.
         /// That enables them to correct for the generic filters decision.
         /// </summary>
         /// <param name="filterStrategy"></param>
-        /// <param name="isSpecializedFilter">true if <paramref name="filterStrategy"/> is a specialized filter, false if it is a generalized filter</param>
-        IDiffingStrategyCollection AddFilter(FilterStrategy<ComparisonSource> filterStrategy, bool isSpecializedFilter = true);
+        /// <param name="strategyType">true if <paramref name="filterStrategy"/> is a specialized filter, false if it is a generalized filter.</param>
+        IDiffingStrategyCollection AddFilter(FilterStrategy<ComparisonSource> filterStrategy, StrategyType strategyType = StrategyType.Specialized);
         /// <summary>
         /// Adds a node matcher to the pipeline.
         /// Specialized matchers always execute before any generalized matchers in the pipeline.
         /// This enables the special matchers to handle special matching cases before the more simple generalized matchers process the rest.
         /// </summary>
         /// <param name="matchStrategy"></param>
-        /// <param name="isSpecializedMatcher">true if <paramref name="matchStrategy"/> is a specialized matcher, false if it is a generalized matcher</param>
-        IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceCollection, Comparison> matchStrategy, bool isSpecializedMatcher = true);
+        /// <param name="strategyType">true if <paramref name="matchStrategy"/> is a specialized matcher, false if it is a generalized matcher.</param>
+        IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceCollection, Comparison> matchStrategy, StrategyType strategyType = StrategyType.Specialized);
         /// <summary>
         /// Adds an attribute matcher to the pipeline.
         /// Specialized matchers always execute before any generalized matchers in the pipeline.
         /// This enables the special matchers to handle special matching cases before the more simple generalized matchers process the rest.
         /// </summary>
         /// <param name="matchStrategy"></param>
-        /// <param name="isSpecializedMatcher">true if <paramref name="matchStrategy"/> is a specialized matcher, false if it is a generalized matcher</param>
-        IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceMap, AttributeComparison> matchStrategy, bool isSpecializedMatcher = true);
+        /// <param name="strategyType">true if <paramref name="matchStrategy"/> is a specialized matcher, false if it is a generalized matcher.</param>
+        IDiffingStrategyCollection AddMatcher(MatchStrategy<SourceMap, AttributeComparison> matchStrategy, StrategyType strategyType = StrategyType.Specialized);
     }
 }
\ No newline at end of file
diff --git a/src/AngleSharp.Diffing/Strategies/MatchStrategy.cs b/src/AngleSharp.Diffing/Strategies/MatchStrategy.cs
new file mode 100644
index 0000000..aa173bc
--- /dev/null
+++ b/src/AngleSharp.Diffing/Strategies/MatchStrategy.cs
@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+using AngleSharp.Diffing.Core;
+
+namespace AngleSharp.Diffing.Strategies
+{
+    /// <summary>
+    /// Represents a matching strategy used to match two sets of collection of elements or two sets of attributes together into
+    /// <see cref="Comparison"/> or <see cref="AttributeComparison"/> matches.
+    ///
+    /// The matcher should only match up the sources it knows how to match up. The rest will be handled
+    /// by other matchers or be left as unmatched and reported as either missing or unexpected by the
+    /// diffing engine.
+    /// </summary>
+    /// <typeparam name="TSources">The source type, i.e. <see cref="ComparisonSource"/> or <see cref="AttributeComparisonSource"/>.</typeparam>
+    /// <typeparam name="TComparison">The resulting match type, i.e. <see cref="Comparison"/> or <see cref="AttributeComparison"/>.</typeparam>
+    /// <param name="context">A diffing context that provides methods for querying the control and test DOM tree.</param>
+    /// <param name="controlSources">The control sources.</param>
+    /// <param name="testSources">The test sources.</param>
+    /// <returns>Any matches found. Can be lazy populated enumerable, e.g. via <c>yield return</c>.</returns>
+    public delegate IEnumerable<TComparison> MatchStrategy<in TSources, out TComparison>(IDiffContext context, TSources controlSources, TSources testSources);
+}
diff --git a/src/AngleSharp.Diffing/Strategies/NodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/NodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
index 3898734..6b98552 100644
--- a/src/AngleSharp.Diffing/Strategies/NodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
+++ b/src/AngleSharp.Diffing/Strategies/NodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -1,5 +1,4 @@
-using AngleSharp.Diffing.Strategies.CommentStrategies;
-using AngleSharp.Diffing.Strategies.ElementStrategies;
+using AngleSharp.Diffing.Strategies;
 using AngleSharp.Diffing.Strategies.NodeStrategies;
 
 namespace AngleSharp.Diffing
@@ -11,7 +10,7 @@ public static partial class DiffingStrategyPipelineBuilderExtensions
         /// </summary>
         public static IDiffingStrategyCollection AddOneToOneNodeMatcher(this IDiffingStrategyCollection builder)
         {
-            builder.AddMatcher(OneToOneNodeMatcher.Match, isSpecializedMatcher: false);
+            builder.AddMatcher(OneToOneNodeMatcher.Match, StrategyType.Generalized);
             return builder;
         }
 
@@ -20,7 +19,7 @@ public static IDiffingStrategyCollection AddOneToOneNodeMatcher(this IDiffingStr
         /// </summary>
         public static IDiffingStrategyCollection AddSearchingNodeMatcher(this IDiffingStrategyCollection builder)
         {
-            builder.AddMatcher(ForwardSearchingNodeMatcher.Match, isSpecializedMatcher: false);
+            builder.AddMatcher(ForwardSearchingNodeMatcher.Match, StrategyType.Generalized);
             return builder;
         }
     }
diff --git a/src/AngleSharp.Diffing/Strategies/NodeStrategies/ForwardSearchingNodeMatcher.cs b/src/AngleSharp.Diffing/Strategies/NodeStrategies/ForwardSearchingNodeMatcher.cs
index 502787a..c506514 100644
--- a/src/AngleSharp.Diffing/Strategies/NodeStrategies/ForwardSearchingNodeMatcher.cs
+++ b/src/AngleSharp.Diffing/Strategies/NodeStrategies/ForwardSearchingNodeMatcher.cs
@@ -1,18 +1,27 @@
 using System;
 using System.Collections.Generic;
+
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Extensions;
 
 namespace AngleSharp.Diffing.Strategies.NodeStrategies
 {
+    /// <summary>
+    /// Represents the forward searching node matcher strategy.
+    /// </summary>
     public static class ForwardSearchingNodeMatcher
     {
+        /// <summary>
+        /// The forward searching node matcher strategy.
+        /// </summary>
         public static IEnumerable<Comparison> Match(IDiffContext context,
                                              SourceCollection controlSources,
                                              SourceCollection testSources)
         {
-            if (controlSources is null) throw new ArgumentNullException(nameof(controlSources));
-            if (testSources is null) throw new ArgumentNullException(nameof(testSources));
+            if (controlSources is null)
+                throw new ArgumentNullException(nameof(controlSources));
+            if (testSources is null)
+                throw new ArgumentNullException(nameof(testSources));
 
             var lastMatchedTestNodeIndex = -1;
             foreach (var control in controlSources.GetUnmatched())
diff --git a/src/AngleSharp.Diffing/Strategies/NodeStrategies/OneToOneNodeMatcher.cs b/src/AngleSharp.Diffing/Strategies/NodeStrategies/OneToOneNodeMatcher.cs
index 059c9e4..36acc34 100644
--- a/src/AngleSharp.Diffing/Strategies/NodeStrategies/OneToOneNodeMatcher.cs
+++ b/src/AngleSharp.Diffing/Strategies/NodeStrategies/OneToOneNodeMatcher.cs
@@ -1,17 +1,26 @@
 using System;
 using System.Collections.Generic;
+
 using AngleSharp.Diffing.Core;
 
 namespace AngleSharp.Diffing.Strategies.NodeStrategies
 {
+    /// <summary>
+    /// Represents the one to one node matcher.
+    /// </summary>
     public static class OneToOneNodeMatcher
     {
+        /// <summary>
+        /// The one to one node matcher.
+        /// </summary>
         public static IEnumerable<Comparison> Match(IDiffContext context,
                                                     SourceCollection controlSources,
                                                     SourceCollection testSources)
         {
-            if (controlSources is null) throw new ArgumentNullException(nameof(controlSources));
-            if (testSources is null) throw new ArgumentNullException(nameof(testSources));
+            if (controlSources is null)
+                throw new ArgumentNullException(nameof(controlSources));
+            if (testSources is null)
+                throw new ArgumentNullException(nameof(testSources));
 
             using var controlsEnumerator = controlSources.GetUnmatched().GetEnumerator();
             using var testsEnumerator = testSources.GetUnmatched().GetEnumerator();
diff --git a/src/AngleSharp.Diffing/Strategies/StrategyType.cs b/src/AngleSharp.Diffing/Strategies/StrategyType.cs
new file mode 100644
index 0000000..33a199a
--- /dev/null
+++ b/src/AngleSharp.Diffing/Strategies/StrategyType.cs
@@ -0,0 +1,17 @@
+namespace AngleSharp.Diffing.Strategies
+{
+    /// <summary>
+    /// Represents a type of strategy in a <see cref="IDiffingStrategyCollection"/> type.
+    /// </summary>
+    public enum StrategyType
+    {
+        /// <summary>
+        /// Indicates the strategy is a general strategy, that targets all nodes or attributes.
+        /// </summary>
+        Generalized,
+        /// <summary>
+        /// Indicates that the strategy is a specialized strategy, that only targets specific or select nodes or attributes.
+        /// </summary>
+        Specialized
+    }
+}
\ No newline at end of file
diff --git a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
index 4c9ca0e..60ae60e 100644
--- a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
+++ b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/DiffingStrategyPipelineBuilderExtensions.cs
@@ -1,3 +1,4 @@
+using AngleSharp.Diffing.Strategies;
 using AngleSharp.Diffing.Strategies.TextNodeStrategies;
 
 namespace AngleSharp.Diffing
@@ -9,8 +10,8 @@ public static partial class DiffingStrategyPipelineBuilderExtensions
         /// </summary>
         public static IDiffingStrategyCollection AddTextComparer(this IDiffingStrategyCollection builder, WhitespaceOption whitespaceOption, bool ignoreCase)
         {
-            builder.AddFilter(new TextNodeFilter(whitespaceOption).Filter, isSpecializedFilter: true);
-            builder.AddComparer(new TextNodeComparer(whitespaceOption, ignoreCase).Compare, isSpecializedComparer: true);
+            builder.AddFilter(new TextNodeFilter(whitespaceOption).Filter, StrategyType.Specialized);
+            builder.AddComparer(new TextNodeComparer(whitespaceOption, ignoreCase).Compare, StrategyType.Specialized);
             return builder;
         }
 
@@ -19,7 +20,7 @@ public static IDiffingStrategyCollection AddTextComparer(this IDiffingStrategyCo
         /// </summary>
         public static IDiffingStrategyCollection AddStyleSheetComparer(this IDiffingStrategyCollection builder)
         {
-            builder.AddComparer(StyleSheetTextNodeComparer.Compare, isSpecializedComparer: true);
+            builder.AddComparer(StyleSheetTextNodeComparer.Compare, StrategyType.Specialized);
             return builder;
         }
     }
diff --git a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/StyleSheetTextNodeComparer.cs b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/StyleSheetTextNodeComparer.cs
index 242181d..cd167db 100644
--- a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/StyleSheetTextNodeComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/StyleSheetTextNodeComparer.cs
@@ -1,16 +1,23 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
-using AngleSharp;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Core;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.TextNodeStrategies
 {
+    /// <summary>
+    /// Represents the stylesheet text node comparer.
+    /// </summary>
     public static class StyleSheetTextNodeComparer
     {
+        /// <summary>
+        /// The stylesheet text node comparer.
+        /// </summary>
         public static CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
             if (TryGetStyleDeclaretions(comparison, out var controlStyles, out var testStyles))
                 return Compare(controlStyles, testStyles);
             else
diff --git a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeComparer.cs b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeComparer.cs
index 55518e4..e951b12 100644
--- a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeComparer.cs
+++ b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeComparer.cs
@@ -1,11 +1,15 @@
 using System;
 using System.Text.RegularExpressions;
-using AngleSharp.Dom;
+
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.TextNodeStrategies
 {
+    /// <summary>
+    /// Represents the text node comparer strategy.
+    /// </summary>
     public class TextNodeComparer
     {
         private static readonly string[] DefaultPreserveElement = new string[] { "PRE", "SCRIPT", "STYLE" };
@@ -14,19 +18,32 @@ public class TextNodeComparer
         private const string REGEX_ATTR_NAME = "diff:regex";
         private static readonly Regex WhitespaceReplace = new Regex(@"\s+", RegexOptions.Compiled | RegexOptions.CultureInvariant, TimeSpan.FromSeconds(5));
 
+        /// <summary>
+        /// Gets the whitespace option of the comparer instance.
+        /// </summary>
         public WhitespaceOption Whitespace { get; }
 
+        /// <summary>
+        /// Gets whether the comparer has been configured to ignore case.
+        /// </summary>
         public bool IgnoreCase { get; }
 
+        /// <summary>
+        /// Instantiates a <see cref="TextNodeComparer"/> with the provided configuration.
+        /// </summary>
         public TextNodeComparer(WhitespaceOption option = WhitespaceOption.Preserve, bool ignoreCase = false)
         {
             Whitespace = option;
             IgnoreCase = ignoreCase;
         }
 
+        /// <summary>
+        /// The text node comparer strategy.
+        /// </summary>
         public CompareResult Compare(in Comparison comparison, CompareResult currentDecision)
         {
-            if (currentDecision.IsSameOrSkip()) return currentDecision;
+            if (currentDecision.IsSameOrSkip())
+                return currentDecision;
 
             if (comparison.TryGetNodesAsType<IText>(out var controlTextNode, out var testTextNode))
                 return Compare(controlTextNode, testTextNode);
@@ -81,7 +98,7 @@ private static bool GetIsRegexComparison(IText controlTextNode)
         private WhitespaceOption GetWhitespaceOption(IText textNode)
         {
             var parent = textNode.ParentElement;
-            foreach(var tagName in DefaultPreserveElement)
+            foreach (var tagName in DefaultPreserveElement)
             {
                 if (parent.NodeName.Equals(tagName, StringComparison.Ordinal))
                 {
diff --git a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeFilter.cs b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeFilter.cs
index 3f7d3c9..71d5b33 100644
--- a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeFilter.cs
+++ b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/TextNodeFilter.cs
@@ -1,25 +1,45 @@
-using System;
-using AngleSharp.Dom;
+using System;
+
 using AngleSharp.Diffing.Core;
 using AngleSharp.Diffing.Extensions;
+using AngleSharp.Dom;
 
 namespace AngleSharp.Diffing.Strategies.TextNodeStrategies
 {
+    /// <summary>
+    /// Represents the text node filter strategy.
+    /// </summary>
     public class TextNodeFilter
     {
         private const string PRE_ELEMENTNAME = "PRE";
+        private const string SCRIPT_ELEMENTNAME = "SCRIPT";
+        private const string STYLE_ELEMENTNAME = "STYLE";
         private const string WHITESPACE_ATTR_NAME = "diff:whitespace";
 
+        /// <summary>
+        /// Gets the whitespace option of the filter instance.
+        /// </summary>
         public WhitespaceOption Whitespace { get; }
 
+        /// <summary>
+        /// Creates a text node filter with the provided option.
+        /// </summary>
+        /// <param name="option"></param>
         public TextNodeFilter(WhitespaceOption option)
         {
             Whitespace = option;
         }
 
+        /// <summary>
+        /// The text node filter strategy.
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="currentDecision"></param>
+        /// <returns></returns>
         public FilterDecision Filter(in ComparisonSource source, FilterDecision currentDecision)
         {
-            if (currentDecision.IsExclude()) return currentDecision;
+            if (currentDecision.IsExclude())
+                return currentDecision;
             return source.Node is IText textNode ? Filter(textNode) : currentDecision;
         }
 
@@ -35,7 +55,9 @@ private WhitespaceOption GetWhitespaceOption(IText textNode)
         {
             var parent = textNode.ParentElement;
 
-            if (parent.NodeName.Equals(PRE_ELEMENTNAME, StringComparison.Ordinal))
+            if (parent.NodeName.Equals(PRE_ELEMENTNAME, StringComparison.Ordinal) ||
+                parent.NodeName.Equals(SCRIPT_ELEMENTNAME, StringComparison.Ordinal) ||
+                parent.NodeName.Equals(STYLE_ELEMENTNAME, StringComparison.Ordinal))
             {
                 return parent.TryGetAttrValue(WHITESPACE_ATTR_NAME, out WhitespaceOption option)
                     ? option
diff --git a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/WhitespaceOption.cs b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/WhitespaceOption.cs
index c672195..7663379 100644
--- a/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/WhitespaceOption.cs
+++ b/src/AngleSharp.Diffing/Strategies/TextNodeStrategies/WhitespaceOption.cs
@@ -1,9 +1,22 @@
 namespace AngleSharp.Diffing.Strategies.TextNodeStrategies
 {
+    /// <summary>
+    /// Represents a whitespace diffing option.
+    /// </summary>
     public enum WhitespaceOption
     {
+        /// <summary>
+        /// Does not change or filter out any whitespace in text nodes the control and test HTML.
+        /// </summary>
         Preserve = 0,
+        /// <summary>
+        /// Using this option filters out all text nodes that only consist of whitespace characters.
+        /// </summary>
         RemoveWhitespaceNodes,
+        /// <summary>
+        /// Using this option will trim all text nodes and replace two or more whitespace characters with a single space character.
+        /// This option implicitly includes the <see cref="RemoveWhitespaceNodes" /> option.
+        /// </summary>
         Normalize
     }
 }