diff --git a/.gitignore b/.gitignore
index 28dd025..611df49 100644
--- a/.gitignore
+++ b/.gitignore
@@ -50,3 +50,7 @@ out
 *.swp
 
 .vscode
+
+# These files are either fetched at build time, or generated from the build
+etld/data/public_suffix_list.h
+etld/data/public_suffix_list.dat
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 8950ac6..b4da9d4 100644
--- a/Makefile
+++ b/Makefile
@@ -6,6 +6,7 @@
 
 build:
 	curl -s https://publicsuffix.org/list/public_suffix_list.dat -o etld/data/public_suffix_list.dat
+	./etld/data/build.js
 	./node_modules/.bin/node-gyp configure && ./node_modules/.bin/node-gyp build
 
 test:
@@ -28,3 +29,5 @@ perf:
 
 clean:
 	rm -Rf build
+	rm etld/data/public_suffix_list.dat
+	rm etld/data/public_suffix_list.h
diff --git a/binding.gyp b/binding.gyp
index 15a5739..ef6f8cf 100644
--- a/binding.gyp
+++ b/binding.gyp
@@ -19,11 +19,10 @@
       "no_fingerprint_domain.h",
       "protocol.cc",
       "protocol.h",
+      "etld/data/public_suffix_list.h",
       "etld/types.h",
       "etld/domain.cc",
       "etld/domain.h",
-      "etld/parser.cc",
-      "etld/parser.h",
       "etld/public_suffix_rule.cc",
       "etld/public_suffix_rule.h",
       "etld/public_suffix_rule_set.cc",
diff --git a/brave/BUILD.gn b/brave/BUILD.gn
index 30855ef..71284e3 100644
--- a/brave/BUILD.gn
+++ b/brave/BUILD.gn
@@ -29,12 +29,11 @@ source_set("ad-block") {
     "../etld/types.h",
     "../etld/domain.cc",
     "../etld/domain.h",
-    "../etld/parser.cc",
-    "../etld/parser.h",
     "../etld/public_suffix_rule.cc",
     "../etld/public_suffix_rule.h",
     "../etld/public_suffix_rule_set.cc",
     "../etld/public_suffix_rule_set.h",
+    "../etld/data/public_suffix_list.h",
     "../etld/matcher.cc",
     "../etld/matcher.h",
     "../etld/shared_matcher.h",
diff --git a/etld/data/build.js b/etld/data/build.js
new file mode 100755
index 0000000..570b8a2
--- /dev/null
+++ b/etld/data/build.js
@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * This code parses the public suffix rule list into a header file of
+ * rules that gets build into the ad-block library.
+ */
+
+const fsLib = require("fs");
+const pathLib = require("path");
+
+const ruleTextPath = pathLib.join(__dirname, "public_suffix_list.dat");
+const ruleText = fsLib.readFileSync(ruleTextPath, "utf8");
+
+const templatePath = pathLib.join(__dirname, "public_suffix_list.h.template");
+const templateText = fsLib.readFileSync(templatePath, "utf8");
+const rules = [];
+
+const toPublicSuffixRuleSerializedString = (isWildcard, isException, labels) => {
+  const constructorArgs = [];
+  constructorArgs.push(isWildcard ? "true" : "false");
+  constructorArgs.push(isException ? "true" : "false");
+
+  const wrappedLabels = labels.map(JSON.stringify);
+  constructorArgs.push("{" + wrappedLabels.join(", ") + "}");
+  return "{" + constructorArgs.join(", ") + "}";
+}
+
+for (const line of ruleText.split("\n")) {
+  let isWildcard = false;
+  let isException = false;
+  let trimmedLine = line.trim();
+  if (trimmedLine.length === 0) {
+    continue;
+  }
+
+  // Check to see if this is a comment line.  If so, process no further.
+  if (trimmedLine.indexOf("//") == 0) {
+    continue;
+  }
+
+  const firstChar = trimmedLine[0];
+  switch (firstChar) {
+    case "!":
+      trimmedLine = trimmedLine.slice(1);
+      isException = true;
+      break;
+
+    case "*":
+      isWildcard = true;
+      break;
+
+    default:
+      break;
+  }
+
+  const lineUntilWhiteSpace = trimmedLine.split(" ")[0];
+  const ruleLabels = lineUntilWhiteSpace.split(".");
+
+  const ruleAsString = toPublicSuffixRuleSerializedString(isWildcard, isException, ruleLabels);
+  rules.push(ruleAsString);
+}
+
+const serializedString = rules.join(",\n");
+const replaceArg = "{" + serializedString + "}";
+const finalCodeText = templateText.replace("{contents}", replaceArg);
+
+const generatedFilePath = pathLib.join(__dirname, "public_suffix_list.h");
+fsLib.writeFileSync(generatedFilePath, finalCodeText, "utf8");
diff --git a/etld/data/.keep b/etld/data/public_suffix_list.cc
similarity index 100%
rename from etld/data/.keep
rename to etld/data/public_suffix_list.cc
diff --git a/etld/data/public_suffix_list.h.template b/etld/data/public_suffix_list.h.template
new file mode 100644
index 0000000..f0926a1
--- /dev/null
+++ b/etld/data/public_suffix_list.h.template
@@ -0,0 +1,16 @@
+/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
+ * license. This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef ETLD_DATA_PUBLIC_SUFFIX_LIST_H_
+#define ETLD_DATA_PUBLIC_SUFFIX_LIST_H_
+
+#include <vector>
+#include "etld/public_suffix_rule.h"
+
+using brave_etld::PublicSuffixRuleSerialized;
+
+const std::vector<PublicSuffixRuleSerialized> SHARED_RULES = {contents};
+
+#endif  //  ETLD_DATA_PUBLIC_SUFFIX_LIST_H_
diff --git a/etld/domain.cc b/etld/domain.cc
index d7ca6a9..d6db2e9 100644
--- a/etld/domain.cc
+++ b/etld/domain.cc
@@ -7,8 +7,7 @@
 #include <sstream>
 #include "etld/domain.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 Domain::Domain(const std::string &string) {
   std::size_t current, previous = 0;
@@ -47,5 +46,4 @@ std::string Domain::ToString() const {
   return as_string.str();
 }
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
diff --git a/etld/domain.h b/etld/domain.h
index 958c342..2ad576d 100644
--- a/etld/domain.h
+++ b/etld/domain.h
@@ -10,8 +10,7 @@
 #include <vector>
 #include "etld/types.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 class Domain {
  public:
@@ -32,7 +31,6 @@ class Domain {
   std::vector<Label> labels_;
 };
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
 
 #endif  // ETLD_DOMAIN_H_
diff --git a/etld/matcher.cc b/etld/matcher.cc
index 2a3e315..460c509 100644
--- a/etld/matcher.cc
+++ b/etld/matcher.cc
@@ -6,23 +6,20 @@
 #include <fstream>
 
 #include "etld/types.h"
-#include "etld/parser.h"
+#include "etld/public_suffix_rule.h"
 #include "etld/matcher.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
-Matcher::Matcher(std::ifstream &rule_file) {
-  PublicSuffixParseResult rules = parse_rule_file(rule_file);
+Matcher::Matcher(const std::vector<PublicSuffixRule> &rules) {
   ConsumeRules(rules);
 }
 
-Matcher::Matcher(const std::string &rule_text) {
-  PublicSuffixParseResult rules = parse_rule_text(rule_text);
-  ConsumeRules(rules);
-}
-
-Matcher::Matcher(const PublicSuffixParseResult &rules) {
+Matcher::Matcher(const std::vector<PublicSuffixRuleSerialized> &serialized_rules) {
+  std::vector<PublicSuffixRule> rules;
+  for (auto &elm : serialized_rules) {
+    rules.push_back(PublicSuffixRule(elm));
+  }
   ConsumeRules(rules);
 }
 
@@ -39,7 +36,7 @@ DomainInfo Matcher::Match(const Domain &domain) const {
     return BuildDomainInfo(rule_match.rule, domain);
   }
 
-  return BuildDomainInfo(PublicSuffixRule("*"), domain);
+  return BuildDomainInfo(PublicSuffixRule({"*"}), domain);
 }
 
 DomainInfo Matcher::BuildDomainInfo(const PublicSuffixRule &rule,
@@ -47,8 +44,8 @@ DomainInfo Matcher::BuildDomainInfo(const PublicSuffixRule &rule,
   return rule.Apply(domain);
 }
 
-void Matcher::ConsumeRules(const PublicSuffixParseResult &rules) {
-  for (auto &elm : rules.Rules()) {
+void Matcher::ConsumeRules(const std::vector<PublicSuffixRule> &rules) {
+  for (auto &elm : rules) {
     if (elm.IsException()) {
       exception_rules_.AddRule(elm);
     } else {
@@ -57,5 +54,4 @@ void Matcher::ConsumeRules(const PublicSuffixParseResult &rules) {
   }
 }
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
diff --git a/etld/matcher.h b/etld/matcher.h
index 8abcc6a..414f9be 100644
--- a/etld/matcher.h
+++ b/etld/matcher.h
@@ -8,37 +8,30 @@
 
 #include <string>
 #include <fstream>
+#include <vector>
 #include "etld/domain.h"
 #include "etld/types.h"
-#include "etld/parser.h"
 #include "etld/public_suffix_rule.h"
 #include "etld/public_suffix_rule_set.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 class Matcher {
  public:
-  static Matcher FromFilePath(const std::string &file_path) {
-    std::ifstream rule_file;
-    rule_file.open(file_path, std::ifstream::in);
-    return Matcher(rule_file);
-  }
-  explicit Matcher(std::ifstream &rule_file);
-  explicit Matcher(const std::string &rule_text);
-  explicit Matcher(const PublicSuffixParseResult &rules);
+  explicit Matcher(const std::vector<PublicSuffixRule> &rules);
+  explicit Matcher(
+    const std::vector<PublicSuffixRuleSerialized> &serialized_rules);
 
   DomainInfo Match(const Domain &domain) const;
 
  private:
   DomainInfo BuildDomainInfo(const PublicSuffixRule &rule,
     const Domain &domain) const;
-  void ConsumeRules(const PublicSuffixParseResult &rules);
+  void ConsumeRules(const std::vector<PublicSuffixRule> &rules);
   PublicSuffixRuleSet exception_rules_;
   PublicSuffixRuleSet rules_;
 };
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
 
 #endif  // ETLD_MATCHER_H_
diff --git a/etld/parser.cc b/etld/parser.cc
deleted file mode 100644
index 6203bc0..0000000
--- a/etld/parser.cc
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
- * license. This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#include <string>
-#include <sstream>
-#include <fstream>
-#include <vector>
-#include "etld/parser.h"
-#include "etld/public_suffix_rule.h"
-#include "etld/types.h"
-
-namespace Brave {
-namespace eTLD {
-
-void PublicSuffixParseResult::AddParseResult(
-    const PublicSuffixTextLineParseResult &result) {
-  switch (result.type) {
-    case PublicSuffixTextLineTypeRule:
-      rules_.push_back(result.rule);
-      break;
-
-    case PublicSuffixTextLineTypeWhitespace:
-      num_whitespace_lines_ += 1;
-      break;
-
-    case PublicSuffixTextLineTypeComment:
-      num_comment_lines_ += 1;
-      break;
-
-    case PublicSuffixTextLineTypeInvalidRule:
-      num_invalid_rules_ += 1;
-      break;
-
-    case PublicSuffixTextLineTypeNone:
-      break;
-  }
-}
-
-PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file) {
-  std::vector<PublicSuffixRule> rules;
-  std::string line;
-  PublicSuffixParseResult results;
-  PublicSuffixTextLineParseResult line_result;
-  while (std::getline(rule_file, line)) {
-    line_result = parse_rule_line(line);
-    results.AddParseResult(line_result);
-  }
-
-  return results;
-}
-
-PublicSuffixParseResult parse_rule_text(const std::string &text) {
-  std::istringstream stream(text);
-  std::string line;
-  PublicSuffixParseResult results;
-  PublicSuffixTextLineParseResult line_result;
-  while (std::getline(stream, line)) {
-    line_result = parse_rule_line(line);
-    results.AddParseResult(line_result);
-  }
-
-  return results;
-}
-
-PublicSuffixTextLineParseResult parse_rule_line(const std::string &line) {
-  PublicSuffixTextLineParseResult result;
-
-  // Check to see if this is a comment line.  If so, process no further.
-  if (line.find("//") == 0) {
-    result.type = PublicSuffixTextLineTypeComment;
-    return result;
-  }
-
-  std::size_t first_non_white_space_char = line.find_first_not_of(" ");
-  // Next, check to see if the line is only whitespace.
-  if (first_non_white_space_char == std::string::npos) {
-    result.type = PublicSuffixTextLineTypeWhitespace;
-    return result;
-  }
-
-  try {
-    result.rule = PublicSuffixRule(line);
-    result.type = PublicSuffixTextLineTypeRule;
-  } catch (PublicSuffixRuleInputException error) {
-    result.type = PublicSuffixTextLineTypeInvalidRule;
-  }
-
-  return result;
-}
-
-}  // namespace eTLD
-}  // namespace Brave
diff --git a/etld/parser.h b/etld/parser.h
deleted file mode 100644
index 8bba22b..0000000
--- a/etld/parser.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/* Copyright (c) 2019 The Brave Software Team. Distributed under the MPL2
- * license. This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef ETLD_PARSER_H_
-#define ETLD_PARSER_H_
-
-#include <string>
-#include <fstream>
-#include <vector>
-#include "etld/public_suffix_rule.h"
-#include "etld/types.h"
-
-namespace Brave {
-namespace eTLD {
-
-enum PublicSuffixTextLineType {
-  PublicSuffixTextLineTypeNone = 0,
-  PublicSuffixTextLineTypeWhitespace,
-  PublicSuffixTextLineTypeComment,
-  PublicSuffixTextLineTypeInvalidRule,
-  PublicSuffixTextLineTypeRule,
-};
-
-struct PublicSuffixTextLineParseResult {
-  PublicSuffixTextLineParseResult() {
-    type = PublicSuffixTextLineTypeNone;
-  }
-  PublicSuffixTextLineType type;
-  PublicSuffixRule rule;
-};
-
-class PublicSuffixParseResult {
- public:
-  PublicSuffixParseResult() {}
-  void AddParseResult(const PublicSuffixTextLineParseResult &result);
-
-  int NumWhitespaceLines() const {
-    return num_whitespace_lines_;
-  }
-
-  int NumCommentLines() const {
-    return num_comment_lines_;
-  }
-
-  int NumInvalidRules() const {
-    return num_invalid_rules_;
-  }
-
-  std::vector<PublicSuffixRule> Rules() const {
-    return rules_;
-  }
-
- private:
-  int num_whitespace_lines_ = 0;
-  int num_comment_lines_ = 0;
-  int num_invalid_rules_ = 0;
-  std::vector<PublicSuffixRule> rules_;
-};
-
-// This attempts to implement the algorithm described here:
-//   https://www.publicsuffix.org/list/
-PublicSuffixParseResult parse_rule_file(std::ifstream &rule_file);
-PublicSuffixParseResult parse_rule_text(const std::string &rule_text);
-PublicSuffixTextLineParseResult parse_rule_line(const std::string &line);
-
-}  // namespace eTLD
-}  // namespace Brave
-
-#endif  // ETLD_PARSER_H_
diff --git a/etld/public_suffix_rule.cc b/etld/public_suffix_rule.cc
index 9529215..185ea96 100644
--- a/etld/public_suffix_rule.cc
+++ b/etld/public_suffix_rule.cc
@@ -8,72 +8,13 @@
 #include "etld/domain.h"
 #include "etld/public_suffix_rule.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
-// Cargo-cult-ed from https://codereview.stackexchange.com/questions/40124/trim-white-space-from-string
-std::string trim_to_whitespace(std::string const& str) {
-  if (str.empty()) {
-    return str;
-  }
-
-  std::size_t first_scan = str.find_first_of(' ');
-  if (first_scan == std::string::npos) {
-    return str;
-  }
-
-  return str.substr(0, first_scan);
-}
-
-PublicSuffixRule::PublicSuffixRule(const std::string &rule_text) {
-  std::string trimmed_rule_text(trim_to_whitespace(rule_text));
-  if (trimmed_rule_text.length() == 0) {
-    throw PublicSuffixRuleInputException(
-      "Cannot create PublicSuffixRule from an empty string");
-  }
-
-  std::size_t current = 0;
-  switch (trimmed_rule_text[0]) {
-    case '*':
-      is_wildcard_ = true;
-      break;
-
-    case '!':
-      is_exception_ = true;
-      current += 1;
-      break;
-
-    case '/':
-      throw PublicSuffixRuleInputException(
-        "Rules cannot start with '/': " + rule_text);
-      break;
-
-    default:
-      break;
-  }
-
-  std::size_t previous = current;
-  current = trimmed_rule_text.find(".", current);
-  Label current_label;
-  while (current != std::string::npos) {
-    current_label = trimmed_rule_text.substr(previous, current - previous);
-    if (current_label.length() == 0) {
-      throw PublicSuffixRuleInputException(
-        "Rules cannot contain adjectent delimitors: " + rule_text);
-    }
-    labels_.push_back(current_label);
-    previous = current + 1;
-    current = trimmed_rule_text.find(".", previous);
-  }
-
-  // If don't include any trailing whitespace, if there is any.
-  current_label = trimmed_rule_text.substr(previous, current - previous);
-  if (current_label == "") {
-    throw PublicSuffixRuleInputException(
-      "Rules cannot end with a delimiter: " + rule_text);
-  }
-
-  labels_.push_back(current_label);
+PublicSuffixRule::PublicSuffixRule(
+    const PublicSuffixRuleSerialized &serialized_rule) {
+  is_wildcard_ = serialized_rule.is_wildcard;
+  is_exception_ = serialized_rule.is_exception;
+  labels_ = serialized_rule.labels;
 }
 
 bool PublicSuffixRule::Equals(const PublicSuffixRule &rule) const {
@@ -189,5 +130,4 @@ std::string PublicSuffixRule::ToString() const {
   return as_string.str();
 }
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
diff --git a/etld/public_suffix_rule.h b/etld/public_suffix_rule.h
index 610362b..adbd18c 100644
--- a/etld/public_suffix_rule.h
+++ b/etld/public_suffix_rule.h
@@ -9,33 +9,38 @@
 #include <string>
 #include <vector>
 #include <exception>
-#include "./domain.h"
-#include "./types.h"
+#include "etld/domain.h"
+#include "etld/types.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
-class PublicSuffixRuleInputException : public std::exception {
- public:
-  explicit PublicSuffixRuleInputException(const char * message) :
-    msg_(message) {}
-  explicit PublicSuffixRuleInputException(const std::string &message) :
-    msg_(message) {}
-  virtual const char* what() const throw() {
-    return msg_.c_str();
-  }
-  virtual ~PublicSuffixRuleInputException() throw() {}
+struct PublicSuffixRuleSerialized {
+  explicit PublicSuffixRuleSerialized(const std::vector<Label> &labels) :
+      is_wildcard(false),
+      is_exception(false),
+      labels(labels) {}
 
- protected:
-  std::string msg_;
+  PublicSuffixRuleSerialized(
+    bool is_wildcard,
+    bool is_exception,
+    const std::vector<Label> &labels) :
+      is_wildcard(is_wildcard),
+      is_exception(is_exception),
+      labels(labels) {}
+
+  bool is_wildcard;
+  bool is_exception;
+  const std::vector<Label> &labels;
 };
 
 class PublicSuffixRule {
  public:
   PublicSuffixRule() {}
-  explicit PublicSuffixRule(const std::string &rule_text);
-  explicit PublicSuffixRule(std::vector<Label> labels, bool is_exception,
-      bool is_wildcard) :
+  explicit PublicSuffixRule(const PublicSuffixRuleSerialized &serialized_rule);
+  explicit PublicSuffixRule(
+      std::vector<Label> labels,
+      bool is_exception = false,
+      bool is_wildcard = false) :
     labels_(labels),
     is_exception_(is_exception),
     is_wildcard_(is_wildcard) {}
@@ -65,7 +70,6 @@ class PublicSuffixRule {
   bool is_wildcard_ = false;
 };
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
 
 #endif  // ETLD_PUBLIC_SUFFIX_RULE_H_
diff --git a/etld/public_suffix_rule_set.cc b/etld/public_suffix_rule_set.cc
index 75f8f62..5263643 100644
--- a/etld/public_suffix_rule_set.cc
+++ b/etld/public_suffix_rule_set.cc
@@ -9,8 +9,7 @@
 #include "etld/public_suffix_rule_set.h"
 #include "etld/types.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 PublicSuffixRuleSetMatchResult PublicSuffixRuleSet::Match(
     const Domain &domain) const {
@@ -44,5 +43,4 @@ void PublicSuffixRuleSet::AddRule(const PublicSuffixRule &rule) {
   rules_.push_back(rule);
 }
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
diff --git a/etld/public_suffix_rule_set.h b/etld/public_suffix_rule_set.h
index 7b4ae54..764ad0d 100644
--- a/etld/public_suffix_rule_set.h
+++ b/etld/public_suffix_rule_set.h
@@ -11,8 +11,7 @@
 #include "etld/domain.h"
 #include "etld/public_suffix_rule.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 struct PublicSuffixRuleSetMatchResult {
   bool found_match;
@@ -29,7 +28,6 @@ class PublicSuffixRuleSet {
   std::vector<PublicSuffixRule> rules_;
 };
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
 
 #endif  // ETLD_PUBLIC_SUFFIX_RULE_SET_H_
diff --git a/etld/shared_matcher.h b/etld/shared_matcher.h
index 2919117..c7a4147 100644
--- a/etld/shared_matcher.h
+++ b/etld/shared_matcher.h
@@ -6,11 +6,11 @@
 #ifndef ETLD_SHARED_MATCHER_H_
 #define ETLD_SHARED_MATCHER_H_
 
-#include "./matcher.h"
-#include "./types.h"
+#include "etld/matcher.h"
+#include "etld/types.h"
+#include "etld/data/public_suffix_list.h"
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 class SharedETLDMatcher {
  public:
@@ -27,11 +27,9 @@ class SharedETLDMatcher {
 
  private:
   SharedETLDMatcher() {}
-  Brave::eTLD::Matcher matcher_ = Matcher::FromFilePath(
-    "./etld/data/public_suffix_list.dat");
+  Matcher matcher_ = Matcher(SHARED_RULES);
 };
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
 
 #endif  // ETLD_SHARED_MATCHER_H_
diff --git a/etld/types.h b/etld/types.h
index eaafa1e..65e2f7a 100644
--- a/etld/types.h
+++ b/etld/types.h
@@ -8,8 +8,7 @@
 
 #include <string>
 
-namespace Brave {
-namespace eTLD {
+namespace brave_etld {
 
 struct DomainInfo {
   std::string tld;
@@ -19,7 +18,6 @@ struct DomainInfo {
 
 typedef std::string Label;
 
-}  // namespace eTLD
-}  // namespace Brave
+}  // namespace brave_etld
 
 #endif  // ETLD_TYPES_H_
diff --git a/filter.cc b/filter.cc
index 466faf8..1baa5a4 100644
--- a/filter.cc
+++ b/filter.cc
@@ -9,7 +9,7 @@
 #include <iostream>
 #include <set>
 #include <string>
-#include "./etld/shared_matcher.h"
+#include "etld/shared_matcher.h"
 
 #ifdef ENABLE_REGEX
 #include <regex> // NOLINT
@@ -24,10 +24,10 @@
 
 static HashFn h(19);
 
-using Brave::eTLD::Domain;
-using Brave::eTLD::SharedETLDMatcher;
-using Brave::eTLD::Matcher;
-using Brave::eTLD::DomainInfo;
+using brave_etld::Domain;
+using brave_etld::SharedETLDMatcher;
+using brave_etld::Matcher;
+using brave_etld::DomainInfo;
 
 const char * getUrlHost(const char *input, int *len);
 
diff --git a/muon/BUILD.gn b/muon/BUILD.gn
index 7b130e2..7985079 100644
--- a/muon/BUILD.gn
+++ b/muon/BUILD.gn
@@ -47,12 +47,11 @@ source_set("ad_block") {
     "../etld/types.h",
     "../etld/domain.cc",
     "../etld/domain.h",
-    "../etld/parser.cc",
-    "../etld/parser.h",
     "../etld/public_suffix_rule.cc",
     "../etld/public_suffix_rule.h",
     "../etld/public_suffix_rule_set.cc",
     "../etld/public_suffix_rule_set.h",
+    "../etld/data/public_suffix_list.h",
     "../etld/matcher.cc",
     "../etld/matcher.h",
     "../etld/shared_matcher.h",
diff --git a/test/binding.gyp b/test/binding.gyp
index f6412a2..20a8751 100644
--- a/test/binding.gyp
+++ b/test/binding.gyp
@@ -15,8 +15,6 @@
       "../etld/types.h",
       "../etld/domain.cc",
       "../etld/domain.h",
-      "../etld/parser.cc",
-      "../etld/parser.h",
       "../etld/public_suffix_rule.cc",
       "../etld/public_suffix_rule.h",
       "../etld/public_suffix_rule_set.cc",
@@ -24,6 +22,7 @@
       "../etld/matcher.cc",
       "../etld/matcher.h",
       "../etld/shared_matcher.h",
+      "../etld/data/public_suffix_list.h",
       "../protocol.cc",
       "../protocol.h",
       "../ad_block_client.cc",
diff --git a/test/data/public_suffix_list_short.txt b/test/data/public_suffix_list_short.txt
deleted file mode 100644
index a9069ba..0000000
--- a/test/data/public_suffix_list_short.txt
+++ /dev/null
@@ -1,52 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at https://mozilla.org/MPL/2.0/.
-
-// Please pull this list from, and only from https://publicsuffix.org/list/public_suffix_list.dat,
-// rather than any other VCS sites. Pulling from any other URL is not guaranteed to be supported.
-
-// Instructions on pulling and using this list can be found at https://publicsuffix.org/list/.
-
-// ===BEGIN ICANN DOMAINS===
-
-// ac : https://en.wikipedia.org/wiki/.ac
-ac
-com.ac
-edu.ac
-gov.ac
-net.ac
-mil.ac
-org.ac
-
-// aero : see https://www.information.aero/index.php?id=66
-aero
-accident-investigation.aero
-accident-prevention.aero
-aerobatic.aero
-aeroclub.aero
-aerodrome.aero
-agents.aero
-aircraft.aero
-airline.aero
-airport.aero
-air-surveillance.aero
-airtraffic.aero
-air-traffic-control.aero
-
-// ck : https://en.wikipedia.org/wiki/.ck
-*.ck
-!www.ck
-
-// cl : https://en.wikipedia.org/wiki/.cl
-cl
-gov.cl
-gob.cl
-co.cl
-mil.cl
-
-// cm : https://en.wikipedia.org/wiki/.cm plus bug 981927
-cm
-co.cm
-com.cm
-gov.cm
-net.cm
\ No newline at end of file
diff --git a/test/etld_test.cc b/test/etld_test.cc
index 91ad62f..f03af17 100644
--- a/test/etld_test.cc
+++ b/test/etld_test.cc
@@ -13,7 +13,6 @@
 #include "./etld/types.h"
 #include "./etld/matcher.h"
 #include "./etld/shared_matcher.h"
-#include "./etld/parser.h"
 #include "./etld/domain.h"
 #include "./etld/public_suffix_rule.h"
 #include "./etld/public_suffix_rule_set.h"
@@ -23,173 +22,21 @@ using std::cout;
 using std::endl;
 
 
-using Brave::eTLD::PublicSuffixTextLineType;
-using Brave::eTLD::PublicSuffixTextLineParseResult;
-using Brave::eTLD::PublicSuffixRuleInputException;
-using Brave::eTLD::PublicSuffixRuleSetMatchResult;
-using Brave::eTLD::PublicSuffixRule;
-using Brave::eTLD::PublicSuffixRuleSet;
-using Brave::eTLD::Domain;
-using Brave::eTLD::Matcher;
-using Brave::eTLD::DomainInfo;
-using Brave::eTLD::PublicSuffixParseResult;
-using Brave::eTLD::parse_rule_line;
-using Brave::eTLD::parse_rule_text;
-using Brave::eTLD::parse_rule_file;
+using brave_etld::PublicSuffixTextLineType;
+using brave_etld::PublicSuffixRuleInputException;
+using brave_etld::PublicSuffixRuleSetMatchResult;
+using brave_etld::PublicSuffixRule;
+using brave_etld::PublicSuffixRuleSerialized;
+using brave_etld::PublicSuffixRuleSet;
+using brave_etld::Domain;
+using brave_etld::Matcher;
+using brave_etld::SharedMatcher;
+using brave_etld::DomainInfo;
 
-
-bool testParsePublicSuffixTestLineNoOps(const string &line,
-    PublicSuffixTextLineType expectedType) {
-  PublicSuffixTextLineParseResult result = parse_rule_line(line);
-  if (result.type != expectedType) {
-    cout << "Received unexpected parse result for " << line << endl;
-    return false;
-  }
-
-  return true;
-}
-
-bool testParsePublicSuffixTestLineError(const string &line,
-    const string &expected_error) {
-  try {
-    PublicSuffixRule rule(line);
-  } catch (PublicSuffixRuleInputException error) {
-    string error_string(error.what());
-    size_t error_substr_pos = error_string.find_first_of(expected_error);
-    if (error_substr_pos == string::npos) {
-      cout << "Caught an unexpected error when parsing " << line << "\n"
-           << "Expected '" << expected_error << "'\n"
-           << "Received '" << error.what() << endl;
-      return false;
-    }
-    return true;
-  }
-
-  cout << "Expected to receive an error when attempting to parse invalid rule '"
-       << line
-       << "' but no error was thrown." << endl;
-  return false;
-}
-
-bool testParsePublicSuffixTest(
-    const string &line,
-    std::vector<string> expected_labels,
-    bool expected_exception,
-    bool expected_wildcard) {
-  PublicSuffixRule rule(line);
-  PublicSuffixRule currect_rule(expected_labels, expected_exception,
-    expected_wildcard);
-  return currect_rule.Equals(rule);
-}
-
-bool _verifyParsePublicSuffixTest(
-    PublicSuffixParseResult result,
-    int num_expected_rules,
-    int num_expected_exception_rules,
-    int num_expected_wildcard_rules,
-    int num_expected_whitespace_lines,
-    int num_expected_comment_lines,
-    int num_expected_invalid_lines) {
-  if (num_expected_rules != result.Rules().size()) {
-    cout << "Incorrect num of rules parsed, expected '"
-         << num_expected_rules << "' "
-         << "but found '" << result.Rules().size() << "'" << endl;
-    return false;
-  }
-
-  int num_found_exception_rules = 0;
-  int num_found_wildcard_rules = 0;
-  for (auto &elm : result.Rules()) {
-    if (elm.IsException()) {
-      num_found_exception_rules += 1;
-    }
-    if (elm.IsWildcard()) {
-      num_found_wildcard_rules += 1;
-    }
-  }
-
-  if (num_found_exception_rules != num_expected_exception_rules) {
-    cout << "Found unexpected number of exception rules, expected '"
-         << num_expected_exception_rules << "' "
-         << "but found '" << num_found_exception_rules << "'" << endl;
-    return false;
-  }
-
-  if (num_found_exception_rules != num_expected_exception_rules) {
-    cout << "Found unexpected number of exception rules, expected '"
-         << num_expected_exception_rules << "' "
-         << "but found '" << num_found_exception_rules << "'" << endl;
-    return false;
-  }
-
-  if (result.NumWhitespaceLines() != num_expected_whitespace_lines) {
-    cout << "Found unexpected number of whitespace lines, expected '"
-         << num_expected_whitespace_lines << "' "
-         << "but found '" << result.NumWhitespaceLines() << "'" << endl;
-    return false;
-  }
-
-  if (result.NumInvalidRules() != num_expected_invalid_lines) {
-    cout << "Found unexpected number of invalid rules, expected '"
-         << num_expected_invalid_lines << "' "
-         << "but found '" << result.NumInvalidRules() << "'" << endl;
-    return false;
-  }
-
-  if (result.NumCommentLines() != num_expected_comment_lines) {
-    cout << "Found unexpected number of comment lines, expected '"
-         << num_expected_comment_lines << "' "
-         << "but found '" << result.NumCommentLines() << "'" << endl;
-    return false;
-  }
-
-  return true;
-}
-
-bool testParsePublicSuffixTextTest(
-    const string &text,
-    int num_expected_rules,
-    int num_expected_exception_rules,
-    int num_expected_wildcard_rules,
-    int num_expected_whitespace_lines,
-    int num_expected_comment_lines,
-    int num_expected_invalid_lines) {
-  PublicSuffixParseResult result = parse_rule_text(text);
-  return _verifyParsePublicSuffixTest(
-    result,
-    num_expected_rules,
-    num_expected_exception_rules,
-    num_expected_wildcard_rules,
-    num_expected_whitespace_lines,
-    num_expected_comment_lines,
-    num_expected_invalid_lines);
-}
-
-bool testParsePublicSuffixFileTest(
-    const string &file_path,
-    int num_expected_rules,
-    int num_expected_exception_rules,
-    int num_expected_wildcard_rules,
-    int num_expected_whitespace_lines,
-    int num_expected_comment_lines,
-    int num_expected_invalid_lines) {
-  std::ifstream rule_file;
-  rule_file.open(file_path, std::ifstream::in);
-  PublicSuffixParseResult result = parse_rule_file(rule_file);
-  return _verifyParsePublicSuffixTest(
-    result,
-    num_expected_rules,
-    num_expected_exception_rules,
-    num_expected_wildcard_rules,
-    num_expected_whitespace_lines,
-    num_expected_comment_lines,
-    num_expected_invalid_lines);
-}
-
-bool testMatchingDomainRules(const string &rule_str, const string &domain_str,
+bool testMatchingDomainRules(const PublicSuffixRuleSerialized &serialized_rule, const string &domain_str,
     bool should_match) {
   Domain domain(domain_str);
-  PublicSuffixRule rule(rule_str);
+  PublicSuffixRule rule(serialized_rule);
 
   bool does_match = rule.Matches(domain);
   if (should_match != does_match) {
@@ -205,7 +52,7 @@ bool testMatchingDomainRules(const string &rule_str, const string &domain_str,
   return true;
 }
 
-bool testPublicSuffixRuleSetMatch(const std::vector<string> &rules,
+bool testPublicSuffixRuleSetMatch(const std::vector<PublicSuffixRuleSerialized> &rules,
     const string &domain_str, const string &expected_match) {
   PublicSuffixRuleSet rule_set;
   PublicSuffixRule rule;
@@ -227,9 +74,9 @@ bool testPublicSuffixRuleSetMatch(const std::vector<string> &rules,
   return true;
 }
 
-bool testPublicSuffixRuleTextApply(const string &rule_str,
+bool testPublicSuffixRuleTextApply(const PublicSuffixRuleSerialized &serialized_rule,
     const string &domain_str, const DomainInfo &expected) {
-  PublicSuffixRule rule(rule_str);
+  PublicSuffixRule rule(serialized_rule);
   Domain domain(domain_str);
   DomainInfo extracted = rule.Apply(domain);
   if (extracted.tld != expected.tld) {
@@ -261,166 +108,76 @@ bool testPublicSuffixRuleTextApply(const string &rule_str,
   return true;
 }
 
-bool testPublicSuffixRuleFileApply(const string &file_path,
-    const string &domain_str, const DomainInfo &expected) {
-  std::ifstream rule_file;
-  rule_file.open(file_path, std::ifstream::in);
-  Matcher matcher(rule_file);
+bool testPublicSuffixListApply(const string &domain_str, const DomainInfo &expected) {
+  Matcher matcher = SharedMatcher.GetInstance.GetMatcher();
   DomainInfo extracted = matcher.Match(Domain(domain_str));
 
   if (extracted.tld != expected.tld) {
-    cout << "Expected tld of '" << expected.tld
-         << "' when applying file '"
-         << file_path << "' to domain '" << domain_str
-         << "', but received tld '" << extracted.tld << "'" << endl;
+    cout << "Expected tld of '" << expected.tld << " for domain '"
+         << domain_str << "', but received tld '"
+         << extracted.tld << "'" << endl;
     return false;
   }
 
   if (extracted.domain != expected.domain) {
-    cout << "Expected domain of '" << expected.domain
-         << "' when applying file '"
-         << file_path << "' to domain '" << domain_str
-         << "', but received domain '" << extracted.domain << "'" << endl;
+    cout << "Expected domain of '" << expected.domain << " for domain '"
+         << domain_str << "', but received domain '"
+         << extracted.domain << "'" << endl;
     return false;
   }
 
   if (extracted.subdomain != expected.subdomain) {
-    cout << "Expected subdomain of '" << expected.subdomain
-         << "' when applying file '"
-         << file_path << "' to domain '" << domain_str
-         << "', but received subdomain '" << extracted.subdomain << "'" << endl;
+    cout << "Expected subdomain of '" << expected.subdomain << " for domain '"
+         << domain_str << "', but received subdomain '"
+         << extracted.subdomain << "'" << endl;
     return false;
   }
 
   return true;
 }
 
-TEST(eTLDParseRulesLine, basic) {
-  CHECK(testParsePublicSuffixTestLineNoOps(
-    "// this is an option",
-    Brave::eTLD::PublicSuffixTextLineTypeComment));
-
-  CHECK(testParsePublicSuffixTestLineNoOps(
-    "this.is.a.invalid..rule",
-    Brave::eTLD::PublicSuffixTextLineTypeInvalidRule));
-
-  CHECK(testParsePublicSuffixTestLineNoOps(
-    "",
-    Brave::eTLD::PublicSuffixTextLineTypeWhitespace));
-
-  // Since we read until the first white space, this will be read
-  // as "example.", which is invalid because rules cannot hae empty labels
-  CHECK(testParsePublicSuffixTestLineError(
-    "example. org",
-    "Rules cannot end with a delimiter"));
-  CHECK(testParsePublicSuffixTestLineError(
-    "example..org",
-    "Rules cannot contain adjectent delimitors"));
-  CHECK(testParsePublicSuffixTestLineError(
-    "example.org.",
-    "Rules cannot end with a delimiter"));
-
-  // Examples taken from https://publicsuffix.org/list/
-  CHECK(testParsePublicSuffixTest(
-    "com",
-    {"com"},
-    false,
-    false));
-  CHECK(testParsePublicSuffixTest(
-    "*.jp",
-    {"*", "jp"},
-    false,
-    true));
-  CHECK(testParsePublicSuffixTest(
-    "*.jp",
-    {"*", "jp"},
-    false,
-    true));
-  CHECK(testParsePublicSuffixTest(
-    "*.tokyo.jp",
-    {"*", "tokyo", "jp"},
-    false,
-    true));
-  CHECK(testParsePublicSuffixTest(
-    "!pref.hokkaido.jp",
-    {"pref", "hokkaido", "jp"},
-    true,
-    false));
-}
-
-TEST(eTLDParseRulesText, basic) {
-  // Just retesting the examples from above, to make sure they are parsed
-  // correctly when all in a line.
-  CHECK(testParsePublicSuffixTextTest(
-    "com\n*.jp\n*.jp\n*.tokyo.jp\n!pref.hokkaido.jp",
-    5, 1, 3, 0, 0, 0));
-
-  CHECK(testParsePublicSuffixTextTest(
-    "// ac : https://en.wikipedia.org/wiki/.ac\n"
-    "ac\n"
-    "com.ac\n"
-    "edu.ac\n"
-    "gov.ac\n"
-    "net.ac\n"
-    "mil.ac\n"
-    "org.ac\n",
-    7, 0, 0, 0, 1, 0));
-  CHECK(testParsePublicSuffixTextTest(
-    "// am : https://en.wikipedia.org/wiki/.am\n"
-    "am\n"
-    "\n"
-    "// ao : https://en.wikipedia.org/wiki/.ao \n"
-    "// http://www.dns.ao/REGISTR.DOC \n"
-    "ao\n"
-    "ed.ao\n"
-    "gv.ao\n"
-    "og.ao\n"
-    "co.ao\n"
-    "pb.ao\n"
-    "it.ao\n",
-    8, 0, 0, 1, 3, 0));
-  CHECK(testParsePublicSuffixTextTest(
-    "\n"
-    "*.wild.rule\n"
-    "!exception.rule \n"
-    "// coment line \n"
-    "example.org\n"
-    "...badrule",
-    3, 1, 1, 1, 1, 1));
-}
-
-TEST(eTLDParseRulesFile, basic) {
-  CHECK(testParsePublicSuffixFileTest(
-    "./test/data/public_suffix_list_short.txt",
-    32, 1, 1, 8, 12, 0));
-}
-
 TEST(eTLDMatchTests, basic) {
-  CHECK(testMatchingDomainRules("com", "com", true));
-  CHECK(testMatchingDomainRules("fp.com", "com", false));
-  CHECK(testMatchingDomainRules("com", "fp.com", true));
-  CHECK(testMatchingDomainRules("*.hokkaido.jp", "bar.hokkaido.jp", true));
-  CHECK(testMatchingDomainRules("!pref.hokkaido.jp", "pref.hokkaido.jp", true));
-  CHECK(testMatchingDomainRules("*.tokyo.jp", "tokyo.jp", false));
-  CHECK(testMatchingDomainRules("*.tokyo.jp", "other.tokyo.jp", true));
-  CHECK(testMatchingDomainRules("com", "foo.com", true));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(false, false, {"com"}), "com", true));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(false, false, {"fp", "com"}), "com", false));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(false, false, {"com"}), "fp.com", true));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(true, false, {"*", "hokkaido", "jp"}), "bar.hokkaido.jp", true));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(false, true, {"pref", "hokkaido", "jp"}), "pref.hokkaido.jp", true));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(true, false, {"*", "tokyo", "jp"}), "tokyo.jp", false));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(true, false, {"*", "tokyo", "jp"}), "other.tokyo.jp", true));
+  CHECK(testMatchingDomainRules(PublicSuffixRuleSerialized(false, false, {"com"}), "foo.com", true));
 }
 
 TEST(eTLDPublicSuffixRuleSetMatchTests, basic) {
   CHECK(testPublicSuffixRuleSetMatch(
-    {"com", "*.jp", "*.hokkaido.jp"},
+    {
+      PublicSuffixRuleSerialized(false, false, {"com"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "jp"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "hokkaido", "jp"})
+    },
     "foo.com",
     "com"));
   CHECK(testPublicSuffixRuleSetMatch(
-    {"com", "*.jp", "*.hokkaido.jp"},
+    {
+      PublicSuffixRuleSerialized(false, false, {"com"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "jp"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "hokkaido", "jp"})
+    },
     "hokkaido.jp",
     "*.jp"));
   CHECK(testPublicSuffixRuleSetMatch(
-    {"com", "*.jp", "*.hokkaido.jp"},
+    {
+      PublicSuffixRuleSerialized(false, false, {"com"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "jp"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "hokkaido", "jp"})
+    },
     "pete.hokkaido.jp",
     "*.hokkaido.jp"));
   CHECK(testPublicSuffixRuleSetMatch(
-    {"com", "*.jp", "*.hokkaido.jp"},
+    {
+      PublicSuffixRuleSerialized(false, false, {"com"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "jp"}),
+      PublicSuffixRuleSerialized(true, false, {"*", "hokkaido", "jp"})
+    },
     "horse.shoes",
     ""));
 }
@@ -428,54 +185,52 @@ TEST(eTLDPublicSuffixRuleSetMatchTests, basic) {
 TEST(eTLDPublicSuffixRuleApplyTestTests, basic) {
   DomainInfo test_one_expected_match = {"example.jp", "shoes", "pete"};
   CHECK(testPublicSuffixRuleTextApply(
-    "*.jp", "pete.shoes.example.jp", test_one_expected_match));
+    PublicSuffixRuleSerialized(true, false, {"*", "jp"}),
+    "pete.shoes.example.jp",
+    test_one_expected_match));
 
   DomainInfo test_two_expected_match = {"horse", "the", "we.love"};
   CHECK(testPublicSuffixRuleTextApply(
-      "horse", "we.love.the.horse", test_two_expected_match));
+    PublicSuffixRuleSerialized(false, false, {"horse"}),
+    "we.love.the.horse", test_two_expected_match));
 
   DomainInfo test_three_expected_match = {"tokyo.jp", "metro", "slate"};
   CHECK(testPublicSuffixRuleTextApply(
-      "!metro.tokyo.jp", "slate.metro.tokyo.jp", test_three_expected_match));
+    PublicSuffixRuleSerialized(false, true, {"!metro", "tokyo", "jp"}),
+    "slate.metro.tokyo.jp", test_three_expected_match));
 }
 
 TEST(eTLDPublicSuffixRuleApplyFileTests, basic) {
   DomainInfo file_test_one = {"com", "google", "www"};
-  CHECK(testPublicSuffixRuleFileApply(
-    "./etld/data/public_suffix_list.dat",
+  CHECK(testPublicSuffixListApply(
     "www.google.com",
     file_test_one));
 
   DomainInfo file_test_two = {"co.uk", "google", ""};
-  CHECK(testPublicSuffixRuleFileApply(
-    "./etld/data/public_suffix_list.dat",
+  CHECK(testPublicSuffixListApply(
     "google.co.uk",
     file_test_two));
 
   // Tests taken from https://www.npmjs.com/package/tldts
   DomainInfo file_test_three = {"s3.amazonaws.com", "spark-public", ""};
-  CHECK(testPublicSuffixRuleFileApply(
-    "./etld/data/public_suffix_list.dat",
+  CHECK(testPublicSuffixListApply(
     "spark-public.s3.amazonaws.com",
     file_test_three));
 
   DomainInfo file_test_four = {"org", "writethedocs", "www"};
-  CHECK(testPublicSuffixRuleFileApply(
-    "./etld/data/public_suffix_list.dat",
+  CHECK(testPublicSuffixListApply(
     "www.writethedocs.org",
     file_test_four));
 
   // Tests taken from https://www.npmjs.com/package/tld
   DomainInfo file_test_five = {"bar.sch.uk", "foo", "www"};
-  CHECK(testPublicSuffixRuleFileApply(
-    "./etld/data/public_suffix_list.dat",
+  CHECK(testPublicSuffixListApply(
     "www.foo.bar.sch.uk",
     file_test_five));
 
   // Tests taken from https://www.npmjs.com/package/parse-domain
   DomainInfo file_test_six = {"co.uk", "example", "some.subdomain"};
-  CHECK(testPublicSuffixRuleFileApply(
-    "./etld/data/public_suffix_list.dat",
+  CHECK(testPublicSuffixListApply(
     "some.subdomain.example.co.uk",
     file_test_six));
 
@@ -541,7 +296,6 @@ TEST(eTLDPublicSuffixRuleApplyFileTests, basic) {
   };
   for (auto &elm : file_test_cases) {
     CHECK(testPublicSuffixRuleFileApply(
-      "./etld/data/public_suffix_list.dat",
       elm.input,
       elm.expected));
   }