diff --git a/DistillNET/DistillNET.csproj b/DistillNET/DistillNET.csproj
index f0adcee..b9f57a0 100644
--- a/DistillNET/DistillNET.csproj
+++ b/DistillNET/DistillNET.csproj
@@ -9,13 +9,13 @@
     <RepositoryUrl>https://github.com/TechnikEmpire/DistillNET</RepositoryUrl>
     <Description>DistillNET is a library for matching and filtering HTTP requests URLs using the Adblock Plus Filter format.</Description>
     <Copyright>Copyright © 2017 - 2018 Jesse Nicholson</Copyright>
-    <Version>1.6.2</Version>
+    <Version>1.6.3</Version>
     <Authors>Jesse Nicholson</Authors>
     <Company>Technik Empire</Company>
     <PackageTags>DistillNET Adblock AdblockPlus Adblock-Plus URL-Filter URL-Filtering Content-Filter Filter</PackageTags>
-    <PackageReleaseNotes>Fixes an issue where cache is not built on an instance where no rules are ever loaded.</PackageReleaseNotes>
-    <AssemblyVersion>1.6.2.0</AssemblyVersion>
-    <FileVersion>1.6.2.0</FileVersion>
+    <PackageReleaseNotes>Upgrades dependencies to latest version.</PackageReleaseNotes>
+    <AssemblyVersion>1.6.3.0</AssemblyVersion>
+    <FileVersion>1.6.3.0</FileVersion>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
@@ -27,8 +27,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Data.SQLite" Version="2.1.0" />
-    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="2.1.0" />
+    <PackageReference Include="Microsoft.Data.SQLite" Version="2.2.0" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="2.2.0" />
   </ItemGroup>
 
 </Project>
diff --git a/DistillNET/DistillNET/AbpFormatRuleParser.cs b/DistillNET/DistillNET/AbpFormatRuleParser.cs
index 84993cf..68f65ae 100644
--- a/DistillNET/DistillNET/AbpFormatRuleParser.cs
+++ b/DistillNET/DistillNET/AbpFormatRuleParser.cs
@@ -10,6 +10,7 @@
 using DistillNET.Extensions;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace DistillNET
 {
@@ -94,6 +95,7 @@ int IEqualityComparer<string>.GetHashCode(string obj)
             { "~elemhide", UrlFilter.UrlFilterOptions.ExceptElemHide },
             { "other", UrlFilter.UrlFilterOptions.Other },
             { "~other", UrlFilter.UrlFilterOptions.ExceptOther },
+            #pragma warning disable CS0618 // Type or member is obsolete
             { "media", UrlFilter.UrlFilterOptions.Media },
             { "~media", UrlFilter.UrlFilterOptions.ExceptMedia },
             { "font", UrlFilter.UrlFilterOptions.Font },
@@ -105,6 +107,7 @@ int IEqualityComparer<string>.GetHashCode(string obj)
             { "generichide", UrlFilter.UrlFilterOptions.GenericHide },
             { "genericblock", UrlFilter.UrlFilterOptions.GenericBlock },
             { "ping", UrlFilter.UrlFilterOptions.Ping }
+            #pragma warning restore CS0618 // Type or member is obsolete
         };
 
         /// <summary>
@@ -114,8 +117,13 @@ int IEqualityComparer<string>.GetHashCode(string obj)
         private static readonly char[] s_anchoredEndIndicators = new[] { '/', ':', '?', '=', '&', '*', '^' };
 
         /// <summary>
+        /// Constructs a new instance.
         /// </summary>
         /// <param name="rule">
+        /// The rule string.
+        /// </param>
+        /// <param name="categoryId">
+        /// The category ID to assign to this rule.
         /// </param>
         /// <returns>
         /// </returns>
@@ -169,7 +177,7 @@ public Filter ParseAbpFormattedRule(string rule, short categoryId)
                 {
                     return ParseCssSelector(rule, cssSelectorStart, isException, categoryId);
                 }
-                catch(ArgumentOutOfRangeException e)
+                catch (ArgumentOutOfRangeException)
                 {
                     throw new ArgumentException("Out of range exception while parsing CSS selector rule. Rule must be malformed.", nameof(rule));
                 }
@@ -179,7 +187,7 @@ public Filter ParseAbpFormattedRule(string rule, short categoryId)
             {   
                 return ParseUrlFilter(rule, optionsStart, hasOptions, isException, categoryId);
             }
-            catch(ArgumentOutOfRangeException e)
+            catch (ArgumentOutOfRangeException)
             {
                 throw new ArgumentException("Out of range exception while parsing filter rule. Rule must be malformed.", nameof(rule));
             }
@@ -198,6 +206,9 @@ public Filter ParseAbpFormattedRule(string rule, short categoryId)
         /// Whether or not this rule is an exception rule. It is obviously assumed that this has been
         /// predetermined externally and this will not be determined internally.
         /// </param>
+        /// <param name="categoryId">
+        /// The category ID to assign to this rule.
+        /// </param>
         /// <returns>
         /// A css selector filtering class instance built from the parsed rule.
         /// </returns>
@@ -205,7 +216,7 @@ private Filter ParseCssSelector(string rule, int selectorStartOffset, bool isExc
         {
             var originalRuleCopy = rule;
 
-            string[] applicableDomains = null;
+            List<string> applicableDomains = null;
 
             if(selectorStartOffset > 0)
             {
@@ -213,7 +224,7 @@ private Filter ParseCssSelector(string rule, int selectorStartOffset, bool isExc
                 // indicates that it's a domain-specific CSS selector rule. As such, one or more
                 // domains, separated by a comma character, will preceed the actual CSS selector
                 // rule.
-                applicableDomains = rule.Substring(0, selectorStartOffset).Split(s_optionsDelim, StringSplitOptions.None);
+                applicableDomains = rule.Substring(0, selectorStartOffset).Split(s_optionsDelim, StringSplitOptions.None).ToList();
             }
 
             // If it's an exception, we need to cut off three characters from the start of the CSS
diff --git a/DistillNET/DistillNET/FilterDbCollection.cs b/DistillNET/DistillNET/FilterDbCollection.cs
index 101936a..740427e 100644
--- a/DistillNET/DistillNET/FilterDbCollection.cs
+++ b/DistillNET/DistillNET/FilterDbCollection.cs
@@ -550,14 +550,15 @@ private List<string> GetAllPossibleSubdomains(string inputDomain)
             return retVal;
         }
 
-        public IEnumerable<Filter> GetFiltersForRequest(Uri requestString, string referer = "")
-        {
-            return null;
-        }
-
         #region IDisposable Support
         private bool disposedValue = false; // To detect redundant calls
 
+        /// <summary>
+        /// Disposes the object.
+        /// </summary>
+        /// <param name="disposing">
+        /// Disposing val.
+        /// </param>
         protected virtual void Dispose(bool disposing)
         {
             if(!disposedValue)
@@ -585,6 +586,9 @@ protected virtual void Dispose(bool disposing)
         // }
 
         // This code added to correctly implement the disposable pattern.
+        /// <summary>
+        /// Disposes the object.
+        /// </summary>
         public void Dispose()
         {
             // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
diff --git a/DistillNET/DistillNET/HtmlFilter.cs b/DistillNET/DistillNET/HtmlFilter.cs
index bf9ad90..71ca3a6 100644
--- a/DistillNET/DistillNET/HtmlFilter.cs
+++ b/DistillNET/DistillNET/HtmlFilter.cs
@@ -6,21 +6,56 @@
  */
 
 using System;
-using System.Diagnostics;
+using System.Collections.Generic;
 
 namespace DistillNET
 {
+    /// <summary>
+    /// The HtmlFilter is a class that represents a CSS selector that can be removed or whitelisted
+    /// in source HTML.
+    /// </summary>
     public class HtmlFilter : Filter
     {
         /// <summary>
-        /// Gets an array of all domains that this CSS selector rule applies to. In the event that
-        /// this array is empty, the rule applies globally, to all domains.
+        /// Gets a list of all referers that this HTML filter rule applies to. In the event that this
+        /// array is empty, the referer field on requests will not be checked.
         /// </summary>
-        public string[] ApplicableDomains
+        public List<string> ApplicableReferers
         {
             get;
             private set;
-        } = new string[0];
+        }
+
+        /// <summary>
+        /// Gets a list of all referers that this HTML filter rule applies to. In the event that this
+        /// array is empty, the referer field on requests will not be checked.
+        /// </summary>
+        public List<string> ExceptReferers
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Gets a list of all domains that this HTML filter rule applies to. In the event that this
+        /// array is empty, the rule applies globally, to all domains.
+        /// </summary>
+        public List<string> ApplicableDomains
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Gets a list of all domains that this HTML filter should not be applied to. In the event
+        /// that this array is empty, the rule applies either globally, or exclusively to the list of
+        /// applicable domains, if that property is not empty.
+        /// </summary>
+        public List<string> ExceptionDomains
+        {
+            get;
+            private set;
+        }
 
         /// <summary>
         /// Gets the raw CSS selector rule string.
@@ -49,14 +84,17 @@ public string CssSelector
         /// Whether or not this CSS selector rule is an exception. Exception rules protect matching
         /// content from being filtered out.
         /// </param>
+        /// <param name="categoryId">
+        /// The category ID to assign to this rule.
+        /// </param>
         /// <exception cref="ArgumentException">
         /// If compiled with TE_FILTERING_VERIFY_RULE_DATA, the cssSelector parameter will undergo
         /// checks to ensure that it is not null, empty or whitespace. If these checks are performed
         /// and any of those conditions is true, the constructor will throw this exception.
         /// </exception>
-        internal HtmlFilter(string originalRule, string[] applicableDomains, string cssSelector, bool isException, short categoryId) : base(originalRule, isException, categoryId)
+        internal HtmlFilter(string originalRule, List<string> applicableDomains, string cssSelector, bool isException, short categoryId) : base(originalRule, isException, categoryId)
         {
-            if(applicableDomains != null && applicableDomains.Length > 0)
+            if (applicableDomains != null && applicableDomains.Count > 0)
             {
                 ApplicableDomains = applicableDomains;
             }
@@ -72,13 +110,13 @@ internal HtmlFilter(string originalRule, string[] applicableDomains, string cssS
             CssSelector = cssSelector;
         }
 
+        /// <summary>
+        /// Removes verbose data from the constructed instance.
+        /// </summary>
         public override void TrimExcessData()
         {
-            if(this.ApplicableDomains != null)
-            {
-                Array.Clear(this.ApplicableDomains, 0, this.ApplicableDomains.Length);
-                this.ApplicableDomains = new string[0];
-            }
+            ApplicableDomains.Clear();
+            ExceptionDomains.Clear();
 
             OriginalRule = string.Empty;
         }
diff --git a/DistillNET/DistillNET/UrlFilter.cs b/DistillNET/DistillNET/UrlFilter.cs
index 69ff994..0bef24a 100644
--- a/DistillNET/DistillNET/UrlFilter.cs
+++ b/DistillNET/DistillNET/UrlFilter.cs
@@ -260,6 +260,17 @@ public enum UrlFilterOptions : long
         /// </summary>
         public class UrlFilteringRuleFragment
         {
+            /// <summary>
+            /// Gets whether or not the supplied URI matches this rule segment.
+            /// </summary>
+            /// <param name="source">
+            /// The URI.
+            /// </param>
+            /// <param name="lastPosition">
+            /// The current position in scan.
+            /// </param>
+            /// <returns>
+            /// </returns>
             public virtual int IsMatch(Uri source, int lastPosition)
             {
                 return -1;
@@ -272,6 +283,17 @@ public virtual int IsMatch(Uri source, int lastPosition)
         /// </summary>
         public class WildcardFragment : UrlFilteringRuleFragment
         {
+            /// <summary>
+            /// Gets whether or not the supplied URI matches this rule segment.
+            /// </summary>
+            /// <param name="source">
+            /// The URI.
+            /// </param>
+            /// <param name="lastPosition">
+            /// The current position in scan.
+            /// </param>
+            /// <returns>
+            /// </returns>
             public override int IsMatch(Uri source, int lastPosition)
             {
                 var stepOne = lastPosition + 1;
@@ -290,8 +312,22 @@ public override int IsMatch(Uri source, int lastPosition)
         /// </summary>
         public class SeparatorFragment : UrlFilteringRuleFragment
         {
+            /// <summary>
+            /// An array of characters that qualify as separator characters.
+            /// </summary>
             public static readonly char[] SeparatorChars = new[] { '/', ':', '?', '=', '&' };
 
+            /// <summary>
+            /// Gets whether or not the supplied URI matches this rule segment.
+            /// </summary>
+            /// <param name="source">
+            /// The URI.
+            /// </param>
+            /// <param name="lastPosition">
+            /// The current position in scan.
+            /// </param>
+            /// <returns>
+            /// </returns>
             public override int IsMatch(Uri source, int lastPosition)
             {
                 if(lastPosition > source.AbsoluteUri.Length)
@@ -309,17 +345,29 @@ public override int IsMatch(Uri source, int lastPosition)
         /// </summary>
         public class StringFragment : UrlFilteringRuleFragment
         {
+            /// <summary>
+            /// Gets whether or not this rule ignores case during comparison.
+            /// </summary>
             public bool ICase
             {
                 get;
                 private set;
             } = true;
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
+            /// <param name="iCase">
+            /// Whether or not this rule ignores case during comparison.
+            /// </param>
             public StringFragment(bool iCase)
             {
                 ICase = iCase;
             }
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
             public StringFragment()
             {
             }
@@ -331,21 +379,47 @@ public StringFragment()
         /// </summary>
         public class AnchoredAddressFragment : StringFragment
         {
+            /// <summary>
+            /// Gets the request segment to be matched.
+            /// </summary>
             public string Request
             {
                 get;
                 private set;
             } = string.Empty;
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
+            /// <param name="request">
+            /// The request segment to match.
+            /// </param>
+            /// <param name="iCase">
+            /// Whether or not matching will ignore case.
+            /// </param>
             public AnchoredAddressFragment(string request, bool iCase) : base(iCase)
             {
                 Request = request;
             }
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
             public AnchoredAddressFragment()
             {
             }
 
+            /// <summary>
+            /// Gets whether or not the supplied URI matches this rule segment.
+            /// </summary>
+            /// <param name="source">
+            /// The URI.
+            /// </param>
+            /// <param name="lastPosition">
+            /// The current position in scan.
+            /// </param>
+            /// <returns>
+            /// </returns>
             public override int IsMatch(Uri source, int lastPosition)
             {
                 // Anchored stuff like this always starts at position zero.
@@ -385,21 +459,44 @@ public override int IsMatch(Uri source, int lastPosition)
         /// </summary>
         public class AnchoredDomainFragment : UrlFilteringRuleFragment
         {
+            /// <summary>
+            /// Gets the domain that should be matched.
+            /// </summary>
             public string Domain
             {
                 get;
                 private set;
             } = string.Empty;
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
+            /// <param name="domain">
+            /// The domain that should be matched.
+            /// </param>
             public AnchoredDomainFragment(string domain)
             {
                 Domain = domain;
             }
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
             public AnchoredDomainFragment()
             {
             }
 
+            /// <summary>
+            /// Gets whether or not the supplied URI matches this rule segment.
+            /// </summary>
+            /// <param name="source">
+            /// The URI.
+            /// </param>
+            /// <param name="lastPosition">
+            /// The current position in scan.
+            /// </param>
+            /// <returns>
+            /// </returns>
             public override int IsMatch(Uri source, int lastPosition)
             {
                 if(Domain.Length > source.Host.Length)
@@ -423,21 +520,47 @@ public override int IsMatch(Uri source, int lastPosition)
         /// </summary>
         public class StringLiteralFragment : StringFragment
         {
+            /// <summary>
+            /// Gets the value to be matched.
+            /// </summary>
             public string Value
             {
                 get;
                 private set;
             } = string.Empty;
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
+            /// <param name="value">
+            /// The value to be matched.
+            /// </param>
+            /// <param name="iCase">
+            /// Whether or not case should be ignored during matching.
+            /// </param>
             public StringLiteralFragment(string value, bool iCase) : base(iCase)
             {
                 Value = value;
             }
 
+            /// <summary>
+            /// Constructs a new instance.
+            /// </summary>
             public StringLiteralFragment()
             {
             }
 
+            /// <summary>
+            /// Gets whether or not the supplied URI matches this rule segment.
+            /// </summary>
+            /// <param name="source">
+            /// The URI.
+            /// </param>
+            /// <param name="lastPosition">
+            /// The current position in scan.
+            /// </param>
+            /// <returns>
+            /// </returns>
             public override int IsMatch(Uri source, int lastPosition)
             {
                 if(lastPosition > source.AbsoluteUri.Length)
@@ -462,7 +585,7 @@ public override int IsMatch(Uri source, int lastPosition)
         }
 
         /// <summary>
-        /// Gets a hashset of all referers that this URL filter rule applies to. In the event that
+        /// Gets a list of all referers that this URL filter rule applies to. In the event that
         /// this array is empty, the referer field on requests will not be checked.
         /// </summary>
         public List<string> ApplicableReferers
@@ -472,7 +595,7 @@ public List<string> ApplicableReferers
         }
 
         /// <summary>
-        /// Gets a hashset of all referers that this URL filter rule applies to. In the event that
+        /// Gets a list of all referers that this URL filter rule applies to. In the event that
         /// this array is empty, the referer field on requests will not be checked.
         /// </summary>
         public List<string> ExceptReferers
@@ -482,7 +605,7 @@ public List<string> ExceptReferers
         }
 
         /// <summary>
-        /// Gets a hashset of all domains that this URL filter rule applies to. In the event that
+        /// Gets a list of all domains that this URL filter rule applies to. In the event that
         /// this array is empty, the rule applies globally, to all domains.
         /// </summary>
         public List<string> ApplicableDomains
@@ -492,7 +615,7 @@ public List<string> ApplicableDomains
         }
 
         /// <summary>
-        /// Gets a hashset of all domains that this URL filter should not be applied to. In the event
+        /// Gets a list of all domains that this URL filter should not be applied to. In the event
         /// that this array is empty, the rule applies either globally, or exclusively to the list of
         /// applicable domains, if that property is not empty.
         /// </summary>
@@ -540,25 +663,31 @@ public List<UrlFilteringRuleFragment> Parts
         /// are meant to be constructed outside of the AbpFormatRuleParser class.
         /// </summary>
         /// <param name="originalRule">
-        /// The original rule string used to build this filter. 
+        /// The original rule string used to build this filter.
         /// </param>
         /// <param name="parts">
-        /// The UrlFilterFragment parts that make up this filter. 
+        /// The UrlFilterFragment parts that make up this filter.
         /// </param>
         /// <param name="options">
-        /// The filter options. 
+        /// The filter options.
         /// </param>
         /// <param name="applicableDomains">
-        /// Domains that the filter should be applied to. 
+        /// Domains that the filter should be applied to.
         /// </param>
         /// <param name="exceptionDomains">
-        /// Domains that the filter should not be applied to. 
+        /// Domains that the filter should not be applied to.
+        /// </param>
+        /// <param name="applicableReferers">
+        /// Referers that the filter rule should be applied to.
+        /// </param>
+        /// <param name="exceptionReferers">
+        /// Referers that the filter rule should not be applied to.
         /// </param>
         /// <param name="isException">
-        /// Whether or not the filter is an exception, that is to say, a whitelisting filter. 
+        /// Whether or not the filter is an exception, that is to say, a whitelisting filter.
         /// </param>
         /// <param name="categoryId">
-        /// The category ID of the category this filter belongs to. 
+        /// The category ID of the category this filter belongs to.
         /// </param>
         internal UrlFilter(string originalRule, List<UrlFilteringRuleFragment> parts, UrlFilterOptions options, List<string> applicableDomains, List<string> exceptionDomains, List<string> applicableReferers, List<string> exceptionReferers, bool isException, short categoryId) : base(originalRule, isException, categoryId)
         {
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
index f4af694..aac01a9 100644
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@@ -66,7 +66,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.Data.SQLite">
-      <Version>2.1.0-rc1-final</Version>
+      <Version>2.2.0</Version>
     </PackageReference>
   </ItemGroup>
   <ItemGroup>