Convert the blocklist helper to Kotlin. https://redmine.stoutner.com/issues/783
authorSoren Stoutner <soren@stoutner.com>
Sat, 28 May 2022 23:44:55 +0000 (16:44 -0700)
committerSoren Stoutner <soren@stoutner.com>
Sat, 28 May 2022 23:44:55 +0000 (16:44 -0700)
app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.java [deleted file]
app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.kt [new file with mode: 0644]
app/src/main/res/values-de/strings.xml
app/src/main/res/values-es/strings.xml
app/src/main/res/values-fr/strings.xml

diff --git a/app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.java b/app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.java
deleted file mode 100644 (file)
index c194ce6..0000000
+++ /dev/null
@@ -1,2121 +0,0 @@
-/*
- * Copyright © 2018-2019,2021-2022 Soren Stoutner <soren@stoutner.com>.
- *
- * This file is part of Privacy Browser Android <https://www.stoutner.com/privacy-browser-android>.
- *
- * Privacy Browser Android is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Privacy Browser Android is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Privacy Browser Android.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.stoutner.privacybrowser.helpers;
-
-import android.content.res.AssetManager;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Pattern;
-
-public class BlocklistHelper {
-    // Describe the schema of the string array in each entry of the resource requests array list.
-    public final static int REQUEST_DISPOSITION = 0;
-    public final static int REQUEST_URL = 1;
-    public final static int REQUEST_BLOCKLIST = 2;
-    public final static int REQUEST_SUBLIST = 3;
-    public final static int REQUEST_BLOCKLIST_ENTRIES = 4;
-    public final static int REQUEST_BLOCKLIST_ORIGINAL_ENTRY = 5;
-
-    // The request disposition options.
-    public final static String REQUEST_DEFAULT = "0";
-    public final static String REQUEST_ALLOWED = "1";
-    public final static String REQUEST_THIRD_PARTY = "2";
-    public final static String REQUEST_BLOCKED = "3";
-
-    // The whitelists.
-    public final static String MAIN_WHITELIST = "1";
-    public final static String FINAL_WHITELIST = "2";
-    public final static String DOMAIN_WHITELIST = "3";
-    public final static String DOMAIN_INITIAL_WHITELIST = "4";
-    public final static String DOMAIN_FINAL_WHITELIST = "5";
-    public final static String THIRD_PARTY_WHITELIST = "6";
-    public final static String THIRD_PARTY_DOMAIN_WHITELIST = "7";
-    public final static String THIRD_PARTY_DOMAIN_INITIAL_WHITELIST = "8";
-
-    // The blacklists.
-    public final static String MAIN_BLACKLIST = "9";
-    public final static String INITIAL_BLACKLIST = "10";
-    public final static String FINAL_BLACKLIST = "11";
-    public final static String DOMAIN_BLACKLIST = "12";
-    public final static String DOMAIN_INITIAL_BLACKLIST = "13";
-    public final static String DOMAIN_FINAL_BLACKLIST = "14";
-    public final static String DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "15";
-    public final static String THIRD_PARTY_BLACKLIST = "16";
-    public final static String THIRD_PARTY_INITIAL_BLACKLIST = "17";
-    public final static String THIRD_PARTY_DOMAIN_BLACKLIST = "18";
-    public final static String THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST = "19";
-    public final static String THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST = "20";
-    public final static String THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "21";
-    public final static String REGULAR_EXPRESSION_BLACKLIST = "22";
-
-    public ArrayList<List<String[]>> parseBlocklist(AssetManager assets, String blocklistName) {
-        // Initialize the header list.
-        List<String[]> headers = new ArrayList<>();  // 0.
-
-        // Initialize the whitelists.
-        List<String[]> mainWhitelist = new ArrayList<>();  // 1.
-        List<String[]> finalWhitelist = new ArrayList<>();  // 2.
-        List<String[]> domainWhitelist = new ArrayList<>();  // 3.
-        List<String[]> domainInitialWhitelist = new ArrayList<>();  // 4.
-        List<String[]> domainFinalWhitelist = new ArrayList<>();  // 5.
-        List<String[]> thirdPartyWhitelist = new ArrayList<>();  // 6.
-        List<String[]> thirdPartyDomainWhitelist = new ArrayList<>();  // 7.
-        List<String[]> thirdPartyDomainInitialWhitelist = new ArrayList<>();  // 8.
-
-        // Initialize the blacklists
-        List<String[]> mainBlacklist = new ArrayList<>();  // 9.
-        List<String[]> initialBlacklist = new ArrayList<>();  // 10.
-        List<String[]> finalBlacklist = new ArrayList<>();  // 11.
-        List<String[]> domainBlacklist = new ArrayList<>();  // 12.
-        List<String[]> domainInitialBlacklist = new ArrayList<>();  // 13.
-        List<String[]> domainFinalBlacklist = new ArrayList<>();  // 14.
-        List<String[]> domainRegularExpressionBlacklist = new ArrayList<>();  // 15.
-        List<String[]> thirdPartyBlacklist = new ArrayList<>();  // 16.
-        List<String[]> thirdPartyInitialBlacklist = new ArrayList<>();  // 17.
-        List<String[]> thirdPartyDomainBlacklist = new ArrayList<>();  // 18.
-        List<String[]> thirdPartyDomainInitialBlacklist = new ArrayList<>();  // 19.
-        List<String[]> regularExpressionBlacklist = new ArrayList<>();  // 20.
-        List<String[]> thirdPartyRegularExpressionBlacklist = new ArrayList<>();  // 21.
-        List<String[]> thirdPartyDomainRegularExpressionBlacklist = new ArrayList<>();  // 22.
-
-
-        // Populate the block lists.  The `try` is required by `InputStreamReader`.
-        try {
-            // Load the block list into a `BufferedReader`.
-            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(assets.open(blocklistName)));
-
-            // Create a string for storing the block list entries.
-            String blocklistEntry;
-
-            // Parse the block list.
-            while ((blocklistEntry = bufferedReader.readLine()) != null) {
-                // Store the original block list entry.
-                String originalBlocklistEntry = blocklistEntry;
-
-                // Remove any `^` from the block list entry.  Privacy Browser does not process them in the interest of efficiency.
-                blocklistEntry = blocklistEntry.replace("^", "");
-
-                //noinspection StatementWithEmptyBody
-                if (blocklistEntry.contains("##") || blocklistEntry.contains("#?#") || blocklistEntry.contains("#@#") || blocklistEntry.startsWith("[")) {
-                    // Entries that contain `##`, `#?#`, and `#@#` are for hiding elements in the main page's HTML.  Entries that start with `[` describe the AdBlock compatibility level.
-                    // Do nothing.  Privacy Browser does not currently use these entries.
-
-                    //Log.i("Blocklists", "Not added: " + blocklistEntry);
-                } else //noinspection StatementWithEmptyBody
-                    if (blocklistEntry.contains("$csp=script-src")) {  // Ignore entries that contain `$csp=script-src`.
-                        // Do nothing.  It is uncertain what this directive is even supposed to mean, and it is blocking entire websites like androidcentral.com.  https://redmine.stoutner.com/issues/306.
-
-                        //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                } else //noinspection StatementWithEmptyBody
-                    if (blocklistEntry.contains("$websocket") || blocklistEntry.contains("$third-party,websocket") || blocklistEntry.contains("$script,websocket")) {  // Ignore entries with `websocket`.
-                        // Do nothing.  Privacy Browser does not differentiate between websocket requests and other requests and these entries cause a lot of false positives.
-
-                        //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                } else if (blocklistEntry.startsWith("!")) {  //  Comment entries.
-                    if (blocklistEntry.startsWith("! Version:")) {
-                        // Get the list version number.
-                        String[] listVersion = {blocklistEntry.substring(11)};
-
-                        // Store the list version in the headers list.
-                        headers.add(listVersion);
-                    }
-
-                    if (blocklistEntry.startsWith("! Title:")) {
-                        // Get the list title.
-                        String[] listTitle = {blocklistEntry.substring(9)};
-
-                        // Store the list title in the headers list.
-                        headers.add(listTitle);
-                    }
-
-                    //Log.i("Blocklists", "Not added: " + blocklistEntry);
-                } else if (blocklistEntry.startsWith("@@")) {  // Entries that begin with `@@` are whitelists.
-                    // Remove the `@@`
-                    blocklistEntry = blocklistEntry.substring(2);
-
-                    // Strip out any initial `||`.  Privacy Browser doesn't differentiate items that only match against the end of the domain name.
-                    if (blocklistEntry.startsWith("||")) {
-                        blocklistEntry = blocklistEntry.substring(2);
-                    }
-
-                    if (blocklistEntry.contains("$")) {  // Filter entries.
-                        //noinspection StatementWithEmptyBody
-                        if (blocklistEntry.contains("~third-party")) {  // Ignore entries that contain `~third-party`.
-                            // Do nothing.
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                        } else if (blocklistEntry.contains("third-party")) {  // Third-party white list entries.
-                            if (blocklistEntry.contains("domain=")) {  // Third-party domain white list entries.
-                                // Parse the entry.
-                                String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                                String filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1);
-                                String domains = filters.substring(filters.indexOf("domain=") + 7);
-
-                                //noinspection StatementWithEmptyBody
-                                if (domains.contains("~")) {  // It is uncertain what a `~` domain means inside an `@@` entry.
-                                    // Do Nothing
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                                } else if (blocklistEntry.startsWith("|")) {  // Third-party domain initial white list entries.
-                                    // Strip out the initial `|`.
-                                    entry = entry.substring(1);
-
-                                    //noinspection StatementWithEmptyBody
-                                    if (entry.equals("http://") || entry.equals("https://")) {  // Ignore generic entries.
-                                        // Do nothing.  These entries are designed for filter options that Privacy Browser does not use.
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                                    } else {  // Process third-party domain initial white list entries.
-                                        // Process each domain.
-                                        do {
-                                            // Create a string to keep track of the current domain.
-                                            String domain;
-
-                                            if (domains.contains("|")) {  // There is more than one domain in the list.
-                                                // Get the first domain from the list.
-                                                domain = domains.substring(0, domains.indexOf("|"));
-
-                                                // Remove the first domain from the list.
-                                                domains = domains.substring(domains.indexOf("|") + 1);
-                                            } else {  // There is only one domain in the list.
-                                                domain = domains;
-                                            }
-
-                                            if (entry.contains("*")) {  // Process a third-party domain initial white list double entry.
-                                                // Get the index of the wildcard.
-                                                int wildcardIndex = entry.indexOf("*");
-
-                                                // Split the entry into components.
-                                                String firstEntry = entry.substring(0, wildcardIndex);
-                                                String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                                // Create an entry string array.
-                                                String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the white list.
-                                                thirdPartyDomainInitialWhitelist.add(domainDoubleEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial white list added: " + domain + " , " + firstEntry + " , " + secondEntry +
-                                                //        "  -  " + originalBlocklistEntry);
-                                            } else {  // Process a third-party domain initial white list single entry.
-                                                // Create a domain entry string array.
-                                                String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                                // Add the entry to the third party domain initial white list.
-                                                thirdPartyDomainInitialWhitelist.add(domainEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial white list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                            }
-                                        } while (domains.contains("|"));
-                                    }
-                                } else {  // Third-party domain entries.
-                                    // Process each domain.
-                                    do {
-                                        // Create a string to keep track of the current domain.
-                                        String domain;
-
-                                        if (domains.contains("|")) {  // three is more than one domain in the list.
-                                            // Get the first domain from the list.
-                                            domain = domains.substring(0, domains.indexOf("|"));
-
-                                            // Remove the first domain from the list.
-                                            domains = domains.substring(domains.indexOf("|") + 1);
-                                        } else {  // There is only one domain in the list.
-                                            domain = domains;
-                                        }
-
-                                        // Remove any trailing `*` from the entry.
-                                        if (entry.endsWith("*")) {
-                                            entry = entry.substring(0, entry.length() - 1);
-                                        }
-
-                                        if (entry.contains("*")) {  // Process a third-party domain double entry.
-                                            // Get the index of the wildcard.
-                                            int wildcardIndex = entry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String firstEntry = entry.substring(0, wildcardIndex);
-                                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                            // Create an entry string array.
-                                            String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                            // Add the entry to the white list.
-                                            thirdPartyDomainWhitelist.add(domainDoubleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain white list added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                            //        originalBlocklistEntry);
-                                        } else {  // Process a third-party domain single entry.
-                                            // Create an entry string array.
-                                            String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                            // Add the entry to the white list.
-                                            thirdPartyDomainWhitelist.add(domainEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain white list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                        }
-                                    } while (domains.contains("|"));
-                                }
-                            } else {  // Process third-party white list entries.
-                                // Parse the entry
-                                String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-
-                                if (entry.contains("*")) {  // There are two or more entries.
-                                    // Get the index of the wildcard.
-                                    int wildcardIndex = entry.indexOf("*");
-
-                                    // Split the entry into components.
-                                    String firstEntry = entry.substring(0, wildcardIndex);
-                                    String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                    if (secondEntry.contains("*")) {  // There are three or more entries.
-                                        // Get the index of the wildcard.
-                                        int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                        String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                        if (thirdEntry.contains("*")) {  // There are four or more entries.
-                                            // Get the index of the wildcard.
-                                            int thirdWildcardIndex = thirdEntry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex);
-                                            String fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1);
-
-                                            if (fourthEntry.contains("*")) {  // Process a third-party white list quintuple entry.
-                                                // Get the index of the wildcard.
-                                                int fourthWildcardIndex = fourthEntry.indexOf("*");
-
-                                                // Split the entry into components.
-                                                String realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex);
-                                                String fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1);
-
-                                                // Create an entry string array.
-                                                String[] quintupleEntry = {firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the white list.
-                                                thirdPartyWhitelist.add(quintupleEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party white list added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
-                                                //        realFourthEntry + " , " + fifthEntry + "  -  " + originalBlocklistEntry);
-                                            } else {  // Process a third-party white list quadruple entry.
-                                                // Create an entry string array.
-                                                String[] quadrupleEntry = {firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the white list.
-                                                thirdPartyWhitelist.add(quadrupleEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party white list added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
-                                                //        fourthEntry + "  -  " + originalBlocklistEntry);
-                                            }
-                                        } else {  // Process a third-party white list triple entry.
-                                            // Create an entry string array.
-                                            String[] tripleEntry = {firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                            // Add the entry to the white list.
-                                            thirdPartyWhitelist.add(tripleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party white list added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " +
-                                            //        originalBlocklistEntry);
-                                        }
-                                    } else {  // Process a third-party white list double entry.
-                                        // Create an entry string array.
-                                        String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the white list.
-                                        thirdPartyWhitelist.add(doubleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party white list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                                    }
-                                } else {  // Process a third-party white list single entry.
-                                    // Create an entry string array.
-                                    String[] singleEntry = {entry, originalBlocklistEntry};
-
-                                    // Add the entry to the white list.
-                                    thirdPartyWhitelist.add(singleEntry);
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " third-party domain white list added: " + entry + "  -  " + originalBlocklistEntry);
-                                }
-                            }
-                        } else if (blocklistEntry.contains("domain=")) {  // Process domain white list entries.
-                            // Parse the entry
-                            String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                            String filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1);
-                            String domains = filters.substring(filters.indexOf("domain=") + 7);
-
-                            if (entry.startsWith("|")) {  // Initial domain white list entries.
-                                // Strip the initial `|`.
-                                entry = entry.substring(1);
-
-                                //noinspection StatementWithEmptyBody
-                                if (entry.equals("http://") || entry.equals("https://")) {  // Ignore generic entries.
-                                    // Do nothing.  These entries are designed for filter options that Privacy Browser does not use.
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                                } else {  // Initial domain white list entry.
-                                    // Process each domain.
-                                    do {
-                                        // Create a string to keep track of the current domain.
-                                        String domain;
-
-                                        if (domains.contains("|")) {  // There is more than one domain in the list.
-                                            // Get the first domain from the list.
-                                            domain = domains.substring(0, domains.indexOf("|"));
-
-                                            // Remove the first domain from the list.
-                                            domains = domains.substring(domains.indexOf("|") + 1);
-                                        } else {  // There is only one domain in the list.
-                                            domain = domains;
-                                        }
-
-                                        if (entry.contains("*")) {  // There are two or more entries.
-                                            // Get the index of the wildcard.
-                                            int wildcardIndex = entry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String firstEntry = entry.substring(0, wildcardIndex);
-                                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                            if (secondEntry.contains("*")) {  // Process a domain initial triple entry.
-                                                // Get the index of the wildcard.
-                                                int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                                // Split the entry into components.
-                                                String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                                String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                                // Create an entry string array.
-                                                String[] domainTripleEntry = {domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the white list.
-                                                domainInitialWhitelist.add(domainTripleEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " domain initial white list entry added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " +
-                                                //        thirdEntry + "  -  " + originalBlocklistEntry);
-                                            } else {  // Process a domain initial double entry.
-                                                // Create an entry string array.
-                                                String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the white list.
-                                                domainInitialWhitelist.add(domainDoubleEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " domain initial white list entry added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                                //        originalBlocklistEntry);
-                                            }
-                                        } else {  // Process a domain initial single entry.
-                                            // Create an entry string array.
-                                            String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                            // Add the entry to the white list.
-                                            domainInitialWhitelist.add(domainEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " domain initial white list entry added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                        }
-                                    } while (domains.contains("|"));
-                                }
-                            } else if (entry.endsWith("|")) {  // Final domain white list entries.
-                                // Strip the `|` from the end of the entry.
-                                entry = entry.substring(0, entry.length() - 1);
-
-                                // Process each domain.
-                                do {
-                                    // Create a string to keep track of the current domain.
-                                    String domain;
-
-                                    if (domains.contains("|")) {  // There is more than one domain in the list.
-                                        // Get the first domain from the list.
-                                        domain = domains.substring(0, domains.indexOf("|"));
-
-                                        // Remove the first domain from the list.
-                                        domains = domains.substring(domains.indexOf("|") + 1);
-                                    } else {  // There is only one domain in the list.
-                                        domain = domains;
-                                    }
-
-                                    if (entry.contains("*")) {  // Process a domain final white list double entry.
-                                        // Get the index of the wildcard.
-                                        int wildcardIndex = entry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String firstEntry = entry.substring(0, wildcardIndex);
-                                        String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                        // Create an entry string array.
-                                        String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the white list.
-                                        domainFinalWhitelist.add(domainDoubleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " domain final white list added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                        //        originalBlocklistEntry);
-                                    } else {  // Process a domain final white list single entry.
-                                        // create an entry string array.
-                                        String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                        // Add the entry to the white list.
-                                        domainFinalWhitelist.add(domainEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " domain final white list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                    }
-                                } while (domains.contains("|"));
-
-                            } else {  // Standard domain white list entries with filters.
-                                //noinspection StatementWithEmptyBody
-                                if (domains.contains("~")) {  // It is uncertain what a `~` domain means inside an `@@` entry.
-                                    // Do Nothing
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                                } else {
-                                    // Process each domain.
-                                    do {
-                                        // Create a string to keep track of the current domain.
-                                        String domain;
-
-                                        if (domains.contains("|")) {  // There is more than one domain in the list.
-                                            // Get the first domain from the list.
-                                            domain = domains.substring(0, domains.indexOf("|"));
-
-                                            // Remove the first domain from the list.
-                                            domains = domains.substring(domains.indexOf("|") + 1);
-                                        } else {  // There is only one domain in the list.
-                                            domain = domains;
-                                        }
-
-                                        if (entry.contains("*")) {  // There are two or more entries.
-                                            // Get the index of the wildcard.
-                                            int wildcardIndex = entry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String firstEntry = entry.substring(0, wildcardIndex);
-                                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                            if (secondEntry.contains("*")) {  // There are three or more entries.
-                                                // Get the index of the wildcard.
-                                                int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                                // Split the entry into components.
-                                                String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                                String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                                if (thirdEntry.contains("*")) {  // Process a domain white list quadruple entry.
-                                                    // Get the index of the wildcard.
-                                                    int thirdWildcardIndex = thirdEntry.indexOf("*");
-
-                                                    // Split the entry into components.
-                                                    String realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex);
-                                                    String fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1);
-
-                                                    // Create an entry string array.
-                                                    String[] domainQuadrupleEntry = {domain, firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry};
-
-                                                    // Add the entry to the white list.
-                                                    domainWhitelist.add(domainQuadrupleEntry);
-
-                                                    //Log.i("Blocklists", headers.get(1)[0] + " domain white list added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " +
-                                                    //        realThirdEntry + " , " + fourthEntry + "  -  " + originalBlocklistEntry);
-                                                } else {  // Process a domain white list triple entry.
-                                                    // Create an entry string array.
-                                                    String[] domainTripleEntry = {domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                                    // Add the entry to the white list.
-                                                    domainWhitelist.add(domainTripleEntry);
-
-                                                    //Log.i("Blocklists", headers.get(1)[0] + " domain white list added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " +
-                                                    //        thirdEntry + "  -  " + originalBlocklistEntry);
-                                                }
-                                            } else {  // Process a domain white list double entry.
-                                                // Create an entry string array.
-                                                String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the white list.
-                                                domainWhitelist.add(domainDoubleEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " domain white list added : " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                                //        originalBlocklistEntry);
-                                            }
-                                        } else {  // Process a domain white list single entry.
-                                            // Create an entry string array.
-                                            String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                            // Add the entry to the white list.
-                                            domainWhitelist.add(domainEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " domain white list added : " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                        }
-                                    } while (domains.contains("|"));
-                                }
-                            }
-                        }  // Ignore all other filter entries.
-                    } else if (blocklistEntry.endsWith("|")) {  // Final white list entries.
-                        // Remove the final `|` from the entry.
-                        String entry = blocklistEntry.substring(0, blocklistEntry.length() - 1);
-
-                        if (entry.contains("*")) {  // Process a final white list double entry
-                            // Get the index of the wildcard.
-                            int wildcardIndex = entry.indexOf("*");
-
-                            // split the entry into components.
-                            String firstEntry = entry.substring(0, wildcardIndex);
-                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                            // Create an entry string array.
-                            String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                            // Add the entry to the white list.
-                            finalWhitelist.add(doubleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " final white list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                        } else {  // Process a final white list single entry.
-                            // Create an entry string array.
-                            String[] singleEntry = {entry, originalBlocklistEntry};
-
-                            // Add the entry to the white list.
-                            finalWhitelist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " final white list added: " + entry + "  -  " + originalBlocklistEntry);
-                        }
-                    } else {  // Main white list entries.
-                        if (blocklistEntry.contains("*")) {  // There are two or more entries.
-                            // Get the index of the wildcard.
-                            int wildcardIndex = blocklistEntry.indexOf("*");
-
-                            // Split the entry into components.
-                            String firstEntry = blocklistEntry.substring(0, wildcardIndex);
-                            String secondEntry = blocklistEntry.substring(wildcardIndex + 1);
-
-                            if (secondEntry.contains("*")) {  // Process a main white list triple entry.
-                                // Get the index of the wildcard.
-                                int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                // Split the entry into components.
-                                String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                // Create an entry string array.
-                                String[] tripleEntry = {firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                // Add the entry to the white list.
-                                mainWhitelist.add(tripleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " main white list added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " + originalBlocklistEntry);
-                            } else {  // Process a main white list double entry.
-                                // Create an entry string array.
-                                String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                // Add the entry to the white list.
-                                mainWhitelist.add(doubleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " main white list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                            }
-                        } else {  // Process a main white list single entry.
-                            // Create an entry string array.
-                            String[] singleEntry = {blocklistEntry, originalBlocklistEntry};
-
-                            // Add the entry to the white list.
-                            mainWhitelist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " main white list added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
-                        }
-                    }
-                } else if (blocklistEntry.endsWith("|")) {  // Final black list entries.
-                    // Strip out the final "|"
-                    String entry = blocklistEntry.substring(0, blocklistEntry.length() - 1);
-
-                    // Strip out any initial `||`.  They are redundant in this case because the block list entry is being matched against the end of the URL.
-                    if (entry.startsWith("||")) {
-                        entry = entry.substring(2);
-                    }
-
-                    if (entry.contains("*")) {  // Process a final black list double entry.
-                        // Get the index of the wildcard.
-                        int wildcardIndex = entry.indexOf("*");
-
-                        // Split the entry into components.
-                        String firstEntry = entry.substring(0, wildcardIndex);
-                        String secondEntry = entry.substring(wildcardIndex + 1);
-
-                        // Create an entry string array.
-                        String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                        // Add the entry to the black list.
-                        finalBlacklist.add(doubleEntry);
-
-                        //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                    } else {  // Process a final black list single entry.
-                        // create an entry string array.
-                        String[] singleEntry = {entry, originalBlocklistEntry};
-
-                        // Add the entry to the black list.
-                        finalBlacklist.add(singleEntry);
-
-                        //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + entry + "  -  " + originalBlocklistEntry);
-                    }
-                } else if (blocklistEntry.contains("$")) {  // Entries with filter options.
-                    // Strip out any initial `||`.  These will be treated like any other entry.
-                    if (blocklistEntry.startsWith("||")) {
-                        blocklistEntry = blocklistEntry.substring(2);
-                    }
-
-                    if (blocklistEntry.contains("third-party")) {  // Third-party entries.
-                        //noinspection StatementWithEmptyBody
-                        if (blocklistEntry.contains("~third-party")) {  // Third-party filter white list entries.
-                            // Do not process these white list entries.  They are designed to combine with block filters that Privacy Browser doesn't use, like `subdocument` and `xmlhttprequest`.
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                        } else if (blocklistEntry.contains("domain=")) {  // Third-party domain entries.
-                            if (blocklistEntry.startsWith("|")) {  // Third-party domain initial entries.
-                                // Strip the initial `|`.
-                                blocklistEntry = blocklistEntry.substring(1);
-
-                                // Parse the entry
-                                String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                                String filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1);
-                                String domains = filters.substring(filters.indexOf("domain=") + 7);
-
-                                //noinspection StatementWithEmptyBody
-                                if (entry.equals("http:") || entry.equals("https:") || entry.equals("http://") || entry.equals("https://")) {  // Ignore generic entries.
-                                    // Do nothing.  These entries will almost entirely disable the website.
-                                    // Often the original entry blocks filter options like `$script`, which Privacy Browser does not differentiate.
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                                } else {  // Third-party domain initial entries.
-                                    // Process each domain.
-                                    do {
-                                        // Create a string to keep track of the current domain.
-                                        String domain;
-
-                                        if (domains.contains("|")) {  // There is more than one domain in the list.
-                                            // Get the first domain from the list.
-                                            domain = domains.substring(0, domains.indexOf("|"));
-
-                                            // Remove the first domain from the list.
-                                            domains = domains.substring(domains.indexOf("|") + 1);
-                                        } else {  // There is only one domain in the list.
-                                            domain = domains;
-                                        }
-
-                                        if (entry.contains("*")) {  // Three are two or more entries.
-                                            // Get the index of the wildcard.
-                                            int wildcardIndex = entry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String firstEntry = entry.substring(0, wildcardIndex);
-                                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                            if (secondEntry.contains("*")) {  // Process a third-party domain initial black list triple entry.
-                                                // Get the index of the wildcard.
-                                                int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                                // Split the entry into components.
-                                                String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                                String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                                // Create an entry string array.
-                                                String[] tripleDomainEntry = {domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the black list.
-                                                thirdPartyDomainInitialBlacklist.add(tripleDomainEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial black list added: " + domain + " , " + firstEntry + " , " + realSecondEntry +
-                                                //        " , " + thirdEntry + "  -  " + originalBlocklistEntry);
-                                            } else {  // Process a third-party domain initial black list double entry.
-                                                // Create an entry string array.
-                                                String[] doubleDomainEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                                // Add the entry to the black list.
-                                                thirdPartyDomainInitialBlacklist.add(doubleDomainEntry);
-
-                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial black list added: " + domain + " , " + firstEntry + " , " + secondEntry +
-                                                //        "  -  " + originalBlocklistEntry);
-                                            }
-                                        } else {  // Process a third-party domain initial black list single entry.
-                                            // Create an entry string array.
-                                            String[] singleEntry = {domain, entry, originalBlocklistEntry};
-
-                                            // Add the entry to the black list.
-                                            thirdPartyDomainInitialBlacklist.add(singleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial black list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                        }
-                                    } while (domains.contains("|"));
-                                }
-                            } else if (blocklistEntry.contains("\\")) {  // Process a third-party domain black list regular expression.
-                                // Parse the entry.  At least one regular expression in this entry contains `$`, so the parser uses `/$`.
-                                String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("/$") + 1);
-                                String filters = blocklistEntry.substring(blocklistEntry.indexOf("/$") + 2);
-                                String domains = filters.substring(filters.indexOf("domain=") + 7);
-
-                                // Process each domain.
-                                do {
-                                    // Create a string to keep track of the current domain.
-                                    String domain;
-
-                                    if (domains.contains("|")) {  // There is more than one domain in the list.
-                                        // Get the first domain from the list.
-                                        domain = domains.substring(0, domains.indexOf("|"));
-
-                                        // Remove the first domain from the list.
-                                        domains = domains.substring(domains.indexOf("|") + 1);
-                                    } else {  // There is only one domain in the list.
-                                        domain = domains;
-                                    }
-
-                                    // Create an entry string array.
-                                    String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                    // Add the entry to the black list.
-                                    thirdPartyDomainRegularExpressionBlacklist.add(domainEntry);
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " third-party domain regular expression black list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                } while (domains.contains("|"));
-                            } else {  // Third-party domain entries.
-                                // Parse the entry
-                                String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                                String filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1);
-                                String domains = filters.substring(filters.indexOf("domain=") + 7);
-
-                                // Strip any trailing "*" from the entry.
-                                if (entry.endsWith("*")) {
-                                    entry = entry.substring(0, entry.length() - 1);
-                                }
-
-                                // Track if any third-party white list filters are applied.
-                                boolean whitelistDomain = false;
-
-                                // Process each domain.
-                                do {
-                                    // Create a string to keep track of the current domain.
-                                    String domain;
-
-                                    if (domains.contains("|")) {  // There is more than one domain in the list.
-                                        // Get the first domain from the list.
-                                        domain = domains.substring(0, domains.indexOf("|"));
-
-                                        // Remove the first domain from the list.
-                                        domains = domains.substring(domains.indexOf("|") + 1);
-                                    } else {  // The is only one domain in the list.
-                                        domain = domains;
-                                    }
-
-                                    // Differentiate between block list domains and white list domains.
-                                    if (domain.startsWith("~")) {  // White list third-party domain entry.
-                                        // Strip the initial `~`.
-                                        domain = domain.substring(1);
-
-                                        // Set the white list domain flag.
-                                        whitelistDomain = true;
-
-                                        if (entry.contains("*")) {  // Process a third-party domain white list double entry.
-                                            // Get the index of the wildcard.
-                                            int wildcardIndex = entry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String firstEntry = entry.substring(0, wildcardIndex);
-                                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                            // Create an entry string array.
-                                            String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                            // Add the entry to the white list.
-                                            thirdPartyDomainWhitelist.add(domainDoubleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain white list added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                            //        originalBlocklistEntry);
-                                        } else {  // Process a third-party domain white list single entry.
-                                            // Create an entry string array.
-                                            String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                            // Add the entry to the white list.
-                                            thirdPartyDomainWhitelist.add(domainEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain white list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                        }
-                                    } else {  // Third-party domain black list entries.
-                                        if (entry.contains("*")) {  // Process a third-party domain black list double entry.
-                                            // Get the index of the wildcard.
-                                            int wildcardIndex = entry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String firstEntry = entry.substring(0, wildcardIndex);
-                                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                            // Create an entry string array.
-                                            String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                            // Add the entry to the black list
-                                            thirdPartyDomainBlacklist.add(domainDoubleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain black list added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                            //        originalBlocklistEntry);
-                                        } else {  // Process a third-party domain black list single entry.
-                                            // Create an entry string array.
-                                            String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                            // Add the entry to the black list.
-                                            thirdPartyDomainBlacklist.add(domainEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain block list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                        }
-                                    }
-                                } while (domains.contains("|"));
-
-                                // Add a third-party black list entry if a white list domain was processed.
-                                if (whitelistDomain) {
-                                    if (entry.contains("*")) {  // Process a third-party black list double entry.
-                                        // Get the index of the wildcard.
-                                        int wildcardIndex = entry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String firstEntry = entry.substring(0, wildcardIndex);
-                                        String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                        // Create an entry string array.
-                                        String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        thirdPartyBlacklist.add(doubleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                                    } else {  // Process a third-party black list single entry.
-                                        // Create an entry string array.
-                                        String[] singleEntry = {entry, originalBlocklistEntry};
-
-                                        // Add an entry to the black list.
-                                        thirdPartyBlacklist.add(singleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party black list added: " + entry + "  -  " + originalBlocklistEntry);
-                                    }
-                                }
-                            }
-                        } else if (blocklistEntry.startsWith("|")) {  // Third-party initial black list entries.
-                            // Strip the initial `|`.
-                            blocklistEntry = blocklistEntry.substring(1);
-
-                            // Get the entry.
-                            String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-
-                            if (entry.contains("*")) {  // Process a third-party initial black list double entry.
-                                // Get the index of the wildcard.
-                                int wildcardIndex = entry.indexOf("*");
-
-                                // Split the entry into components.
-                                String firstEntry = entry.substring(0, wildcardIndex);
-                                String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                // Create an entry string array.
-                                String[] thirdPartyDoubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                thirdPartyInitialBlacklist.add(thirdPartyDoubleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " third-party initial black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                            } else {  // Process a third-party initial black list single entry.
-                                // Create an entry string array.
-                                String[] singleEntry = {entry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                thirdPartyInitialBlacklist.add(singleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " third-party initial black list added: " + entry + "  -  " + originalBlocklistEntry);
-                            }
-                        } else if (blocklistEntry.contains("\\")) {  // Process a regular expression black list entry.
-                            // Prepare a string to hold the entry.
-                            String entry;
-
-                            // Get the entry.
-                            if (blocklistEntry.contains("$/$")) {  // The first `$` is part of the regular expression.
-                                entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$/$") + 2);
-                            } else {  // The only `$` indicates the filter options.
-                                entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                            }
-
-                            // Create an entry string array.
-                            String[] singleEntry = {entry, originalBlocklistEntry};
-
-                            // Add the entry to the black list.
-                            thirdPartyRegularExpressionBlacklist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " third-party regular expression black list added: " + entry + "  -  " + originalBlocklistEntry);
-                        } else if (blocklistEntry.contains("*")) {  // Third-party and regular expression black list entries.
-                            // Get the entry.
-                            String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-
-                            if (entry.endsWith("*")) {  // Process a third-party black list single entry.
-                                // Strip the final `*`.
-                                entry = entry.substring(0, entry.length() - 1);
-
-                                // Create an entry string array.
-                                String[] singleEntry = {entry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                thirdPartyBlacklist.add(singleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " third party black list added: " + entry + "  -  " + originalBlocklistEntry);
-                            } else {  // There are two or more entries.
-                                // Get the index of the wildcard.
-                                int wildcardIndex = entry.indexOf("*");
-
-                                // Split the entry into components.
-                                String firstEntry = entry.substring(0, wildcardIndex);
-                                String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                if (secondEntry.contains("*")) {  // There are three or more entries.
-                                    // Get the index of the wildcard.
-                                    int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                    // Split the entry into components.
-                                    String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                    String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                    if (thirdEntry.contains("*")) {  // Process a third-party black list quadruple entry.
-                                        // Get the index of the wildcard.
-                                        int thirdWildcardIndex = thirdEntry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex);
-                                        String fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1);
-
-                                        // Create an entry string array.
-                                        String[] quadrupleEntry = {firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        thirdPartyBlacklist.add(quadrupleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party black list added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
-                                        //        fourthEntry + "  -  " + originalBlocklistEntry);
-                                    } else {  // Process a third-party black list triple entry.
-                                        // Create an entry string array.
-                                        String[] tripleEntry = {firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        thirdPartyBlacklist.add(tripleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party black list added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " +
-                                        //        originalBlocklistEntry);
-                                    }
-                                } else {  // Process a third-party black list double entry.
-                                    // Create an entry string array.
-                                    String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                    // Add the entry to the black list.
-                                    thirdPartyBlacklist.add(doubleEntry);
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " third-party black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                                }
-                            }
-                        } else {  // Process a third party black list single entry.
-                            // Get the entry.
-                            String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-
-                            // Create an entry string array.
-                            String[] singleEntry = {entry, originalBlocklistEntry};
-
-                            // Add the entry to the black list.
-                            thirdPartyBlacklist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " third party black list added: " + entry + "  -  " + originalBlocklistEntry);
-                        }
-                    } else if (blocklistEntry.substring(blocklistEntry.indexOf("$")).contains("domain=")) {  // Domain entries.
-                        if (blocklistEntry.contains("~")) {  // Domain white list entries.
-                            // Separate the filters.
-                            String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                            String filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1);
-                            String domains = filters.substring(filters.indexOf("domain=") + 7);
-
-                            // Strip any final `*` from the entry.  They are redundant.
-                            if (entry.endsWith("*")) {
-                                entry = entry.substring(0, entry.length() - 1);
-                            }
-
-                            // Process each domain.
-                            do {
-                                // Create a string to keep track of the current domain.
-                                String domain;
-
-                                if (domains.contains("|")) {  // There is more than one domain in the list.
-                                    // Get the first domain from the list.
-                                    domain = domains.substring(0, domains.indexOf("|"));
-
-                                    // Remove the first domain from the list.
-                                    domains = domains.substring(domains.indexOf("|") + 1);
-                                } else {  // There is only one domain in the list.
-                                    domain = domains;
-                                }
-
-                                // Strip the initial `~`.
-                                domain = domain.substring(1);
-
-                                if (entry.contains("*")) {  // There are two or more entries.
-                                    // Get the index of the wildcard.
-                                    int wildcardIndex = entry.indexOf("*");
-
-                                    // Split the entry into components.
-                                    String firstEntry = entry.substring(0, wildcardIndex);
-                                    String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                    if (secondEntry.contains("*")) {  // Process a domain white list triple entry.
-                                        // Get the index of the wildcard.
-                                        int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                        String thirdEntry = secondEntry.substring((secondWildcardIndex + 1));
-
-                                        // Create an entry string array.
-                                        String[] domainTripleEntry = {domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the white list.
-                                        domainWhitelist.add(domainTripleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " domain white list added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry +
-                                        //        "  -  " + originalBlocklistEntry);
-                                    } else {  // Process a domain white list double entry.
-                                        // Create an entry string array.
-                                        String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the white list.
-                                        domainWhitelist.add(domainDoubleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " domain white list added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                                    }
-                                } else {  // Process a domain white list single entry.
-                                    // Create an entry string array.
-                                    String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                    // Add the entry to the white list.
-                                    domainWhitelist.add(domainEntry);
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " domain white list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                }
-                            } while (domains.contains("|"));
-                        } else {  // Domain black list entries.
-                            // Separate the filters.
-                            String entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                            String filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1);
-                            String domains = filters.substring(filters.indexOf("domain=") + 7);
-
-                            // Only process the item if the entry is not null.  For example, some lines begin with `$websocket`, which create a null entry.
-                            if (!entry.equals("")) {
-                                // Process each domain.
-                                do {
-                                    // Create a string to keep track of the current domain.
-                                    String domain;
-
-                                    if (domains.contains("|")) {  // There is more than one domain in the list.
-                                        // Get the first domain from the list.
-                                        domain = domains.substring(0, domains.indexOf("|"));
-
-                                        // Remove the first domain from the list.
-                                        domains = domains.substring(domains.indexOf("|") + 1);
-                                    } else {  // There is only one domain in the list.
-                                        domain = domains;
-                                    }
-
-                                    if (entry.startsWith("|")) {  // Domain initial black list entries.
-                                        // Remove the initial `|`;
-                                        String entryBase = entry.substring(1);
-
-                                        //noinspection StatementWithEmptyBody
-                                        if (entryBase.equals("http://") || entryBase.equals("https://")) {
-                                            // Do nothing.  These entries will entirely block the website.
-                                            // Often the original entry blocks `$script` but Privacy Browser does not currently differentiate between scripts and other entries.
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
-                                        } else {  // Process a domain initial black list entry
-                                            // Create an entry string array.
-                                            String[] domainEntry = {domain, entryBase, originalBlocklistEntry};
-
-                                            // Add the entry to the black list.
-                                            domainInitialBlacklist.add(domainEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " domain initial black list added: " + domain + " , " + entryBase + "  -  " + originalBlocklistEntry);
-                                        }
-                                    } else if (entry.endsWith("|")) {  // Domain final black list entries.
-                                        // Remove the final `|`.
-                                        String entryBase = entry.substring(0, entry.length() - 1);
-
-                                        if (entryBase.contains("*")) {  // Process a domain final black list double entry.
-                                            // Get the index of the wildcard.
-                                            int wildcardIndex = entry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String firstEntry = entryBase.substring(0, wildcardIndex);
-                                            String secondEntry = entryBase.substring(wildcardIndex + 1);
-
-                                            // Create an entry string array.
-                                            String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                            // Add the entry to the black list.
-                                            domainFinalBlacklist.add(domainDoubleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " domain final black list added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                            //        originalBlocklistEntry);
-                                        } else {  // Process a domain final black list single entry.
-                                            // Create an entry string array.
-                                            String[] domainEntry = {domain, entryBase, originalBlocklistEntry};
-
-                                            // Add the entry to the black list.
-                                            domainFinalBlacklist.add(domainEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " domain final black list added: " + domain + " , " + entryBase + "  -  " + originalBlocklistEntry);
-                                        }
-                                    } else if (entry.contains("\\")) {  // Process a domain regular expression black list entry.
-                                        // Create an entry string array.
-                                        String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        domainRegularExpressionBlacklist.add(domainEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " domain regular expression black list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                    } else if (entry.contains("*")) {  // There are two or more entries.
-                                        // Get the index of the wildcard.
-                                        int wildcardIndex = entry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String firstEntry = entry.substring(0, wildcardIndex);
-                                        String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                        if (secondEntry.contains("*")) {  // Process a domain black list triple entry.
-                                            // Get the index of the wildcard.
-                                            int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                            // Split the entry into components.
-                                            String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                            String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                            // Create an entry string array.
-                                            String[] domainTripleEntry = {domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                            // Add the entry to the black list.
-                                            domainBlacklist.add(domainTripleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " domain black list added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry +
-                                            //        "  -  " + originalBlocklistEntry);
-                                        } else {  // Process a domain black list double entry.
-                                            // Create an entry string array.
-                                            String[] domainDoubleEntry = {domain, firstEntry, secondEntry, originalBlocklistEntry};
-
-                                            // Add the entry to the black list.
-                                            domainBlacklist.add(domainDoubleEntry);
-
-                                            //Log.i("Blocklists", headers.get(1)[0] + " domain black list added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
-                                            //        originalBlocklistEntry);
-                                        }
-                                    } else {  // Process a domain black list single entry.
-                                        // Create an entry string array.
-                                        String[] domainEntry = {domain, entry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        domainBlacklist.add(domainEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " domain black list added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
-                                    }
-                                } while (domains.contains("|"));
-                            }
-                        }
-                    } else if (blocklistEntry.contains("~")) {  // White list entries.  Privacy Browser does not differentiate against these filter options, so they are just generally white listed.
-                        // Remove the filter options.
-                        blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-
-                        // Strip any trailing `*`.
-                        if (blocklistEntry.endsWith("*")) {
-                            blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length() - 1);
-                        }
-
-                        if (blocklistEntry.contains("*")) {  // Process a white list double entry.
-                            // Get the index of the wildcard.
-                            int wildcardIndex = blocklistEntry.indexOf("*");
-
-                            // Split the entry into components.
-                            String firstEntry = blocklistEntry.substring(0, wildcardIndex);
-                            String secondEntry = blocklistEntry.substring(wildcardIndex + 1);
-
-                            // Create an entry string array.
-                            String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                            // Add the entry to the white list.
-                            mainWhitelist.add(doubleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " main white list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                        } else {  // Process a white list single entry.
-                            // Create an entry string array.
-                            String[] singleEntry = {blocklistEntry, originalBlocklistEntry};
-
-                            // Add the entry to the white list.
-                            mainWhitelist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " main white list added: " + blocklistEntry + "  -  + " + originalBlocklistEntry);
-                        }
-                    } else if (blocklistEntry.contains("\\")) {  // Process a regular expression black list entry.
-                        // Remove the filter options.
-                        blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-
-                        // Create an entry string array.
-                        String[] singleEntry = {blocklistEntry, originalBlocklistEntry};
-
-                        // Add the entry to the black list.
-                        regularExpressionBlacklist.add(singleEntry);
-
-                        //Log.i("Blocklists", headers.get(1)[0] + " regular expression black list added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
-                    } else {  // Black list entries.
-                        // Remove the filter options.
-                        if (!blocklistEntry.contains("$file")) {  // EasyPrivacy contains an entry with `$file` that does not have filter options.
-                            blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"));
-                        }
-
-                        // Strip any trailing `*`.  These are redundant.
-                        if (blocklistEntry.endsWith("*")) {
-                            blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length() - 1);
-                        }
-
-                        if (blocklistEntry.startsWith("|")) {  // Initial black list entries.
-                            // Strip the initial `|`.
-                            String entry = blocklistEntry.substring(1);
-
-                            if (entry.contains("*")) {  // Process an initial black list double entry.
-                                // Get the index of the wildcard.
-                                int wildcardIndex = entry.indexOf("*");
-
-                                // Split the entry into components.
-                                String firstEntry = entry.substring(0, wildcardIndex);
-                                String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                // Create an entry string array.
-                                String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                initialBlacklist.add(doubleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " initial black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                            } else {  // Process an initial black list single entry.
-                                // Create an entry string array.
-                                String[] singleEntry = {entry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                initialBlacklist.add(singleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " initial black list added: " + entry + "  -  " + originalBlocklistEntry);
-                            }
-                        } else if (blocklistEntry.endsWith("|")) {  // Final black list entries.
-                            // Ignore entries with `object` filters.  They can block entire websites and don't have any meaning in the context of Privacy Browser.
-                            if (!originalBlocklistEntry.contains("$object")) {
-                                // Strip the final `|`.
-                                String entry = blocklistEntry.substring(0, blocklistEntry.length() - 1);
-
-                                if (entry.contains("*")) {  // There are two or more entries.
-                                    // Get the index of the wildcard.
-                                    int wildcardIndex = entry.indexOf("*");
-
-                                    // Split the entry into components.
-                                    String firstEntry = entry.substring(0, wildcardIndex);
-                                    String secondEntry = entry.substring(wildcardIndex + 1);
-
-                                    if (secondEntry.contains("*")) {  // Process a final black list triple entry.
-                                        // Get the index of the wildcard.
-                                        int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                        String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                        // Create an entry string array.
-                                        String[] tripleEntry = {firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        finalBlacklist.add(tripleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " +
-                                        //        originalBlocklistEntry);
-                                    } else {  // Process a final black list double entry.
-                                        // Create an entry string array.
-                                        String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        finalBlacklist.add(doubleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                                    }
-                                } else {  // Process a final black list single entry.
-                                    // Create an entry sting array.
-                                    String[] singleEntry = {entry, originalBlocklistEntry};
-
-                                    // Add the entry to the black list.
-                                    finalBlacklist.add(singleEntry);
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + entry + "  -  " + originalBlocklistEntry);
-                                }
-                            }
-                        } else if (blocklistEntry.contains("*")) {  // There are two or more entries.
-                            // Get the index of the wildcard.
-                            int wildcardIndex = blocklistEntry.indexOf("*");
-
-                            // Split the entry into components.
-                            String firstEntry = blocklistEntry.substring(0, wildcardIndex);
-                            String secondEntry = blocklistEntry.substring(wildcardIndex + 1);
-
-                            if (secondEntry.contains("*")) {  // Process a main black list triple entry.
-                                // Get the index of the wildcard.
-                                int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                // Split the entry into components.
-                                String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                // Create an entry string array.
-                                String[] tripleEntry = {firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                mainBlacklist.add(tripleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " + originalBlocklistEntry);
-                            } else {  // Process a main black list double entry.
-                                // Create an entry string array.
-                                String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                mainBlacklist.add(doubleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                            }
-                        } else {  // Process a main black list single entry.
-                            // Create an entry string array.
-                            String[] singleEntry = {blocklistEntry, originalBlocklistEntry};
-
-                            // Add the entry to the black list.
-                            mainBlacklist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
-                        }
-                    }
-                } else {  // Main black list entries
-                    // Strip out any initial `||`.  These will be treated like any other entry.
-                    if (blocklistEntry.startsWith("||")) {
-                        blocklistEntry = blocklistEntry.substring(2);
-                    }
-
-                    // Strip out any initial `*`.
-                    if (blocklistEntry.startsWith("*")) {
-                        blocklistEntry = blocklistEntry.substring(1);
-                    }
-
-                    // Strip out any trailing `*`.
-                    if (blocklistEntry.endsWith("*")) {
-                        blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length() - 1);
-                    }
-
-                    if (blocklistEntry.startsWith("|")) {  // Initial black list entries.
-                        // Strip the initial `|`.
-                        String entry = blocklistEntry.substring(1);
-
-                        if (entry.contains("*")) {  // Process an initial black list double entry.
-                            // Get the index of the wildcard.
-                            int wildcardIndex = entry.indexOf("*");
-
-                            // Split the entry into components.
-                            String firstEntry = entry.substring(0, wildcardIndex);
-                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                            // Create an entry string array.
-                            String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                            // Add the entry to the black list.
-                            initialBlacklist.add(doubleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " initial black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                        } else {  // Process an initial black list single entry.
-                            // Create an entry string array.
-                            String[] singleEntry = {entry, originalBlocklistEntry};
-
-                            // Add the entry to the black list.
-                            initialBlacklist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " initial black list added: " + entry + "  -  " + originalBlocklistEntry);
-                        }
-                    } else if (blocklistEntry.endsWith("|")) {  // Final black list entries.
-                        // Strip the final `|`.
-                        String entry = blocklistEntry.substring(0, blocklistEntry.length() - 1);
-
-                        if (entry.contains("*")) {  // There are two or more entries.
-                            // Get the index of the wildcard.
-                            int wildcardIndex = entry.indexOf("*");
-
-                            // Split the entry into components.
-                            String firstEntry = entry.substring(0, wildcardIndex);
-                            String secondEntry = entry.substring(wildcardIndex + 1);
-
-                            if (secondEntry.contains("*")) {  // Process a final black list triple entry.
-                                // Get the index of the wildcard.
-                                int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                // Split the entry into components.
-                                String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                // Create an entry string array.
-                                String[] tripleEntry = {firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                finalBlacklist.add(tripleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " +
-                                //        originalBlocklistEntry);
-                            } else {  // Process a final black list double entry.
-                                // Create an entry string array.
-                                String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                finalBlacklist.add(doubleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                            }
-                        } else {  // Process a final black list single entry.
-                            // Create an entry string array.
-                            String[] singleEntry = {entry, originalBlocklistEntry};
-
-                            // Add the entry to the black list.
-                            finalBlacklist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " final black list added: " + entry + "  -  " + originalBlocklistEntry);
-                        }
-                    } else {  // Main black list entries.
-                        if (blocklistEntry.contains("*")) {  // There are two or more entries.
-                            // Get the index of the wildcard.
-                            int wildcardIndex = blocklistEntry.indexOf("*");
-
-                            // Split the entry into components.
-                            String firstEntry = blocklistEntry.substring(0, wildcardIndex);
-                            String secondEntry = blocklistEntry.substring(wildcardIndex + 1);
-
-                            if (secondEntry.contains("*")) {  // There are three or more entries.
-                                // Get the index of the wildcard.
-                                int secondWildcardIndex = secondEntry.indexOf("*");
-
-                                // Split the entry into components.
-                                String realSecondEntry = secondEntry.substring(0, secondWildcardIndex);
-                                String thirdEntry = secondEntry.substring(secondWildcardIndex + 1);
-
-                                if (thirdEntry.contains("*")) {  // There are four or more entries.
-                                    // Get the index of the wildcard.
-                                    int thirdWildcardIndex = thirdEntry.indexOf("*");
-
-                                    // Split the entry into components.
-                                    String realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex);
-                                    String fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1);
-
-                                    if (fourthEntry.contains("*")) {  // Process a main black list quintuple entry.
-                                        // Get the index of the wildcard.
-                                        int fourthWildcardIndex = fourthEntry.indexOf("*");
-
-                                        // Split the entry into components.
-                                        String realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex);
-                                        String fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1);
-
-                                        // Create an entry string array.
-                                        String[] quintupleEntry = {firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        mainBlacklist.add(quintupleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
-                                        //        realFourthEntry + " , " + fifthEntry + "  -  " + originalBlocklistEntry);
-                                    } else {  // Process a main black list quadruple entry.
-                                        // Create an entry string array.
-                                        String[] quadrupleEntry = {firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry};
-
-                                        // Add the entry to the black list.
-                                        mainBlacklist.add(quadrupleEntry);
-
-                                        //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
-                                        //        fourthEntry + "  -  " + originalBlocklistEntry);
-                                    }
-                                } else {  // Process a main black list triple entry.
-                                    // Create an entry string array.
-                                    String[] tripleEntry = {firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry};
-
-                                    // Add the entry to the black list.
-                                    mainBlacklist.add(tripleEntry);
-
-                                    //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " + originalBlocklistEntry);
-                                }
-                            } else {  // Process a main black list double entry.
-                                // Create an entry string array.
-                                String[] doubleEntry = {firstEntry, secondEntry, originalBlocklistEntry};
-
-                                // Add the entry to the black list.
-                                mainBlacklist.add(doubleEntry);
-
-                                //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
-                            }
-                        } else {  // Process a main black list single entry.
-                            // Create an entry string array.
-                            String[] singleEntry = {blocklistEntry, originalBlocklistEntry};
-
-                            // Add the entry to the black list.
-                            mainBlacklist.add(singleEntry);
-
-                            //Log.i("Blocklists", headers.get(1)[0] + " main black list added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
-                        }
-                    }
-                }
-            }
-            // Close `bufferedReader`.
-            bufferedReader.close();
-        } catch (IOException e) {
-            // The asset exists, so the `IOException` will never be thrown.
-        }
-
-        // Initialize the combined list.
-        ArrayList<List<String[]>> combinedLists = new ArrayList<>();
-
-        // Add the headers (0).
-        combinedLists.add(headers);  // 0.
-
-        // Add the white lists (1-8).
-        combinedLists.add(mainWhitelist);  // 1.
-        combinedLists.add(finalWhitelist);  // 2.
-        combinedLists.add(domainWhitelist);  // 3.
-        combinedLists.add(domainInitialWhitelist);  // 4.
-        combinedLists.add(domainFinalWhitelist); // 5.
-        combinedLists.add(thirdPartyWhitelist);  // 6.
-        combinedLists.add(thirdPartyDomainWhitelist);  // 7.
-        combinedLists.add(thirdPartyDomainInitialWhitelist);  // 8.
-
-        // Add the black lists (9-22).
-        combinedLists.add(mainBlacklist);  // 9.
-        combinedLists.add(initialBlacklist);  // 10.
-        combinedLists.add(finalBlacklist);  // 11.
-        combinedLists.add(domainBlacklist);  //  12.
-        combinedLists.add(domainInitialBlacklist);  // 13.
-        combinedLists.add(domainFinalBlacklist);  // 14.
-        combinedLists.add(domainRegularExpressionBlacklist);  // 15.
-        combinedLists.add(thirdPartyBlacklist);  // 16.
-        combinedLists.add(thirdPartyInitialBlacklist);  // 17.
-        combinedLists.add(thirdPartyDomainBlacklist);  // 18.
-        combinedLists.add(thirdPartyDomainInitialBlacklist);  // 19.
-        combinedLists.add(thirdPartyRegularExpressionBlacklist);  // 20.
-        combinedLists.add(thirdPartyDomainRegularExpressionBlacklist);  // 21.
-        combinedLists.add(regularExpressionBlacklist);  // 22.
-
-        return combinedLists;
-    }
-
-    public String[] checkBlocklist(String currentDomain, String resourceUrl, boolean isThirdPartyRequest, ArrayList<List<String[]>> blocklist) {
-        // Get the blocklist name.
-        String BLOCK_LIST_NAME_STRING = blocklist.get(0).get(1)[0];
-
-        // Assert that currentDomain != null only if this is a third party request.  Apparently, lint can't tell that this isn't redundant.
-        //noinspection RedundantIfStatement
-        if (isThirdPartyRequest) {
-            assert currentDomain != null;
-        }
-
-        // Process the white lists.
-        // Main white list.
-        for (String[] whitelistEntry : blocklist.get(Integer.parseInt(MAIN_WHITELIST))) {
-            switch (whitelistEntry.length) {
-                case 2:  // There is one entry.
-                    if (resourceUrl.contains(whitelistEntry[0])) {
-                        // Return a whitelist match request allowed.
-                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_WHITELIST, whitelistEntry[0], whitelistEntry[1]};
-                    }
-                    break;
-
-                case 3:  // There are two entries.
-                    if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
-                        // Return a whitelist match request allowed.
-                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                    }
-                    break;
-
-                case 4:  // There are three entries.
-                    if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
-                        // Return a whitelist match request allowed.
-                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2], whitelistEntry[3]};
-                    }
-                    break;
-            }
-        }
-
-        // Final white list.
-        for (String[] whitelistEntry : blocklist.get(Integer.parseInt(FINAL_WHITELIST))) {
-            if (whitelistEntry.length == 2) {  // There is one entry.
-                if (resourceUrl.contains(whitelistEntry[0])) {
-                    // Return a whitelist match request allowed.
-                    return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_WHITELIST, whitelistEntry[0], whitelistEntry[1]};
-                }
-            } else {  // There are two entries.
-                if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
-                    // Return a whitelist match request allowed.
-                    return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                }
-            }
-        }
-
-        // Only check the domain lists if the current domain is not null (like `about:blank`).
-        if (currentDomain != null) {
-            // Domain white list.
-            for (String[] whitelistEntry : blocklist.get(Integer.parseInt(DOMAIN_WHITELIST))) {
-                switch (whitelistEntry.length) {
-                    case 3:  // There is one entry.
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are two entries.
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2],
-                                    whitelistEntry[3]};
-                        }
-                        break;
-
-                    case 5:  // There are three entries.
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2] + "\n" +
-                                    whitelistEntry[3], whitelistEntry[4]};
-                        }
-                        break;
-
-                    case 6:  // There are four entries.
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) &&
-                                resourceUrl.contains(whitelistEntry[4])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2] + "\n" +
-                                    whitelistEntry[3] + "\n" + whitelistEntry[4], whitelistEntry[5]};
-                        }
-                        break;
-                }
-            }
-
-            // Domain initial white list.
-            for (String[] whitelistEntry : blocklist.get(Integer.parseInt(DOMAIN_INITIAL_WHITELIST))) {
-                switch (whitelistEntry.length) {
-                    case 3:  // There is one entry.
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are two entries.
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2],
-                                    whitelistEntry[3]};
-                        }
-                        break;
-
-                    case 5:  // There are three entries.
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.startsWith(whitelistEntry[3])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2] + "\n" +
-                                    whitelistEntry[3], whitelistEntry[4]};
-                        }
-                        break;
-                }
-            }
-
-            // Domain final white list.
-            for (String[] whitelistEntry : blocklist.get(Integer.parseInt(DOMAIN_FINAL_WHITELIST))) {
-                switch (whitelistEntry.length) {
-                    case 3:  // There is one entry;
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.endsWith(whitelistEntry[1])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are two entries;
-                        if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.endsWith(whitelistEntry[2])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2],
-                                    whitelistEntry[3]};
-                        }
-                        break;
-                }
-            }
-        }
-
-        // Only check the third-party white lists if this is a third-party request.
-        if (isThirdPartyRequest) {
-            // Third-party white list.
-            for (String[] whitelistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_WHITELIST))) {
-                switch (whitelistEntry.length) {
-                    case 2:  // There is one entry
-                        if (resourceUrl.contains(whitelistEntry[0])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whitelistEntry[0], whitelistEntry[1]};
-                        }
-                        break;
-
-                    case 3:  // There are two entries.
-                        if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are three entries.
-                        if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2],
-                                    whitelistEntry[3]};
-                        }
-                        break;
-
-                    case 5:  // There are four entries.
-                        if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2] + "\n" +
-                                    whitelistEntry[3], whitelistEntry[4]};
-                        }
-                        break;
-
-                    case 6:  // There are five entries.
-                        if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) &&
-                                resourceUrl.contains(whitelistEntry[4])) {
-                            // Return a whitelist match request allowed.
-                            return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2] + "\n" +
-                                    whitelistEntry[3] + "\n" + whitelistEntry[4], whitelistEntry[5]};
-                        }
-                        break;
-                }
-            }
-
-            // Third-party domain white list.
-            for (String[] whitelistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_DOMAIN_WHITELIST))) {
-                if (whitelistEntry.length == 3) {  // There is one entry.
-                    if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
-                        // Return a whitelist match request allowed.
-                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                    }
-                } else {  // There are two entries.
-                    if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
-                        // Return a whitelist match request allowed.
-                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2],
-                                whitelistEntry[3]};
-                    }
-                }
-            }
-
-            // Third-party domain initial white list.
-            for (String[] whitelistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_DOMAIN_INITIAL_WHITELIST))) {
-                if (whitelistEntry.length == 3) {  // There is one entry.
-                    if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) {
-                        // Return a whitelist match request allowed.
-                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1], whitelistEntry[2]};
-                    }
-                } else {  // There are two entries.
-                    if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
-                        // Return a whitelist match request allowed.
-                        return new String[] {REQUEST_ALLOWED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_WHITELIST, whitelistEntry[0] + "\n" + whitelistEntry[1] + "\n" + whitelistEntry[2],
-                                whitelistEntry[3]};
-                    }
-                }
-            }
-        }
-
-        // Process the black lists.
-        // Main black list.
-        for (String[] blacklistEntry : blocklist.get(Integer.parseInt(MAIN_BLACKLIST))) {
-            switch (blacklistEntry.length) {
-                case 2:  // There is one entry.
-                    if (resourceUrl.contains(blacklistEntry[0])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blacklistEntry[0], blacklistEntry[1]};
-                    }
-                    break;
-
-                case 3:  // There are two entries.
-                    if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                    }
-                    break;
-
-                case 4:  // There are three entries.
-                    if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2], blacklistEntry[3]};
-                    }
-                    break;
-
-                case 5:  // There are four entries.
-                    if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2] + "\n" +
-                                blacklistEntry[3], blacklistEntry[4]};
-                    }
-                    break;
-
-                case 6:  // There are five entries.
-                    if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3]) &&
-                            resourceUrl.contains(blacklistEntry[4])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, MAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2] + "\n" +
-                                blacklistEntry[3] + "\n" + blacklistEntry[4], blacklistEntry[5]};
-                    }
-                    break;
-            }
-        }
-
-        // Initial black list.
-        for (String[] blacklistEntry : blocklist.get(Integer.parseInt(INITIAL_BLACKLIST))) {
-            if (blacklistEntry.length == 2) {  // There is one entry.
-                if (resourceUrl.startsWith(blacklistEntry[0])) {
-                    // Return a blacklist match request blocked.
-                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]};
-                }
-            } else {  // There are two entries
-                if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
-                    // Return a blacklist match request blocked.
-                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, INITIAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                }
-            }
-        }
-
-        // Final black list.
-        for (String[] blacklistEntry : blocklist.get(Integer.parseInt(FINAL_BLACKLIST))) {
-            switch (blacklistEntry.length) {
-                case 2:  // There is one entry.
-                    if (resourceUrl.endsWith(blacklistEntry[0])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]};
-                    }
-                    break;
-
-                case 3:  // There are two entries.
-                    if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                    }
-                    break;
-
-                case 4:  // There are three entries.
-                    if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, FINAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2], blacklistEntry[3]};
-                    }
-                    break;
-            }
-        }
-
-        // Only check the domain lists if the current domain is not null (like `about:blank`).
-        if (currentDomain != null) {
-            // Domain black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(DOMAIN_BLACKLIST))) {
-                switch (blacklistEntry.length) {
-                    case 3:  // There is one entry.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are two entries.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2],
-                                    blacklistEntry[3]};
-                        }
-                        break;
-
-                    case 5:  // There are three entries.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2] + "\n" +
-                                    blacklistEntry[3], blacklistEntry[4]};
-                        }
-                        break;
-                }
-            }
-
-            // Domain initial black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(DOMAIN_INITIAL_BLACKLIST))) {
-                // Store the entry in the resource request log.
-                if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) {
-                    // Return a blacklist match request blocked.
-                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_INITIAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                }
-            }
-
-            // Domain final black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(DOMAIN_FINAL_BLACKLIST))) {
-                switch (blacklistEntry.length) {
-                    case 3:  // There is one entry.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are two entries.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_FINAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2],
-                                    blacklistEntry[3]};
-                        }
-                        break;
-                }
-            }
-
-            // Domain regular expression black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(DOMAIN_REGULAR_EXPRESSION_BLACKLIST))) {
-                if (currentDomain.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) {
-                    // Return a blacklist match request blocked.
-                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, DOMAIN_REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                }
-            }
-        }
-
-        // Only check the third-party black lists if this is a third-party request.
-        if (isThirdPartyRequest) {
-            // Third-party black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_BLACKLIST))) {
-                switch (blacklistEntry.length) {
-                    case 2:  // There is one entry.
-                        if (resourceUrl.contains(blacklistEntry[0])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blacklistEntry[0], blacklistEntry[1]};
-                        }
-                        break;
-
-                    case 3:  // There are two entries.
-                        if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are three entries.
-                        if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2],
-                                    blacklistEntry[3]};
-                        }
-                        break;
-
-                    case 5:  // There are four entries.
-                        if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2] + "\n" +
-                                    blacklistEntry[3], blacklistEntry[4]};
-                        }
-                        break;
-                }
-            }
-
-            // Third-party initial black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_INITIAL_BLACKLIST))) {
-                if (blacklistEntry.length == 2) {  // There is one entry.
-                    if (resourceUrl.startsWith(blacklistEntry[0])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1]};
-                    }
-                } else {  // There are two entries.
-                    if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_INITIAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                    }
-                }
-            }
-
-            // Third-party domain black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_DOMAIN_BLACKLIST))) {
-                if (blacklistEntry.length == 3) {  // There is one entry.
-                    if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                    }
-                } else { // There are two entries.
-                    if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
-                        // Return a blacklist match request blocked.
-                        return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" + blacklistEntry[2],
-                                blacklistEntry[3]};
-                    }
-                }
-            }
-
-            // Third-party domain initial black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST))) {
-                switch (blacklistEntry.length) {
-                    case 3:  // There is one entry.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                        }
-                        break;
-
-                    case 4:  // There are two entries.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" +
-                                    blacklistEntry[2], blacklistEntry[3]};
-                        }
-                        break;
-
-                    case 5:  // There are three entries.
-                        if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
-                            // Return a blacklist match request blocked.
-                            return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1] + "\n" +
-                                    blacklistEntry[2] + "\n" + blacklistEntry[3], blacklistEntry[4]};
-                        }
-                        break;
-                }
-            }
-
-            // Third-party regular expression black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST))) {
-                if (Pattern.matches(blacklistEntry[0], resourceUrl)) {
-                    // Return a blacklist match request blocked.
-                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1]};
-                }
-            }
-
-            // Third-party domain regular expression black list.
-            for (String[] blacklistEntry : blocklist.get(Integer.parseInt(THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST))) {
-                if (currentDomain.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) {
-                    // Return a blacklist match request blocked.
-                    return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0] + "\n" + blacklistEntry[1], blacklistEntry[2]};
-                }
-            }
-        }
-
-        // Regular expression black list.
-        for (String[] blacklistEntry : blocklist.get(Integer.parseInt(REGULAR_EXPRESSION_BLACKLIST))) {
-            if (Pattern.matches(blacklistEntry[0], resourceUrl)) {
-                // Return a blacklist match request blocked.
-                return new String[] {REQUEST_BLOCKED, resourceUrl, BLOCK_LIST_NAME_STRING, REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1]};
-            }
-        }
-
-        // Return a no match request default.
-        return new String[] {REQUEST_DEFAULT};
-    }
-}
\ No newline at end of file
diff --git a/app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.kt b/app/src/main/java/com/stoutner/privacybrowser/helpers/BlocklistHelper.kt
new file mode 100644 (file)
index 0000000..104d15c
--- /dev/null
@@ -0,0 +1,2066 @@
+/*
+ * Copyright © 2018-2019,2021-2022 Soren Stoutner <soren@stoutner.com>.
+ *
+ * This file is part of Privacy Browser Android <https://www.stoutner.com/privacy-browser-android>.
+ *
+ * Privacy Browser Android is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Privacy Browser Android is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Privacy Browser Android.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.stoutner.privacybrowser.helpers
+
+import android.content.res.AssetManager
+
+import java.io.BufferedReader
+import java.io.IOException
+import java.io.InputStreamReader
+import java.util.ArrayList
+import java.util.regex.Pattern
+
+class BlocklistHelper {
+    companion object {
+        // Describe the schema of the string array in each entry of the resource requests array list.
+        const val REQUEST_DISPOSITION = 0
+        const val REQUEST_URL = 1
+        const val REQUEST_BLOCKLIST = 2
+        const val REQUEST_SUBLIST = 3
+        const val REQUEST_BLOCKLIST_ENTRIES = 4
+        const val REQUEST_BLOCKLIST_ORIGINAL_ENTRY = 5
+
+        // The request disposition options.
+        const val REQUEST_DEFAULT = "0"
+        const val REQUEST_ALLOWED = "1"
+        const val REQUEST_THIRD_PARTY = "2"
+        const val REQUEST_BLOCKED = "3"
+
+        // The whitelists.
+        const val MAIN_WHITELIST = "1"
+        const val FINAL_WHITELIST = "2"
+        const val DOMAIN_WHITELIST = "3"
+        const val DOMAIN_INITIAL_WHITELIST = "4"
+        const val DOMAIN_FINAL_WHITELIST = "5"
+        const val THIRD_PARTY_WHITELIST = "6"
+        const val THIRD_PARTY_DOMAIN_WHITELIST = "7"
+        const val THIRD_PARTY_DOMAIN_INITIAL_WHITELIST = "8"
+
+        // The blacklists.
+        const val MAIN_BLACKLIST = "9"
+        const val INITIAL_BLACKLIST = "10"
+        const val FINAL_BLACKLIST = "11"
+        const val DOMAIN_BLACKLIST = "12"
+        const val DOMAIN_INITIAL_BLACKLIST = "13"
+        const val DOMAIN_FINAL_BLACKLIST = "14"
+        const val DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "15"
+        const val THIRD_PARTY_BLACKLIST = "16"
+        const val THIRD_PARTY_INITIAL_BLACKLIST = "17"
+        const val THIRD_PARTY_DOMAIN_BLACKLIST = "18"
+        const val THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST = "19"
+        const val THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST = "20"
+        const val THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST = "21"
+        const val REGULAR_EXPRESSION_BLACKLIST = "22"
+    }
+
+    fun parseBlocklist(assetManager: AssetManager, blocklistName: String): ArrayList<List<Array<String>>> {
+        // Initialize the header list.
+        val headers: MutableList<Array<String>> = ArrayList()  // 0.
+
+        // Initialize the whitelists.
+        val mainWhitelist: MutableList<Array<String>> = ArrayList()  // 1.
+        val finalWhitelist: MutableList<Array<String>> = ArrayList()  // 2.
+        val domainWhitelist: MutableList<Array<String>> = ArrayList()  // 3.
+        val domainInitialWhitelist: MutableList<Array<String>> = ArrayList()  // 4.
+        val domainFinalWhitelist: MutableList<Array<String>> = ArrayList()  // 5.
+        val thirdPartyWhitelist: MutableList<Array<String>> = ArrayList()  // 6.
+        val thirdPartyDomainWhitelist: MutableList<Array<String>> = ArrayList()  // 7.
+        val thirdPartyDomainInitialWhitelist: MutableList<Array<String>> = ArrayList()  // 8.
+
+        // Initialize the blacklists.
+        val mainBlacklist: MutableList<Array<String>> = ArrayList()  // 9.
+        val initialBlacklist: MutableList<Array<String>> = ArrayList()  // 10.
+        val finalBlacklist: MutableList<Array<String>> = ArrayList()  // 11.
+        val domainBlacklist: MutableList<Array<String>> = ArrayList()  // 12.
+        val domainInitialBlacklist: MutableList<Array<String>> = ArrayList()  // 13.
+        val domainFinalBlacklist: MutableList<Array<String>> = ArrayList()  // 14.
+        val domainRegularExpressionBlacklist: MutableList<Array<String>> = ArrayList()  // 15.
+        val thirdPartyBlacklist: MutableList<Array<String>> = ArrayList()  // 16.
+        val thirdPartyInitialBlacklist: MutableList<Array<String>> = ArrayList()  // 17.
+        val thirdPartyDomainBlacklist: MutableList<Array<String>> = ArrayList()  // 18.
+        val thirdPartyDomainInitialBlacklist: MutableList<Array<String>> = ArrayList()  // 19.
+        val regularExpressionBlacklist: MutableList<Array<String>> = ArrayList()  // 20.
+        val thirdPartyRegularExpressionBlacklist: MutableList<Array<String>> = ArrayList()  // 21.
+        val thirdPartyDomainRegularExpressionBlacklist: MutableList<Array<String>> = ArrayList()  // 22.
+
+        // Populate the blocklists.  The `try` is required by input stream reader.
+        try {
+            // Load the blocklist into a buffered reader.
+            val bufferedReader = BufferedReader(InputStreamReader(assetManager.open(blocklistName)))
+
+            // Create strings for storing the block list entries.
+            var blocklistEntry: String
+            var originalBlocklistEntry: String
+
+            // Parse the block list.
+            bufferedReader.forEachLine {
+                // Store the original block list entry.
+                originalBlocklistEntry = it
+
+                // Remove any `^` from the block list entry.  Privacy Browser does not process them in the interest of efficiency.
+                blocklistEntry = it.replace("^", "")
+
+                // Parse the entry.
+                if (blocklistEntry.contains("##") || blocklistEntry.contains("#?#") || blocklistEntry.contains("#@#") || blocklistEntry.startsWith("[")) {
+                    // Entries that contain `##`, `#?#`, and `#@#` are for hiding elements in the main page's HTML.  Entries that start with `[` describe the AdBlock compatibility level.
+                    // Do nothing.  Privacy Browser does not currently use these entries.
+
+                    //Log.i("Blocklists", "Not added: " + blocklistEntry);
+                } else if (blocklistEntry.contains("\$csp=script-src")) {  // Ignore entries that contain `$csp=script-src`.
+                    // Do nothing.  It is uncertain what this directive is even supposed to mean, and it is blocking entire websites like androidcentral.com.  https://redmine.stoutner.com/issues/306.
+
+                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                } else if (blocklistEntry.contains("\$websocket") || blocklistEntry.contains("\$third-party,websocket") || blocklistEntry.contains("\$script,websocket")) {
+                    // Ignore entries with `websocket`.
+                    // Do nothing.  Privacy Browser does not differentiate between websocket requests and other requests and these entries cause a lot of false positives.
+
+                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                } else if (blocklistEntry.startsWith("!")) {  //  Comment entries.
+                    if (blocklistEntry.startsWith("! Version:")) {
+                        // Get the list version number.
+                        val listVersion = arrayOf(blocklistEntry.substring(11))
+
+                        // Store the list version in the headers list.
+                        headers.add(listVersion)
+                    }
+
+                    if (blocklistEntry.startsWith("! Title:")) {
+                        // Get the list title.
+                        val listTitle = arrayOf(blocklistEntry.substring(9))
+
+                        // Store the list title in the headers list.
+                        headers.add(listTitle)
+                    }
+
+                    //Log.i("Blocklists", "Not added: " + blocklistEntry);
+                } else if (blocklistEntry.startsWith("@@")) {  // Entries that begin with `@@` are whitelists.
+                    // Remove the `@@`
+                    blocklistEntry = blocklistEntry.substring(2)
+
+                    // Strip out any initial `||`.  Privacy Browser doesn't differentiate items that only match against the end of the domain name.
+                    if (blocklistEntry.startsWith("||")) {
+                        blocklistEntry = blocklistEntry.substring(2)
+                    }
+
+                    if (blocklistEntry.contains("$")) {  // Filter entries.
+                        if (blocklistEntry.contains("~third-party")) {  // Ignore entries that contain `~third-party`.
+                            // Do nothing.
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                        } else if (blocklistEntry.contains("third-party")) {  // Third-party whitelist entries.
+                            if (blocklistEntry.contains("domain=")) {  // Third-party domain whitelist entries.
+                                // Parse the entry.
+                                var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                                val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1)
+                                var domains = filters.substring(filters.indexOf("domain=") + 7)
+
+                                if (domains.contains("~")) {  // It is uncertain what a `~` domain means inside an `@@` entry.
+                                    // Do Nothing
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                                } else if (blocklistEntry.startsWith("|")) {  // Third-party domain initial whitelist entries.
+                                    // Strip out the initial `|`.
+                                    entry = entry.substring(1)
+
+                                    if (entry == "http://" || entry == "https://") {  // Ignore generic entries.
+                                        // Do nothing.  These entries are designed for filter options that Privacy Browser does not use.
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                                    } else {  // Process third-party domain initial whitelist entries.
+                                        // Process each domain.
+                                        do {
+                                            // Create a string to keep track of the current domain.
+                                            var domain: String
+
+                                            if (domains.contains("|")) {  // There is more than one domain in the list.
+                                                // Get the first domain from the list.
+                                                domain = domains.substring(0, domains.indexOf("|"))
+
+                                                // Remove the first domain from the list.
+                                                domains = domains.substring(domains.indexOf("|") + 1)
+                                            } else {  // There is only one domain in the list.
+                                                domain = domains
+                                            }
+
+                                            if (entry.contains("*")) {  // Process a third-party domain initial whitelist double entry.
+                                                // Get the index of the wildcard.
+                                                val wildcardIndex = entry.indexOf("*")
+
+                                                // Split the entry into components.
+                                                val firstEntry = entry.substring(0, wildcardIndex)
+                                                val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                                // Create an entry string array.
+                                                val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the whitelist.
+                                                thirdPartyDomainInitialWhitelist.add(domainDoubleEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry +
+                                                //        "  -  " + originalBlocklistEntry);
+                                            } else {  // Process a third-party domain initial whitelist single entry.
+                                                // Create a domain entry string array.
+                                                val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                                // Add the entry to the third party domain initial whitelist.
+                                                thirdPartyDomainInitialWhitelist.add(domainEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial whitelist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                            }
+                                        } while (domains.contains("|"))
+                                    }
+                                } else {  // Third-party domain entries.
+                                    // Process each domain.
+                                    do {
+                                        // Create a string to keep track of the current domain.
+                                        var domain: String
+
+                                        if (domains.contains("|")) {  // three is more than one domain in the list.
+                                            // Get the first domain from the list.
+                                            domain = domains.substring(0, domains.indexOf("|"))
+
+                                            // Remove the first domain from the list.
+                                            domains = domains.substring(domains.indexOf("|") + 1)
+                                        } else {  // There is only one domain in the list.
+                                            domain = domains
+                                        }
+
+                                        // Remove any trailing `*` from the entry.
+                                        if (entry.endsWith("*")) {
+                                            entry = entry.substring(0, entry.length - 1)
+                                        }
+
+                                        if (entry.contains("*")) {  // Process a third-party domain double entry.
+                                            // Get the index of the wildcard.
+                                            val wildcardIndex = entry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val firstEntry = entry.substring(0, wildcardIndex)
+                                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                            // Create an entry string array.
+                                            val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                            // Add the entry to the whitelist.
+                                            thirdPartyDomainWhitelist.add(domainDoubleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                            //        originalBlocklistEntry);
+                                        } else {  // Process a third-party domain single entry.
+                                            // Create an entry string array.
+                                            val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                            // Add the entry to the whitelist.
+                                            thirdPartyDomainWhitelist.add(domainEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                        }
+                                    } while (domains.contains("|"))
+                                }
+                            } else {  // Process third-party whitelist entries.
+                                // Parse the entry
+                                val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+
+                                if (entry.contains("*")) {  // There are two or more entries.
+                                    // Get the index of the wildcard.
+                                    val wildcardIndex = entry.indexOf("*")
+
+                                    // Split the entry into components.
+                                    val firstEntry = entry.substring(0, wildcardIndex)
+                                    val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                    if (secondEntry.contains("*")) {  // There are three or more entries.
+                                        // Get the index of the wildcard.
+                                        val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                        val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                        if (thirdEntry.contains("*")) {  // There are four or more entries.
+                                            // Get the index of the wildcard.
+                                            val thirdWildcardIndex = thirdEntry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex)
+                                            val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1)
+
+                                            if (fourthEntry.contains("*")) {  // Process a third-party whitelist quintuple entry.
+                                                // Get the index of the wildcard.
+                                                val fourthWildcardIndex = fourthEntry.indexOf("*")
+
+                                                // Split the entry into components.
+                                                val realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex)
+                                                val fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1)
+
+                                                // Create an entry string array.
+                                                val quintupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the whitelist.
+                                                thirdPartyWhitelist.add(quintupleEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
+                                                //        realFourthEntry + " , " + fifthEntry + "  -  " + originalBlocklistEntry);
+                                            } else {  // Process a third-party whitelist quadruple entry.
+                                                // Create an entry string array.
+                                                val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the whitelist.
+                                                thirdPartyWhitelist.add(quadrupleEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
+                                                //        fourthEntry + "  -  " + originalBlocklistEntry);
+                                            }
+                                        } else {  // Process a third-party whitelist triple entry.
+                                            // Create an entry string array.
+                                            val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                            // Add the entry to the whitelist.
+                                            thirdPartyWhitelist.add(tripleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " +
+                                            //        originalBlocklistEntry);
+                                        }
+                                    } else {  // Process a third-party whitelist double entry.
+                                        // Create an entry string array.
+                                        val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the whitelist.
+                                        thirdPartyWhitelist.add(doubleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party whitelist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                                    }
+                                } else {  // Process a third-party whitelist single entry.
+                                    // Create an entry string array.
+                                    val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                                    // Add the entry to the whitelist.
+                                    thirdPartyWhitelist.add(singleEntry)
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + entry + "  -  " + originalBlocklistEntry);
+                                }
+                            }
+                        } else if (blocklistEntry.contains("domain=")) {  // Process domain whitelist entries.
+                            // Parse the entry
+                            var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                            val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1)
+                            var domains = filters.substring(filters.indexOf("domain=") + 7)
+
+                            if (entry.startsWith("|")) {  // Initial domain whitelist entries.
+                                // Strip the initial `|`.
+                                entry = entry.substring(1)
+
+                                if (entry == "http://" || entry == "https://") {  // Ignore generic entries.
+                                    // Do nothing.  These entries are designed for filter options that Privacy Browser does not use.
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                                } else {  // Initial domain whitelist entry.
+                                    // Process each domain.
+                                    do {
+                                        // Create a string to keep track of the current domain.
+                                        var domain: String
+
+                                        if (domains.contains("|")) {  // There is more than one domain in the list.
+                                            // Get the first domain from the list.
+                                            domain = domains.substring(0, domains.indexOf("|"))
+
+                                            // Remove the first domain from the list.
+                                            domains = domains.substring(domains.indexOf("|") + 1)
+                                        } else {  // There is only one domain in the list.
+                                            domain = domains
+                                        }
+
+                                        if (entry.contains("*")) {  // There are two or more entries.
+                                            // Get the index of the wildcard.
+                                            val wildcardIndex = entry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val firstEntry = entry.substring(0, wildcardIndex)
+                                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                            if (secondEntry.contains("*")) {  // Process a domain initial triple entry.
+                                                // Get the index of the wildcard.
+                                                val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                                // Split the entry into components.
+                                                val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                                val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                                // Create an entry string array.
+                                                val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the whitelist.
+                                                domainInitialWhitelist.add(domainTripleEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " +
+                                                //        thirdEntry + "  -  " + originalBlocklistEntry);
+                                            } else {  // Process a domain initial double entry.
+                                                // Create an entry string array.
+                                                val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the whitelist.
+                                                domainInitialWhitelist.add(domainDoubleEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                                //        originalBlocklistEntry);
+                                            }
+                                        } else {  // Process a domain initial single entry.
+                                            // Create an entry string array.
+                                            val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                            // Add the entry to the whitelist.
+                                            domainInitialWhitelist.add(domainEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " domain initial whitelist entry added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                        }
+                                    } while (domains.contains("|"))
+                                }
+                            } else if (entry.endsWith("|")) {  // Final domain whitelist entries.
+                                // Strip the `|` from the end of the entry.
+                                entry = entry.substring(0, entry.length - 1)
+
+                                // Process each domain.
+                                do {
+                                    // Create a string to keep track of the current domain.
+                                    var domain: String
+
+                                    if (domains.contains("|")) {  // There is more than one domain in the list.
+                                        // Get the first domain from the list.
+                                        domain = domains.substring(0, domains.indexOf("|"))
+
+                                        // Remove the first domain from the list.
+                                        domains = domains.substring(domains.indexOf("|") + 1)
+                                    } else {  // There is only one domain in the list.
+                                        domain = domains
+                                    }
+
+                                    if (entry.contains("*")) {  // Process a domain final whitelist double entry.
+                                        // Get the index of the wildcard.
+                                        val wildcardIndex = entry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val firstEntry = entry.substring(0, wildcardIndex)
+                                        val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                        // Create an entry string array.
+                                        val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the whitelist.
+                                        domainFinalWhitelist.add(domainDoubleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " domain final whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                        //        originalBlocklistEntry);
+                                    } else {  // Process a domain final whitelist single entry.
+                                        // create an entry string array.
+                                        val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                        // Add the entry to the whitelist.
+                                        domainFinalWhitelist.add(domainEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " domain final whitelist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                    }
+                                } while (domains.contains("|"))
+                            } else {  // Standard domain whitelist entries with filters.
+                                if (domains.contains("~")) {  // It is uncertain what a `~` domain means inside an `@@` entry.
+                                    // Do Nothing
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                                } else {
+                                    // Process each domain.
+                                    do {
+                                        // Create a string to keep track of the current domain.
+                                        var domain: String
+
+                                        if (domains.contains("|")) {  // There is more than one domain in the list.
+                                            // Get the first domain from the list.
+                                            domain = domains.substring(0, domains.indexOf("|"))
+
+                                            // Remove the first domain from the list.
+                                            domains = domains.substring(domains.indexOf("|") + 1)
+                                        } else {  // There is only one domain in the list.
+                                            domain = domains
+                                        }
+
+                                        if (entry.contains("*")) {  // There are two or more entries.
+                                            // Get the index of the wildcard.
+                                            val wildcardIndex = entry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val firstEntry = entry.substring(0, wildcardIndex)
+                                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                            if (secondEntry.contains("*")) {  // There are three or more entries.
+                                                // Get the index of the wildcard.
+                                                val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                                // Split the entry into components.
+                                                val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                                val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                                if (thirdEntry.contains("*")) {  // Process a domain whitelist quadruple entry.
+                                                    // Get the index of the wildcard.
+                                                    val thirdWildcardIndex = thirdEntry.indexOf("*")
+
+                                                    // Split the entry into components.
+                                                    val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex)
+                                                    val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1)
+
+                                                    // Create an entry string array.
+                                                    val domainQuadrupleEntry = arrayOf(domain, firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry)
+
+                                                    // Add the entry to the whitelist.
+                                                    domainWhitelist.add(domainQuadrupleEntry)
+
+                                                    //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " +
+                                                    //        realThirdEntry + " , " + fourthEntry + "  -  " + originalBlocklistEntry);
+                                                } else {  // Process a domain whitelist triple entry.
+                                                    // Create an entry string array.
+                                                    val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                                    // Add the entry to the whitelist.
+                                                    domainWhitelist.add(domainTripleEntry)
+
+                                                    //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " +
+                                                    //        thirdEntry + "  -  " + originalBlocklistEntry);
+                                                }
+                                            } else {  // Process a domain whitelist double entry.
+                                                // Create an entry string array.
+                                                val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the whitelist.
+                                                domainWhitelist.add(domainDoubleEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                                //        originalBlocklistEntry);
+                                            }
+                                        } else {  // Process a domain whitelist single entry.
+                                            // Create an entry string array.
+                                            val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                            // Add the entry to the whitelist.
+                                            domainWhitelist.add(domainEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added : " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                        }
+                                    } while (domains.contains("|"))
+                                }
+                            }
+                        }  // Ignore all other filter entries.
+                    } else if (blocklistEntry.endsWith("|")) {  // Final whitelist entries.
+                        // Remove the final `|` from the entry.
+                        val entry = blocklistEntry.substring(0, blocklistEntry.length - 1)
+
+                        if (entry.contains("*")) {  // Process a final whitelist double entry
+                            // Get the index of the wildcard.
+                            val wildcardIndex = entry.indexOf("*")
+
+                            // split the entry into components.
+                            val firstEntry = entry.substring(0, wildcardIndex)
+                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                            // Create an entry string array.
+                            val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                            // Add the entry to the whitelist.
+                            finalWhitelist.add(doubleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " final whitelist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                        } else {  // Process a final whitelist single entry.
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                            // Add the entry to the whitelist.
+                            finalWhitelist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " final whitelist added: " + entry + "  -  " + originalBlocklistEntry);
+                        }
+                    } else {  // Main whitelist entries.
+                        if (blocklistEntry.contains("*")) {  // There are two or more entries.
+                            // Get the index of the wildcard.
+                            val wildcardIndex = blocklistEntry.indexOf("*")
+
+                            // Split the entry into components.
+                            val firstEntry = blocklistEntry.substring(0, wildcardIndex)
+                            val secondEntry = blocklistEntry.substring(wildcardIndex + 1)
+
+                            if (secondEntry.contains("*")) {  // Process a main whitelist triple entry.
+                                // Get the index of the wildcard.
+                                val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                // Split the entry into components.
+                                val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                // Create an entry string array.
+                                val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                // Add the entry to the whitelist.
+                                mainWhitelist.add(tripleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " + originalBlocklistEntry);
+                            } else {  // Process a main whitelist double entry.
+                                // Create an entry string array.
+                                val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                // Add the entry to the whitelist.
+                                mainWhitelist.add(doubleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                            }
+                        } else {  // Process a main whitelist single entry.
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry)
+
+                            // Add the entry to the whitelist.
+                            mainWhitelist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
+                        }
+                    }
+                } else if (blocklistEntry.endsWith("|")) {  // Final blacklist entries.
+                    // Strip out the final "|"
+                    var entry = blocklistEntry.substring(0, blocklistEntry.length - 1)
+
+                    // Strip out any initial `||`.  They are redundant in this case because the blocklist entry is being matched against the end of the URL.
+                    if (entry.startsWith("||")) {
+                        entry = entry.substring(2)
+                    }
+
+                    if (entry.contains("*")) {  // Process a final blacklist double entry.
+                        // Get the index of the wildcard.
+                        val wildcardIndex = entry.indexOf("*")
+
+                        // Split the entry into components.
+                        val firstEntry = entry.substring(0, wildcardIndex)
+                        val secondEntry = entry.substring(wildcardIndex + 1)
+
+                        // Create an entry string array.
+                        val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                        // Add the entry to the blacklist.
+                        finalBlacklist.add(doubleEntry)
+
+                        //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                    } else {  // Process a final blacklist single entry.
+                        // create an entry string array.
+                        val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                        // Add the entry to the blacklist.
+                        finalBlacklist.add(singleEntry)
+
+                        //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                    }
+                } else if (blocklistEntry.contains("$")) {  // Entries with filter options.
+                    // Strip out any initial `||`.  These will be treated like any other entry.
+                    if (blocklistEntry.startsWith("||")) {
+                        blocklistEntry = blocklistEntry.substring(2)
+                    }
+
+                    if (blocklistEntry.contains("third-party")) {  // Third-party entries.
+                        if (blocklistEntry.contains("~third-party")) {  // Third-party filter whitelist entries.
+                            // Do not process these whitelist entries.  They are designed to combine with block filters that Privacy Browser doesn't use, like `subdocument` and `xmlhttprequest`.
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                        } else if (blocklistEntry.contains("domain=")) {  // Third-party domain entries.
+                            if (blocklistEntry.startsWith("|")) {  // Third-party domain initial entries.
+                                // Strip the initial `|`.
+                                blocklistEntry = blocklistEntry.substring(1)
+
+                                // Parse the entry
+                                val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                                val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1)
+                                var domains = filters.substring(filters.indexOf("domain=") + 7)
+
+                                if (entry == "http:" || entry == "https:" || entry == "http://" || entry == "https://") {  // Ignore generic entries.
+                                    // Do nothing.  These entries will almost entirely disable the website.
+                                    // Often the original entry blocks filter options like `$script`, which Privacy Browser does not differentiate.
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                                } else {  // Third-party domain initial entries.
+                                    // Process each domain.
+                                    do {
+                                        // Create a string to keep track of the current domain.
+                                        var domain: String
+
+                                        if (domains.contains("|")) {  // There is more than one domain in the list.
+                                            // Get the first domain from the list.
+                                            domain = domains.substring(0, domains.indexOf("|"))
+
+                                            // Remove the first domain from the list.
+                                            domains = domains.substring(domains.indexOf("|") + 1)
+                                        } else {  // There is only one domain in the list.
+                                            domain = domains
+                                        }
+
+                                        if (entry.contains("*")) {  // Three are two or more entries.
+                                            // Get the index of the wildcard.
+                                            val wildcardIndex = entry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val firstEntry = entry.substring(0, wildcardIndex)
+                                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                            if (secondEntry.contains("*")) {  // Process a third-party domain initial blacklist triple entry.
+                                                // Get the index of the wildcard.
+                                                val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                                // Split the entry into components.
+                                                val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                                val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                                // Create an entry string array.
+                                                val tripleDomainEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the blacklist.
+                                                thirdPartyDomainInitialBlacklist.add(tripleDomainEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + firstEntry + " , " + realSecondEntry +
+                                                //        " , " + thirdEntry + "  -  " + originalBlocklistEntry);
+                                            } else {  // Process a third-party domain initial blacklist double entry.
+                                                // Create an entry string array.
+                                                val doubleDomainEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                                // Add the entry to the blacklist.
+                                                thirdPartyDomainInitialBlacklist.add(doubleDomainEntry)
+
+                                                //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry +
+                                                //        "  -  " + originalBlocklistEntry);
+                                            }
+                                        } else {  // Process a third-party domain initial blacklist single entry.
+                                            // Create an entry string array.
+                                            val singleEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist.
+                                            thirdPartyDomainInitialBlacklist.add(singleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain initial blacklist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                        }
+                                    } while (domains.contains("|"))
+                                }
+                            } else if (blocklistEntry.contains("\\")) {  // Process a third-party domain blacklist regular expression.
+                                // Parse the entry.  At least one regular expression in this entry contains `$`, so the parser uses `/$`.
+                                val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("/$") + 1)
+                                val filters = blocklistEntry.substring(blocklistEntry.indexOf("/$") + 2)
+                                var domains = filters.substring(filters.indexOf("domain=") + 7)
+
+                                // Process each domain.
+                                do {
+                                    // Create a string to keep track of the current domain.
+                                    var domain: String
+
+                                    if (domains.contains("|")) {  // There is more than one domain in the list.
+                                        // Get the first domain from the list.
+                                        domain = domains.substring(0, domains.indexOf("|"))
+
+                                        // Remove the first domain from the list.
+                                        domains = domains.substring(domains.indexOf("|") + 1)
+                                    } else {  // There is only one domain in the list.
+                                        domain = domains
+                                    }
+
+                                    // Create an entry string array.
+                                    val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                    // Add the entry to the blacklist.
+                                    thirdPartyDomainRegularExpressionBlacklist.add(domainEntry)
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " third-party domain regular expression blacklist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                } while (domains.contains("|"))
+                            } else {  // Third-party domain entries.
+                                // Parse the entry
+                                var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                                val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1)
+                                var domains = filters.substring(filters.indexOf("domain=") + 7)
+
+                                // Strip any trailing "*" from the entry.
+                                if (entry.endsWith("*")) {
+                                    entry = entry.substring(0, entry.length - 1)
+                                }
+
+                                // Track if any third-party whitelist filters are applied.
+                                var whitelistDomain = false
+
+                                // Process each domain.
+                                do {
+                                    // Create a string to keep track of the current domain.
+                                    var domain: String
+
+                                    if (domains.contains("|")) {  // There is more than one domain in the list.
+                                        // Get the first domain from the list.
+                                        domain = domains.substring(0, domains.indexOf("|"))
+
+                                        // Remove the first domain from the list.
+                                        domains = domains.substring(domains.indexOf("|") + 1)
+                                    } else {  // The is only one domain in the list.
+                                        domain = domains
+                                    }
+
+                                    // Differentiate between blocklist domains and whitelist domains.
+                                    if (domain.startsWith("~")) {  // Whitelist third-party domain entry.
+                                        // Strip the initial `~`.
+                                        domain = domain.substring(1)
+
+                                        // Set the whitelist domain flag.
+                                        whitelistDomain = true
+
+                                        if (entry.contains("*")) {  // Process a third-party domain whitelist double entry.
+                                            // Get the index of the wildcard.
+                                            val wildcardIndex = entry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val firstEntry = entry.substring(0, wildcardIndex)
+                                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                            // Create an entry string array.
+                                            val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                            // Add the entry to the whitelist.
+                                            thirdPartyDomainWhitelist.add(domainDoubleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                            //        originalBlocklistEntry);
+                                        } else {  // Process a third-party domain whitelist single entry.
+                                            // Create an entry string array.
+                                            val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                            // Add the entry to the whitelist.
+                                            thirdPartyDomainWhitelist.add(domainEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain whitelist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                        }
+                                    } else {  // Third-party domain blacklist entries.
+                                        if (entry.contains("*")) {  // Process a third-party domain blacklist double entry.
+                                            // Get the index of the wildcard.
+                                            val wildcardIndex = entry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val firstEntry = entry.substring(0, wildcardIndex)
+                                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                            // Create an entry string array.
+                                            val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist
+                                            thirdPartyDomainBlacklist.add(domainDoubleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                            //        originalBlocklistEntry);
+                                        } else {  // Process a third-party domain blacklist single entry.
+                                            // Create an entry string array.
+                                            val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist.
+                                            thirdPartyDomainBlacklist.add(domainEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " third-party domain blocklist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                        }
+                                    }
+                                } while (domains.contains("|"))
+
+                                // Add a third-party blacklist entry if a whitelist domain was processed.
+                                if (whitelistDomain) {
+                                    if (entry.contains("*")) {  // Process a third-party blacklist double entry.
+                                        // Get the index of the wildcard.
+                                        val wildcardIndex = entry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val firstEntry = entry.substring(0, wildcardIndex)
+                                        val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                        // Create an entry string array.
+                                        val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        thirdPartyBlacklist.add(doubleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                                    } else {  // Process a third-party blacklist single entry.
+                                        // Create an entry string array.
+                                        val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                                        // Add an entry to the blacklist.
+                                        thirdPartyBlacklist.add(singleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                                    }
+                                }
+                            }
+                        } else if (blocklistEntry.startsWith("|")) {  // Third-party initial blacklist entries.
+                            // Strip the initial `|`.
+                            blocklistEntry = blocklistEntry.substring(1)
+
+                            // Get the entry.
+                            val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                            if (entry.contains("*")) {  // Process a third-party initial blacklist double entry.
+                                // Get the index of the wildcard.
+                                val wildcardIndex = entry.indexOf("*")
+
+                                // Split the entry into components.
+                                val firstEntry = entry.substring(0, wildcardIndex)
+                                val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                // Create an entry string array.
+                                val thirdPartyDoubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                thirdPartyInitialBlacklist.add(thirdPartyDoubleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " third-party initial blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                            } else {  // Process a third-party initial blacklist single entry.
+                                // Create an entry string array.
+                                val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                thirdPartyInitialBlacklist.add(singleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " third-party initial blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                            }
+                        } else if (blocklistEntry.contains("\\")) {  // Process a regular expression blacklist entry.
+                            // Prepare a string to hold the entry.
+
+                            // Get the entry.
+                            val entry: String = if (blocklistEntry.contains("$/$")) {  // The first `$` is part of the regular expression.
+                                blocklistEntry.substring(0, blocklistEntry.indexOf("$/$") + 2)
+                            } else {  // The only `$` indicates the filter options.
+                                blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                            }
+
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                            // Add the entry to the blacklist.
+                            thirdPartyRegularExpressionBlacklist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " third-party regular expression blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                        } else if (blocklistEntry.contains("*")) {  // Third-party and regular expression blacklist entries.
+                            // Get the entry.
+                            var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+
+                            if (entry.endsWith("*")) {  // Process a third-party blacklist single entry.
+                                // Strip the final `*`.
+                                entry = entry.substring(0, entry.length - 1)
+
+                                // Create an entry string array.
+                                val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                thirdPartyBlacklist.add(singleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " third party blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                            } else {  // There are two or more entries.
+                                // Get the index of the wildcard.
+                                val wildcardIndex = entry.indexOf("*")
+
+                                // Split the entry into components.
+                                val firstEntry = entry.substring(0, wildcardIndex)
+                                val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                if (secondEntry.contains("*")) {  // There are three or more entries.
+                                    // Get the index of the wildcard.
+                                    val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                    // Split the entry into components.
+                                    val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                    val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                    if (thirdEntry.contains("*")) {  // Process a third-party blacklist quadruple entry.
+                                        // Get the index of the wildcard.
+                                        val thirdWildcardIndex = thirdEntry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex)
+                                        val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1)
+
+                                        // Create an entry string array.
+                                        val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        thirdPartyBlacklist.add(quadrupleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " +
+                                        //        fourthEntry + "  -  " + originalBlocklistEntry);
+                                    } else {  // Process a third-party blacklist triple entry.
+                                        // Create an entry string array.
+                                        val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        thirdPartyBlacklist.add(tripleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " +
+                                        //        originalBlocklistEntry);
+                                    }
+                                } else {  // Process a third-party blacklist double entry.
+                                    // Create an entry string array.
+                                    val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                    // Add the entry to the blacklist.
+                                    thirdPartyBlacklist.add(doubleEntry)
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " third-party blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                                }
+                            }
+                        } else {  // Process a third party blacklist single entry.
+                            // Get the entry.
+                            val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                            // Add the entry to the blacklist.
+                            thirdPartyBlacklist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " third party blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                        }
+                    } else if (blocklistEntry.substring(blocklistEntry.indexOf("$")).contains("domain=")) {  // Domain entries.
+                        if (blocklistEntry.contains("~")) {  // Domain whitelist entries.
+                            // Separate the filters.
+                            var entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                            val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1)
+                            var domains = filters.substring(filters.indexOf("domain=") + 7)
+
+                            // Strip any final `*` from the entry.  They are redundant.
+                            if (entry.endsWith("*")) {
+                                entry = entry.substring(0, entry.length - 1)
+                            }
+
+                            // Process each domain.
+                            do {
+                                // Create a string to keep track of the current domain.
+                                var domain: String
+
+                                if (domains.contains("|")) {  // There is more than one domain in the list.
+                                    // Get the first domain from the list.
+                                    domain = domains.substring(0, domains.indexOf("|"))
+
+                                    // Remove the first domain from the list.
+                                    domains = domains.substring(domains.indexOf("|") + 1)
+                                } else {  // There is only one domain in the list.
+                                    domain = domains
+                                }
+
+                                // Strip the initial `~`.
+                                domain = domain.substring(1)
+                                if (entry.contains("*")) {  // There are two or more entries.
+                                    // Get the index of the wildcard.
+                                    val wildcardIndex = entry.indexOf("*")
+
+                                    // Split the entry into components.
+                                    val firstEntry = entry.substring(0, wildcardIndex)
+                                    val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                    if (secondEntry.contains("*")) {  // Process a domain whitelist triple entry.
+                                        // Get the index of the wildcard.
+                                        val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                        val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                        // Create an entry string array.
+                                        val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the whitelist.
+                                        domainWhitelist.add(domainTripleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry +
+                                        //        "  -  " + originalBlocklistEntry);
+                                    } else {  // Process a domain whitelist double entry.
+                                        // Create an entry string array.
+                                        val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the whitelist.
+                                        domainWhitelist.add(domainDoubleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                                    }
+                                } else {  // Process a domain whitelist single entry.
+                                    // Create an entry string array.
+                                    val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                    // Add the entry to the whitelist.
+                                    domainWhitelist.add(domainEntry)
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " domain whitelist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                }
+                            } while (domains.contains("|"))
+                        } else {  // Domain blacklist entries.
+                            // Separate the filters.
+                            val entry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                            val filters = blocklistEntry.substring(blocklistEntry.indexOf("$") + 1)
+                            var domains = filters.substring(filters.indexOf("domain=") + 7)
+
+                            // Only process the item if the entry is not null.  For example, some lines begin with `$websocket`, which create a null entry.
+                            if (entry != "") {
+                                // Process each domain.
+                                do {
+                                    // Create a string to keep track of the current domain.
+                                    var domain: String
+
+                                    if (domains.contains("|")) {  // There is more than one domain in the list.
+                                        // Get the first domain from the list.
+                                        domain = domains.substring(0, domains.indexOf("|"))
+
+                                        // Remove the first domain from the list.
+                                        domains = domains.substring(domains.indexOf("|") + 1)
+                                    } else {  // There is only one domain in the list.
+                                        domain = domains
+                                    }
+
+                                    if (entry.startsWith("|")) {  // Domain initial blacklist entries.
+                                        // Remove the initial `|`;
+                                        val entryBase = entry.substring(1)
+
+                                        if (entryBase == "http://" || entryBase == "https://") {
+                                            // Do nothing.  These entries will entirely block the website.
+                                            // Often the original entry blocks `$script` but Privacy Browser does not currently differentiate between scripts and other entries.
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " not added: " + originalBlocklistEntry);
+                                        } else {  // Process a domain initial blacklist entry
+                                            // Create an entry string array.
+                                            val domainEntry = arrayOf(domain, entryBase, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist.
+                                            domainInitialBlacklist.add(domainEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " domain initial blacklist added: " + domain + " , " + entryBase + "  -  " + originalBlocklistEntry);
+                                        }
+                                    } else if (entry.endsWith("|")) {  // Domain final blacklist entries.
+                                        // Remove the final `|`.
+                                        val entryBase = entry.substring(0, entry.length - 1)
+
+                                        if (entryBase.contains("*")) {  // Process a domain final blacklist double entry.
+                                            // Get the index of the wildcard.
+                                            val wildcardIndex = entry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val firstEntry = entryBase.substring(0, wildcardIndex)
+                                            val secondEntry = entryBase.substring(wildcardIndex + 1)
+
+                                            // Create an entry string array.
+                                            val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist.
+                                            domainFinalBlacklist.add(domainDoubleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " domain final blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                            //        originalBlocklistEntry);
+                                        } else {  // Process a domain final blacklist single entry.
+                                            // Create an entry string array.
+                                            val domainEntry = arrayOf(domain, entryBase, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist.
+                                            domainFinalBlacklist.add(domainEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " domain final blacklist added: " + domain + " , " + entryBase + "  -  " + originalBlocklistEntry);
+                                        }
+                                    } else if (entry.contains("\\")) {  // Process a domain regular expression blacklist entry.
+                                        // Create an entry string array.
+                                        val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        domainRegularExpressionBlacklist.add(domainEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " domain regular expression blacklist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                    } else if (entry.contains("*")) {  // There are two or more entries.
+                                        // Get the index of the wildcard.
+                                        val wildcardIndex = entry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val firstEntry = entry.substring(0, wildcardIndex)
+                                        val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                        if (secondEntry.contains("*")) {  // Process a domain blacklist triple entry.
+                                            // Get the index of the wildcard.
+                                            val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                            // Split the entry into components.
+                                            val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                            val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                            // Create an entry string array.
+                                            val domainTripleEntry = arrayOf(domain, firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist.
+                                            domainBlacklist.add(domainTripleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry +
+                                            //        "  -  " + originalBlocklistEntry);
+                                        } else {  // Process a domain blacklist double entry.
+                                            // Create an entry string array.
+                                            val domainDoubleEntry = arrayOf(domain, firstEntry, secondEntry, originalBlocklistEntry)
+
+                                            // Add the entry to the blacklist.
+                                            domainBlacklist.add(domainDoubleEntry)
+
+                                            //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + firstEntry + " , " + secondEntry + "  -  " +
+                                            //        originalBlocklistEntry);
+                                        }
+                                    } else {  // Process a domain blacklist single entry.
+                                        // Create an entry string array.
+                                        val domainEntry = arrayOf(domain, entry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        domainBlacklist.add(domainEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " domain blacklist added: " + domain + " , " + entry + "  -  " + originalBlocklistEntry);
+                                    }
+                                } while (domains.contains("|"))
+                            }
+                        }
+                    } else if (blocklistEntry.contains("~")) {  // Whitelist entries.  Privacy Browser does not differentiate against these filter options, so they are just generally whitelisted.
+                        // Remove the filter options.
+                        blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+
+                        // Strip any trailing `*`.
+                        if (blocklistEntry.endsWith("*")) {
+                            blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1)
+                        }
+
+                        if (blocklistEntry.contains("*")) {  // Process a whitelist double entry.
+                            // Get the index of the wildcard.
+                            val wildcardIndex = blocklistEntry.indexOf("*")
+
+                            // Split the entry into components.
+                            val firstEntry = blocklistEntry.substring(0, wildcardIndex)
+                            val secondEntry = blocklistEntry.substring(wildcardIndex + 1)
+
+                            // Create an entry string array.
+                            val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                            // Add the entry to the whitelist.
+                            mainWhitelist.add(doubleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                        } else {  // Process a whitelist single entry.
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry)
+
+                            // Add the entry to the whitelist.
+                            mainWhitelist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " main whitelist added: " + blocklistEntry + "  -  + " + originalBlocklistEntry);
+                        }
+                    } else if (blocklistEntry.contains("\\")) {  // Process a regular expression blacklist entry.
+                        // Remove the filter options.
+                        blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+
+                        // Create an entry string array.
+                        val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry)
+
+                        // Add the entry to the blacklist.
+                        regularExpressionBlacklist.add(singleEntry)
+
+                        //Log.i("Blocklists", headers.get(1)[0] + " regular expression blacklist added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
+                    } else {  // Blacklist entries.
+                        // Remove the filter options.
+                        if (!blocklistEntry.contains("\$file")) {  // EasyPrivacy contains an entry with `$file` that does not have filter options.
+                            blocklistEntry = blocklistEntry.substring(0, blocklistEntry.indexOf("$"))
+                        }
+
+                        // Strip any trailing `*`.  These are redundant.
+                        if (blocklistEntry.endsWith("*")) {
+                            blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1)
+                        }
+
+                        if (blocklistEntry.startsWith("|")) {  // Initial blacklist entries.
+                            // Strip the initial `|`.
+                            val entry = blocklistEntry.substring(1)
+
+                            if (entry.contains("*")) {  // Process an initial blacklist double entry.
+                                // Get the index of the wildcard.
+                                val wildcardIndex = entry.indexOf("*")
+
+                                // Split the entry into components.
+                                val firstEntry = entry.substring(0, wildcardIndex)
+                                val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                // Create an entry string array.
+                                val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                initialBlacklist.add(doubleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                            } else {  // Process an initial blacklist single entry.
+                                // Create an entry string array.
+                                val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                initialBlacklist.add(singleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                            }
+                        } else if (blocklistEntry.endsWith("|")) {  // Final blacklist entries.
+                            // Ignore entries with `object` filters.  They can block entire websites and don't have any meaning in the context of Privacy Browser.
+                            if (!originalBlocklistEntry.contains("\$object")) {
+                                // Strip the final `|`.
+                                val entry = blocklistEntry.substring(0, blocklistEntry.length - 1)
+
+                                if (entry.contains("*")) {  // There are two or more entries.
+                                    // Get the index of the wildcard.
+                                    val wildcardIndex = entry.indexOf("*")
+
+                                    // Split the entry into components.
+                                    val firstEntry = entry.substring(0, wildcardIndex)
+                                    val secondEntry = entry.substring(wildcardIndex + 1)
+
+                                    if (secondEntry.contains("*")) {  // Process a final blacklist triple entry.
+                                        // Get the index of the wildcard.
+                                        val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                        val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                        // Create an entry string array.
+                                        val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        finalBlacklist.add(tripleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " +
+                                        //        originalBlocklistEntry);
+                                    } else {  // Process a final blacklist double entry.
+                                        // Create an entry string array.
+                                        val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        finalBlacklist.add(doubleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                                    }
+                                } else {  // Process a final blacklist single entry.
+                                    // Create an entry sting array.
+                                    val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                                    // Add the entry to the blacklist.
+                                    finalBlacklist.add(singleEntry)
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                                }
+                            }
+                        } else if (blocklistEntry.contains("*")) {  // There are two or more entries.
+                            // Get the index of the wildcard.
+                            val wildcardIndex = blocklistEntry.indexOf("*")
+
+                            // Split the entry into components.
+                            val firstEntry = blocklistEntry.substring(0, wildcardIndex)
+                            val secondEntry = blocklistEntry.substring(wildcardIndex + 1)
+
+                            if (secondEntry.contains("*")) {  // Process a main blacklist triple entry.
+                                // Get the index of the wildcard.
+                                val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                // Split the entry into components.
+                                val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                // Create an entry string array.
+                                val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                mainBlacklist.add(tripleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " + originalBlocklistEntry);
+                            } else {  // Process a main blacklist double entry.
+                                // Create an entry string array.
+                                val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                mainBlacklist.add(doubleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                            }
+                        } else {  // Process a main blacklist single entry.
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry)
+
+                            // Add the entry to the blacklist.
+                            mainBlacklist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
+                        }
+                    }
+                } else {  // Main blacklist entries
+                    // Strip out any initial `||`.  These will be treated like any other entry.
+                    if (blocklistEntry.startsWith("||")) {
+                        blocklistEntry = blocklistEntry.substring(2)
+                    }
+
+                    // Strip out any initial `*`.
+                    if (blocklistEntry.startsWith("*")) {
+                        blocklistEntry = blocklistEntry.substring(1)
+                    }
+
+                    // Strip out any trailing `*`.
+                    if (blocklistEntry.endsWith("*")) {
+                        blocklistEntry = blocklistEntry.substring(0, blocklistEntry.length - 1)
+                    }
+
+                    if (blocklistEntry.startsWith("|")) {  // Initial blacklist entries.
+                        // Strip the initial `|`.
+                        val entry = blocklistEntry.substring(1)
+
+                        if (entry.contains("*")) {  // Process an initial blacklist double entry.
+                            // Get the index of the wildcard.
+                            val wildcardIndex = entry.indexOf("*")
+
+                            // Split the entry into components.
+                            val firstEntry = entry.substring(0, wildcardIndex)
+                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                            // Create an entry string array.
+                            val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                            // Add the entry to the blacklist.
+                            initialBlacklist.add(doubleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                        } else {  // Process an initial blacklist single entry.
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                            // Add the entry to the blacklist.
+                            initialBlacklist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " initial blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                        }
+                    } else if (blocklistEntry.endsWith("|")) {  // Final blacklist entries.
+                        // Strip the final `|`.
+                        val entry = blocklistEntry.substring(0, blocklistEntry.length - 1)
+
+                        if (entry.contains("*")) {  // There are two or more entries.
+                            // Get the index of the wildcard.
+                            val wildcardIndex = entry.indexOf("*")
+
+                            // Split the entry into components.
+                            val firstEntry = entry.substring(0, wildcardIndex)
+                            val secondEntry = entry.substring(wildcardIndex + 1)
+
+                            if (secondEntry.contains("*")) {  // Process a final blacklist triple entry.
+                                // Get the index of the wildcard.
+                                val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                // Split the entry into components.
+                                val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                // Create an entry string array.
+                                val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                finalBlacklist.add(tripleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " + originalBlocklistEntry);
+                            } else {  // Process a final blacklist double entry.
+                                // Create an entry string array.
+                                val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                finalBlacklist.add(doubleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                            }
+                        } else {  // Process a final blacklist single entry.
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(entry, originalBlocklistEntry)
+
+                            // Add the entry to the blacklist.
+                            finalBlacklist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " final blacklist added: " + entry + "  -  " + originalBlocklistEntry);
+                        }
+                    } else {  // Main blacklist entries.
+                        if (blocklistEntry.contains("*")) {  // There are two or more entries.
+                            // Get the index of the wildcard.
+                            val wildcardIndex = blocklistEntry.indexOf("*")
+
+                            // Split the entry into components.
+                            val firstEntry = blocklistEntry.substring(0, wildcardIndex)
+                            val secondEntry = blocklistEntry.substring(wildcardIndex + 1)
+
+                            if (secondEntry.contains("*")) {  // There are three or more entries.
+                                // Get the index of the wildcard.
+                                val secondWildcardIndex = secondEntry.indexOf("*")
+
+                                // Split the entry into components.
+                                val realSecondEntry = secondEntry.substring(0, secondWildcardIndex)
+                                val thirdEntry = secondEntry.substring(secondWildcardIndex + 1)
+
+                                if (thirdEntry.contains("*")) {  // There are four or more entries.
+                                    // Get the index of the wildcard.
+                                    val thirdWildcardIndex = thirdEntry.indexOf("*")
+
+                                    // Split the entry into components.
+                                    val realThirdEntry = thirdEntry.substring(0, thirdWildcardIndex)
+                                    val fourthEntry = thirdEntry.substring(thirdWildcardIndex + 1)
+
+                                    if (fourthEntry.contains("*")) {  // Process a main blacklist quintuple entry.
+                                        // Get the index of the wildcard.
+                                        val fourthWildcardIndex = fourthEntry.indexOf("*")
+
+                                        // Split the entry into components.
+                                        val realFourthEntry = fourthEntry.substring(0, fourthWildcardIndex)
+                                        val fifthEntry = fourthEntry.substring(fourthWildcardIndex + 1)
+
+                                        // Create an entry string array.
+                                        val quintupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, realFourthEntry, fifthEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        mainBlacklist.add(quintupleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + realFourthEntry + " , " +
+                                        //      fifthEntry + "  -  " + originalBlocklistEntry);
+                                    } else {  // Process a main blacklist quadruple entry.
+                                        // Create an entry string array.
+                                        val quadrupleEntry = arrayOf(firstEntry, realSecondEntry, realThirdEntry, fourthEntry, originalBlocklistEntry)
+
+                                        // Add the entry to the blacklist.
+                                        mainBlacklist.add(quadrupleEntry)
+
+                                        //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + realThirdEntry + " , " + fourthEntry + "  -  " +
+                                        //      originalBlocklistEntry);
+                                    }
+                                } else {  // Process a main blacklist triple entry.
+                                    // Create an entry string array.
+                                    val tripleEntry = arrayOf(firstEntry, realSecondEntry, thirdEntry, originalBlocklistEntry)
+
+                                    // Add the entry to the blacklist.
+                                    mainBlacklist.add(tripleEntry)
+
+                                    //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + realSecondEntry + " , " + thirdEntry + "  -  " + originalBlocklistEntry);
+                                }
+                            } else {  // Process a main blacklist double entry.
+                                // Create an entry string array.
+                                val doubleEntry = arrayOf(firstEntry, secondEntry, originalBlocklistEntry)
+
+                                // Add the entry to the blacklist.
+                                mainBlacklist.add(doubleEntry)
+
+                                //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + firstEntry + " , " + secondEntry + "  -  " + originalBlocklistEntry);
+                            }
+                        } else {  // Process a main blacklist single entry.
+                            // Create an entry string array.
+                            val singleEntry = arrayOf(blocklistEntry, originalBlocklistEntry)
+
+                            // Add the entry to the blacklist.
+                            mainBlacklist.add(singleEntry)
+
+                            //Log.i("Blocklists", headers.get(1)[0] + " main blacklist added: " + blocklistEntry + "  -  " + originalBlocklistEntry);
+                        }
+                    }
+                }
+            }
+            // Close `bufferedReader`.
+            bufferedReader.close()
+        } catch (e: IOException) {
+            // The asset exists, so the `IOException` will never be thrown.
+        }
+
+        // Initialize the combined list.
+        val combinedLists = ArrayList<List<Array<String>>>()
+
+        // Add the headers (0).
+        combinedLists.add(headers) // 0.
+
+        // Add the whitelists (1-8).
+        combinedLists.add(mainWhitelist) // 1.
+        combinedLists.add(finalWhitelist) // 2.
+        combinedLists.add(domainWhitelist) // 3.
+        combinedLists.add(domainInitialWhitelist) // 4.
+        combinedLists.add(domainFinalWhitelist) // 5.
+        combinedLists.add(thirdPartyWhitelist) // 6.
+        combinedLists.add(thirdPartyDomainWhitelist) // 7.
+        combinedLists.add(thirdPartyDomainInitialWhitelist) // 8.
+
+        // Add the blacklists (9-22).
+        combinedLists.add(mainBlacklist) // 9.
+        combinedLists.add(initialBlacklist) // 10.
+        combinedLists.add(finalBlacklist) // 11.
+        combinedLists.add(domainBlacklist) //  12.
+        combinedLists.add(domainInitialBlacklist) // 13.
+        combinedLists.add(domainFinalBlacklist) // 14.
+        combinedLists.add(domainRegularExpressionBlacklist) // 15.
+        combinedLists.add(thirdPartyBlacklist) // 16.
+        combinedLists.add(thirdPartyInitialBlacklist) // 17.
+        combinedLists.add(thirdPartyDomainBlacklist) // 18.
+        combinedLists.add(thirdPartyDomainInitialBlacklist) // 19.
+        combinedLists.add(thirdPartyRegularExpressionBlacklist) // 20.
+        combinedLists.add(thirdPartyDomainRegularExpressionBlacklist) // 21.
+        combinedLists.add(regularExpressionBlacklist) // 22.
+
+        // Return the combined lists.
+        return combinedLists
+    }
+
+    fun checkBlocklist(currentDomain: String?, resourceUrl: String, isThirdPartyRequest: Boolean, blocklist: ArrayList<List<Array<String>>>): Array<String> {
+        // Get the blocklist name.
+        val blocklistName = blocklist[0][1][0]
+
+        // Process the whitelists.
+        // Main whitelist.
+        for (whitelistEntry in blocklist[MAIN_WHITELIST.toInt()]) {
+            when (whitelistEntry.size) {
+                // There is one entry.
+                2 -> if (resourceUrl.contains(whitelistEntry[0])) {
+                    // Return a whitelist match request allowed.
+                    return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, whitelistEntry[0], whitelistEntry[1])
+                }
+
+                // There are two entries.
+                3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
+                    // Return a whitelist match request allowed.
+                    return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2]
+                    )
+                }
+
+                // There are three entries.
+                4 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
+                    // Return a whitelist match request allowed.
+                    return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, MAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3])
+                }
+            }
+        }
+
+        // Final whitelist.
+        for (whitelistEntry in blocklist[FINAL_WHITELIST.toInt()]) {
+            when (whitelistEntry.size) {
+                // There is one entry.
+                2 -> if (resourceUrl.contains(whitelistEntry[0])) {
+                    // Return a whitelist match request allowed.
+                    return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, FINAL_WHITELIST, whitelistEntry[0], whitelistEntry[1])
+                }
+
+                // There are two entries.
+                3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
+                    // Return a whitelist match request allowed.
+                    return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2])
+                }
+            }
+        }
+
+        // Only check the domain lists if the current domain is not null (like `about:blank`).
+        if (currentDomain != null) {
+            // Domain whitelist.
+            for (whitelistEntry in blocklist[DOMAIN_WHITELIST.toInt()]) {
+                when (whitelistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3])
+                    }
+
+                    // There are three entries.
+                    5 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}", whitelistEntry[4])
+                    }
+
+                    // There are four entries.
+                    6 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) &&
+                        resourceUrl.contains(whitelistEntry[4])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_WHITELIST,
+                            "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}\n${whitelistEntry[4]}", whitelistEntry[5])
+                    }
+                }
+            }
+
+            // Domain initial whitelist.
+            for (whitelistEntry in blocklist[DOMAIN_INITIAL_WHITELIST.toInt()]) {
+                when (whitelistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}".trimIndent(), whitelistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3])
+                    }
+
+                    // There are three entries.
+                    5 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.startsWith(whitelistEntry[3])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}",
+                            whitelistEntry[4])
+                    }
+                }
+            }
+
+            // Domain final whitelist.
+            for (whitelistEntry in blocklist[DOMAIN_FINAL_WHITELIST.toInt()]) {
+                when (whitelistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.endsWith(whitelistEntry[1])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.endsWith(whitelistEntry[2])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, DOMAIN_FINAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3])
+                    }
+                }
+            }
+        }
+
+        // Only check the third-party whitelists if this is a third-party request.
+        if (isThirdPartyRequest) {
+            // Third-party whitelist.
+            for (whitelistEntry in blocklist[THIRD_PARTY_WHITELIST.toInt()]) {
+                when (whitelistEntry.size) {
+                    // There is one entry.
+                    2 -> if (resourceUrl.contains(whitelistEntry[0])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, whitelistEntry[0], whitelistEntry[1])
+                    }
+
+                    // There are two entries.
+                    3 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}", whitelistEntry[2])
+                    }
+
+                    // There are three entries.
+                    4 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3])
+                    }
+
+                    // There are four entries.
+                    5 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}",
+                            whitelistEntry[4])
+                    }
+
+                    // There are five entries.
+                    6 -> if (resourceUrl.contains(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2]) && resourceUrl.contains(whitelistEntry[3]) &&
+                        resourceUrl.contains(whitelistEntry[4])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_WHITELIST,
+                            "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}\n${whitelistEntry[3]}\n${whitelistEntry[4]}", whitelistEntry[5])
+                    }
+                }
+            }
+
+            // Third-party domain whitelist.
+            for (whitelistEntry in blocklist[THIRD_PARTY_DOMAIN_WHITELIST.toInt()]) {
+                when (whitelistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n", whitelistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.contains(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3])
+                    }
+                }
+            }
+
+            // Third-party domain initial whitelist.
+            for (whitelistEntry in blocklist[THIRD_PARTY_DOMAIN_INITIAL_WHITELIST.toInt()]) {
+                when (whitelistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n", whitelistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain!!.endsWith(whitelistEntry[0]) && resourceUrl.startsWith(whitelistEntry[1]) && resourceUrl.contains(whitelistEntry[2])) {
+                        // Return a whitelist match request allowed.
+                        return arrayOf(REQUEST_ALLOWED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_WHITELIST, "${whitelistEntry[0]}\n${whitelistEntry[1]}\n${whitelistEntry[2]}", whitelistEntry[3])
+                    }
+                }
+            }
+        }
+
+        // Process the blacklists.
+        // Main blacklist.
+        for (blacklistEntry in blocklist[MAIN_BLACKLIST.toInt()]) {
+            when (blacklistEntry.size) {
+                // There is one entry.
+                2 -> if (resourceUrl.contains(blacklistEntry[0])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, blacklistEntry[0], blacklistEntry[1])
+                }
+
+                // There are two entries.
+                3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                }
+
+                // There are three entries.
+                4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3])
+                }
+
+                // There are four entries.
+                5 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4])
+                }
+
+                // There are five entries.
+                6 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3]) &&
+                    resourceUrl.contains(blacklistEntry[4])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, MAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}\n${blacklistEntry[4]}",
+                        blacklistEntry[5])
+                }
+            }
+        }
+
+        // Initial blacklist.
+        for (blacklistEntry in blocklist[INITIAL_BLACKLIST.toInt()]) {
+            when (blacklistEntry.size) {
+                // There is one entry.
+                2 -> if (resourceUrl.startsWith(blacklistEntry[0])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1])
+                }
+
+                // There are two entries
+                3 -> if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                }
+            }
+        }
+
+        // Final blacklist.
+        for (blacklistEntry in blocklist[FINAL_BLACKLIST.toInt()]) {
+            when (blacklistEntry.size) {
+                // There is one entry.
+                2 -> if (resourceUrl.endsWith(blacklistEntry[0])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1])
+                }
+
+                // There are two entries.
+                3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                }
+
+                // There are three entries.
+                4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3])
+                }
+            }
+        }
+
+        // Only check the domain lists if the current domain is not null (like `about:blank`).
+        if (currentDomain != null) {
+            // Domain blacklist.
+            for (blacklistEntry in blocklist[DOMAIN_BLACKLIST.toInt()]) {
+                when (blacklistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3])
+                    }
+
+                    // There are three entries.
+                    5 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4])
+                    }
+                }
+            }
+
+            // Domain initial blacklist.
+            for (blacklistEntry in blocklist[DOMAIN_INITIAL_BLACKLIST.toInt()]) {
+                // Store the entry in the resource request log.
+                if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                }
+            }
+
+            // Domain final blacklist.
+            for (blacklistEntry in blocklist[DOMAIN_FINAL_BLACKLIST.toInt()]) {
+                when (blacklistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.endsWith(blacklistEntry[1])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.endsWith(blacklistEntry[2])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_FINAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3])
+                    }
+                }
+            }
+
+            // Domain regular expression blacklist.
+            for (blacklistEntry in blocklist[DOMAIN_REGULAR_EXPRESSION_BLACKLIST.toInt()]) {
+                if (currentDomain.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, DOMAIN_REGULAR_EXPRESSION_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                }
+            }
+        }
+
+        // Only check the third-party blacklists if this is a third-party request.
+        if (isThirdPartyRequest) {
+            // Third-party blacklist.
+            for (blacklistEntry in blocklist[THIRD_PARTY_BLACKLIST.toInt()]) {
+                when (blacklistEntry.size) {
+                    // There is one entry.
+                    2 -> if (resourceUrl.contains(blacklistEntry[0])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, blacklistEntry[0], blacklistEntry[1])
+                    }
+
+                    // There are two entries.
+                    3 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(
+                            REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n", blacklistEntry[2])
+                    }
+
+                    // There are three entries.
+                    4 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3])
+                    }
+
+                    // There are four entries.
+                    5 -> if (resourceUrl.contains(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}",
+                            blacklistEntry[4])
+                    }
+                }
+            }
+
+            // Third-party initial blacklist.
+            for (blacklistEntry in blocklist[THIRD_PARTY_INITIAL_BLACKLIST.toInt()]) {
+                when (blacklistEntry.size) {
+                    // There is one entry.
+                    2 -> if (resourceUrl.startsWith(blacklistEntry[0])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_INITIAL_BLACKLIST, blacklistEntry[0], blacklistEntry[1])
+                    }
+
+                    // There are two entries.
+                    3 -> if (resourceUrl.startsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                    }
+                }
+            }
+
+            // Third-party domain blacklist.
+            for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_BLACKLIST.toInt()]) {
+                when (blacklistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.contains(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3])
+                    }
+                }
+            }
+
+            // Third-party domain initial blacklist.
+            for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST.toInt()]) {
+                when (blacklistEntry.size) {
+                    // There is one entry.
+                    3 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n", blacklistEntry[2])
+                    }
+
+                    // There are two entries.
+                    4 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}", blacklistEntry[3])
+                    }
+
+                    // There are three entries.
+                    5 -> if (currentDomain!!.endsWith(blacklistEntry[0]) && resourceUrl.startsWith(blacklistEntry[1]) && resourceUrl.contains(blacklistEntry[2]) && resourceUrl.contains(blacklistEntry[3])) {
+                        // Return a blacklist match request blocked.
+                        return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_INITIAL_BLACKLIST,
+                            "${blacklistEntry[0]}\n${blacklistEntry[1]}\n${blacklistEntry[2]}\n${blacklistEntry[3]}", blacklistEntry[4])
+                    }
+                }
+            }
+
+            // Third-party regular expression blacklist.
+            for (blacklistEntry in blocklist[THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST.toInt()]) {
+                if (Pattern.matches(blacklistEntry[0], resourceUrl)) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1])
+                }
+            }
+
+            // Third-party domain regular expression blacklist.
+            for (blacklistEntry in blocklist[THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST.toInt()]) {
+                if (currentDomain!!.endsWith(blacklistEntry[0]) && Pattern.matches(blacklistEntry[1], resourceUrl)) {
+                    // Return a blacklist match request blocked.
+                    return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, THIRD_PARTY_DOMAIN_REGULAR_EXPRESSION_BLACKLIST, "${blacklistEntry[0]}\n${blacklistEntry[1]}", blacklistEntry[2])
+                }
+            }
+        }
+
+        // Regular expression blacklist.
+        for (blacklistEntry in blocklist[REGULAR_EXPRESSION_BLACKLIST.toInt()]) {
+            if (Pattern.matches(blacklistEntry[0], resourceUrl)) {
+                // Return a blacklist match request blocked.
+                return arrayOf(REQUEST_BLOCKED, resourceUrl, blocklistName, REGULAR_EXPRESSION_BLACKLIST, blacklistEntry[0], blacklistEntry[1])
+            }
+        }
+
+        // Return a no match request default.
+        return arrayOf(REQUEST_DEFAULT)
+    }
+}
\ No newline at end of file
index 1a9ba83b20b11c43e731f5ffb2b12c56726a26e2..5fc5ca69042dffdac697be54aecd7b5a23f42286 100644 (file)
             <string name="api">API</string>
             <string name="security_patch">Sicherheits-Patch:</string>
             <string name="build">Build:</string>
+            <string name="kernel">Kernel:</string>
             <string name="webview_provider">WebView-Anbieter:</string>
             <string name="webview_version">WebView-Version:</string>
             <string name="orbot">Orbot:</string>
index 0297ce50b86b0bf8cbbebe78fba6606e216c211e..5044c8bb8ee65f3330e49fd01ab01ba3eef5901d 100644 (file)
             <string name="api">API</string>
             <string name="security_patch">Parche de seguridad:</string>
             <string name="build">Versión de compilación:</string>
+            <string name="kernel">Kernel:</string>
             <string name="webview_provider">Proveedor de WebView:</string>
             <string name="webview_version">Versión de WebView:</string>
             <string name="orbot">Orbot:</string>
index 2d0853642cb6f0656a4af8206e1b591364e775b1..362c5e1d52e301128337cddb17a56b70b73ceaae 100644 (file)
             <string name="api">API</string>
             <string name="security_patch">MAJ de sécurité :</string>
             <string name="build">Version :</string>
+            <string name="kernel">Noyau:</string>
             <string name="webview_provider">Fournisseur WebView :</string>
             <string name="webview_version">Version WebView :</string>
             <string name="orbot">Orbot :</string>