rpz

file.rs (31042B)

---

 extern crate alloc;
 use crate::dom::{
     Adblock, DomainOnly, FirefoxDomainErr, Hosts, ParsedDomain, RpzDomain, Value, Wildcard,
 };
 use alloc::string::FromUtf8Error;
 use core::{
     borrow::Borrow,
     error::Error,
     fmt::{self, Display, Formatter},
     hash::Hash,
     ops::Deref,
     time::Duration,
 };
 use reqwest::Client;
 use serde::de::{self, Deserialize, Deserializer, Unexpected, Visitor};
 use std::{
     collections::{HashMap, HashSet},
     fs,
     io::{self, ErrorKind},
     path::{Path, PathBuf},
 };
 use superset_map::SupersetSet;
 use tokio::{
     task::{JoinError, JoinSet},
     time::{self, error::Elapsed},
 };
 use url::Url;
 /// Wrapper around an absolute [`PathBuf`] to a directory or file depending on `IS_DIR`.
 ///
 /// Note that `IS_DIR` iff the wrapped `PathBuf` ends with `/`.
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct AbsFilePath<const IS_DIR: bool> {
     /// The file or directory.
     path: PathBuf,
 }
 impl<const IS_DIR: bool> AbsFilePath<IS_DIR> {
     /// Returns `true` iff `val` was appended to `self`.
     #[inline]
     pub fn append(&mut self, val: &str) -> bool {
         let bytes = val.as_bytes();
         if IS_DIR {
             self.path.as_mut_os_string().push(val);
             bytes.last().map_or(true, |byt| {
                 if *byt != b'/' {
                     self.path.as_mut_os_string().push("/");
                 }
                 true
             })
             // When `!IS_DIR`, we have to verify `val` does not end
             // with `/` as well as verify the last component is not
             // `..` which is true iff `val == ".."` or the last 3
             // characters of `val` is `/..`.
         } else if bytes.last().map_or(false, |byt| {
             *byt == b'/'
                 || bytes
                     .get(bytes.len().wrapping_sub(2)..)
                     .map_or(false, |byts| {
                         byts == b".."
                             && bytes
                                 .get(bytes.len().wrapping_sub(3))
                                 .map_or(true, |byt2| *byt2 == b'/')
                     })
         }) {
             false
         } else {
             self.path.as_mut_os_string().push(val);
             true
         }
     }
     /// Returns `self` as a [`Path`] reference.
     #[inline]
     #[must_use]
     pub fn as_path(&self) -> &Path {
         self.path.as_path()
     }
     /// Returns an `AbsFilePath` iff `val` conforms to the following:
     /// * `PathBuf::from(val).is_absolute()`.
     /// * `PathBuf::from(val).as_bytes().last().unwrap() == b'/'` ⇒ `IS_DIR`.
     /// * `PathBuf::from(val).file_name().is_none()` ⇒ `IS_DIR`.
     ///
     /// If `IS_DIR` and `PathBuf::from(val).as_bytes().last().unwrap() != b'/'`, `val`
     /// will have `/` appended to it.
     #[expect(clippy::option_if_let_else, reason = "map will not work")]
     #[inline]
     #[must_use]
     pub fn from_string(val: String) -> Option<Self> {
         match val.as_bytes().last() {
             Some(byt) => {
                 let last = *byt;
                 let mut path = PathBuf::from(val);
                 if path.is_absolute() {
                     if last == b'/' {
                         IS_DIR.then_some(Self { path })
                     } else if IS_DIR {
                         path.as_mut_os_string().push("/");
                         Some(Self { path })
                     } else {
                         path.file_name().is_some().then_some(Self { path })
                     }
                 } else {
                     None
                 }
             }
             None => None,
         }
     }
 }
 impl<const IS_DIR: bool> AsRef<Path> for AbsFilePath<IS_DIR> {
     #[inline]
     fn as_ref(&self) -> &Path {
         self.as_path()
     }
 }
 impl<const IS_DIR: bool> Borrow<Path> for AbsFilePath<IS_DIR> {
     #[inline]
     fn borrow(&self) -> &Path {
         self.as_path()
     }
 }
 impl<const IS_DIR: bool> Deref for AbsFilePath<IS_DIR> {
     type Target = Path;
     #[inline]
     fn deref(&self) -> &Self::Target {
         self.as_path()
     }
 }
 impl<const IS_DIR: bool> From<AbsFilePath<IS_DIR>> for PathBuf {
     #[inline]
     fn from(value: AbsFilePath<IS_DIR>) -> Self {
         value.path
     }
 }
 impl<'de, const IS_DIR: bool> Deserialize<'de> for AbsFilePath<IS_DIR> {
     #[expect(clippy::too_many_lines, reason = "this is fine")]
     #[inline]
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         /// `Visitor` for `AbsFilePath`.
         struct FilePathVisitor<const IS_DIR: bool>;
         impl<'de, const IS_DIR: bool> Visitor<'de> for FilePathVisitor<IS_DIR> {
             type Value = AbsFilePath<IS_DIR>;
             fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
                 formatter.write_str("struct AbsFilePath")
             }
             #[expect(clippy::arithmetic_side_effects, reason = "math has been verified")]
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
                 v.as_bytes().last().map_or_else(
                     || {
                         Err(E::invalid_value(
                             Unexpected::Str(v),
                             &"an absolute file path",
                         ))
                     },
                     |byt| {
                         if *byt == b'/' {
                             if IS_DIR {
                                 let path = PathBuf::with_capacity(v.len()).join(v);
                                 if path.is_absolute() {
                                     Ok(AbsFilePath { path })
                                 } else {
                                     Err(E::invalid_value(
                                         Unexpected::Str(v),
                                         &"an absolute file path to a directory",
                                     ))
                                 }
                             } else {
                                 Err(E::invalid_value(
                                     Unexpected::Str(v),
                                     &"an absolute file path to a file",
                                 ))
                             }
                         } else if IS_DIR {
                             let mut path = PathBuf::with_capacity(v.len() + 1).join(v);
                             path.as_mut_os_string().push("/");
                             if path.is_absolute() {
                                 Ok(AbsFilePath { path })
                             } else {
                                 Err(E::invalid_value(
                                     Unexpected::Str(v),
                                     &"an absolute file path to a directory",
                                 ))
                             }
                         } else {
                             let path = PathBuf::with_capacity(v.len()).join(v);
                             if path.is_absolute() && path.file_name().is_some() {
                                 Ok(AbsFilePath { path })
                             } else {
                                 Err(E::invalid_value(
                                     Unexpected::Str(v),
                                     &"an absolute file path to a file",
                                 ))
                             }
                         }
                     },
                 )
             }
             fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
                 match v.as_bytes().last() {
                     Some(byt) => {
                         if *byt == b'/' {
                             if IS_DIR {
                                 let path = PathBuf::from(v);
                                 if path.is_absolute() {
                                     Ok(AbsFilePath { path })
                                 } else {
                                     Err(E::invalid_value(
                                         Unexpected::Str(path.to_string_lossy().as_ref()),
                                         &"an absolute file path to a directory",
                                     ))
                                 }
                             } else {
                                 Err(E::invalid_value(
                                     Unexpected::Str(v.as_str()),
                                     &"an absolute file path to a file",
                                 ))
                             }
                         } else if IS_DIR {
                             let mut path = PathBuf::from(v);
                             path.as_mut_os_string().push("/");
                             if path.is_absolute() {
                                 Ok(AbsFilePath { path })
                             } else {
                                 Err(E::invalid_value(
                                     Unexpected::Str(path.to_string_lossy().as_ref()),
                                     &"an absolute file path to a directory",
                                 ))
                             }
                         } else {
                             let path = PathBuf::from(v);
                             if path.is_absolute() && path.file_name().is_some() {
                                 Ok(AbsFilePath { path })
                             } else {
                                 Err(E::invalid_value(
                                     Unexpected::Str(path.to_string_lossy().as_ref()),
                                     &"an absolute file path to a file",
                                 ))
                             }
                         }
                     }
                     None => Err(E::invalid_value(
                         Unexpected::Str(v.as_str()),
                         &"an absolute file path",
                     )),
                 }
             }
         }
         deserializer.deserialize_string(FilePathVisitor)
     }
 }
 impl<const IS_DIR: bool> Display for AbsFilePath<IS_DIR> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str(&self.path.to_string_lossy())
     }
 }
 /// Wrapper around an absolute HTTP(S) [`Url`].
 #[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct HttpUrl {
     /// The HTTP(S) `Url`.
     url: Url,
 }
 impl HttpUrl {
     /// Returns `self` as a [`Url`] reference.
     #[inline]
     #[must_use]
     pub const fn as_url(&self) -> &Url {
         &self.url
     }
     /// Returns an `HttpUrl` iff `url` has a host and HTTP(S) scheme.
     #[inline]
     #[must_use]
     pub fn from_url(url: Url) -> Option<Self> {
         (url.has_host() && (url.scheme() == "http" || url.scheme() == "https"))
             .then_some(Self { url })
     }
 }
 impl AsRef<Url> for HttpUrl {
     #[inline]
     fn as_ref(&self) -> &Url {
         self.as_url()
     }
 }
 impl Borrow<Url> for HttpUrl {
     #[inline]
     fn borrow(&self) -> &Url {
         self.as_url()
     }
 }
 impl Deref for HttpUrl {
     type Target = Url;
     #[inline]
     fn deref(&self) -> &Self::Target {
         self.as_url()
     }
 }
 impl Display for HttpUrl {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         self.url.fmt(f)
     }
 }
 impl From<HttpUrl> for Url {
     #[inline]
     fn from(value: HttpUrl) -> Self {
         value.url
     }
 }
 impl<'de> Deserialize<'de> for HttpUrl {
     #[inline]
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         /// `Visitor` for `HttpUrl`.
         struct UrlVisitor;
         impl<'d> Visitor<'d> for UrlVisitor {
             type Value = HttpUrl;
             fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
                 formatter.write_str("struct HttpUrl")
             }
             fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
             where
                 E: de::Error,
             {
                 Url::parse(v).map_or_else(
                     |_| {
                         Err(E::invalid_type(
                             Unexpected::Str(v),
                             &"an absolute URL with HTTP(S) scheme",
                         ))
                     },
                     |url| {
                         if url.has_host() && (url.scheme() == "http" || url.scheme() == "https") {
                             Ok(HttpUrl { url })
                         } else {
                             Err(E::invalid_value(
                                 Unexpected::Other(v),
                                 &"an absolute URL with HTTP(S) scheme",
                             ))
                         }
                     },
                 )
             }
         }
         deserializer.deserialize_str(UrlVisitor)
     }
 }
 /// Represents the kind of [`ParsedDomain`]s a [`File`]
 /// contains.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum Kind {
     /// [`Adblock`] domains.
     Adblock,
     /// [`DomainOnly`] domains.
     DomainOnly,
     /// [`Hosts`] domains.
     Hosts,
     /// [`Wildcard`] domains.
     Wildcard,
 }
 impl Display for Kind {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Adblock => f.write_str("Adblock"),
             Self::DomainOnly => f.write_str("Domain-only"),
             Self::Hosts => f.write_str("Hosts"),
             Self::Wildcard => f.write_str("Wildcard"),
         }
     }
 }
 /// The name where a [`File`] was sourced from.
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum Name {
     /// The `File` came from the contained `AbsFilePath`.
     Path(AbsFilePath<false>),
     /// The `File` came from the contained `HttpUrl`.
     Url(HttpUrl),
 }
 impl Display for Name {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Path(ref path) => path.fmt(f),
             Self::Url(ref url) => url.fmt(f),
         }
     }
 }
 /// An in-memory file sourced from [`Self::name`];
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct File {
     /// The name/origin of the file.
     pub name: Name,
     /// The contents of the file.
     pub data: String,
 }
 impl Display for File {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         self.name.fmt(f)
     }
 }
 /// A summary of a [`File`] after it has been parsed
 /// into [`Value`]s.
 #[derive(Clone, Debug)]
 pub struct Summary<'a, E: Eq + Hash> {
     /// The `File` that was parsed.
     pub file: &'a File,
     /// The kind of file.
     pub kind: Kind,
     /// The quantity of domains parsed.
     pub domain_count: usize,
     /// The quantity of comments parsed.
     pub comment_count: usize,
     /// The quantity of blank lines parsed.
     pub blank_count: usize,
     /// Parsing errors and their counts.
     pub errors: HashMap<E, usize>,
 }
 impl<E: Display + Eq + Hash> Display for Summary<'_, E> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "({}) {} - domains parsed: {}, comments parsed: {}, blanks parsed: {}, parsing errors: {}",
             self.kind, self.file, self.domain_count, self.comment_count, self.blank_count, self.errors.values().sum::<usize>()
         ).and_then(|()| {
             if self.errors.is_empty() {
                 Ok(())
             } else {
                 f.write_str(", errors: [").and_then(|()| {
                     self.errors.iter().try_fold((), |(), tup| {
                         write!(f, "{}: {}, ", tup.0, tup.1)
                     })
                 }).and_then(|()| f.write_str("]"))
             }
         })
     }
 }
 impl<E: Eq + Hash> PartialEq<Summary<'_, E>> for Summary<'_, E> {
     #[inline]
     fn eq(&self, other: &Summary<'_, E>) -> bool {
         self.file == other.file
             && self.kind == other.kind
             && self.domain_count == other.domain_count
             && self.comment_count == other.comment_count
             && self.blank_count == other.blank_count
             && self.errors == other.errors
     }
 }
 impl<E: Eq + Hash> Eq for Summary<'_, E> {}
 /// Container of [`Adblock`], [`DomainOnly`], [`Hosts`], and [`Wildcard`]
 /// files.
 #[derive(Clone, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
 pub struct Files {
     /// [`Adblock`] files.
     pub adblock: Vec<File>,
     /// [`DomainOnly`] files.
     pub domain: Vec<File>,
     /// [`Hosts`] files.
     pub hosts: Vec<File>,
     /// [`Wildcard`] files.
     pub wildcard: Vec<File>,
 }
 /// Helper trait to track what kind of file.
 trait Helper {
     /// Returns the `Kind`.
     fn kind() -> Kind;
 }
 impl Helper for Adblock<'_> {
     fn kind() -> Kind {
         Kind::Adblock
     }
 }
 impl Helper for DomainOnly<'_> {
     fn kind() -> Kind {
         Kind::DomainOnly
     }
 }
 impl Helper for Hosts<'_> {
     fn kind() -> Kind {
         Kind::Hosts
     }
 }
 impl Helper for Wildcard<'_> {
     fn kind() -> Kind {
         Kind::Wildcard
     }
 }
 impl Files {
     /// Attempts to convert an `ExternalFiles` into a `Files`
     /// with `timeout_per_file` as the maximum amount of time allowed
     /// for a file to finish downloading.
     ///
     /// Note that if `timeout_per_file` is 0 or larger than one hour, then
     /// it'll be set to one hour. Similarly, if `timeout_per_file`,
     /// is less than 1 second, it'll be be set to one second.
     ///
     /// # Errors
     ///
     /// Returns `ExtFileErr` iff any of the files in `ExternalFiles`
     /// errors when downloading them and transforming them into a [`String`].
     #[inline]
     pub async fn from_external(
         ext: ExternalFiles,
         mut timeout_per_file: Duration,
     ) -> Result<Self, ExtFileErr> {
         /// `await`s each `Result` in `set` propagating any errors; otherwise
         /// the `String` is `push`ed into `files`.
         ///
         /// If an error occurs, then the function immediately returns.
         async fn add_file(
             files: &mut Vec<File>,
             timeout: Duration,
             mut set: JoinSet<Result<File, ExtFileErr>>,
         ) -> Result<(), ExtFileErr> {
             while let Some(file) = time::timeout(timeout, set.join_next()).await? {
                 files.push(file??);
             }
             Ok(())
         }
         timeout_per_file = if timeout_per_file == Duration::ZERO {
             Duration::from_secs(3600)
         } else {
             timeout_per_file.clamp(Duration::from_secs(1), Duration::from_secs(3600))
         };
         let mut files = Self {
             adblock: Vec::with_capacity(ext.adblock.len()),
             domain: Vec::with_capacity(ext.domain.len()),
             hosts: Vec::with_capacity(ext.hosts.len()),
             wildcard: Vec::with_capacity(ext.wildcard.len()),
         };
         add_file(&mut files.adblock, timeout_per_file, ext.adblock).await?;
         add_file(&mut files.domain, timeout_per_file, ext.domain).await?;
         add_file(&mut files.hosts, timeout_per_file, ext.hosts).await?;
         add_file(&mut files.wildcard, timeout_per_file, ext.wildcard).await?;
         Ok(files)
     }
     /// Creates an empty instance of `Files`.
     #[inline]
     #[must_use]
     pub const fn new() -> Self {
         Self {
             adblock: Vec::new(),
             domain: Vec::new(),
             hosts: Vec::new(),
             wildcard: Vec::new(),
         }
     }
     /// Reads each [`String`] from each field and attempts
     /// to transform each line into an `RpzDomain` before adding
     /// the domain into `doms`.
     ///
     /// Returns a `Vec` containing `Summary` information for each
     /// [`File`] that was parsed.
     #[expect(clippy::arithmetic_side_effects, reason = "math is verified")]
     #[inline]
     pub fn add_to_superset<'a: 'b, 'b>(
         &'a self,
         doms: &mut SupersetSet<RpzDomain<'b>>,
     ) -> Vec<Summary<'a, FirefoxDomainErr>> {
         /// Iterates each `String` from `files` and transforms each line
         /// into `T` before adding it as an `RpzDomain` into `doms`.
         fn insert<
             'a,
             'b: 'a,
             T: Into<RpzDomain<'a>> + ParsedDomain<'a, Error = FirefoxDomainErr> + Helper,
         >(
             doms: &mut SupersetSet<RpzDomain<'a>>,
             files: &'b [File],
             summaries: &mut Vec<Summary<'b, FirefoxDomainErr>>,
         ) {
             let kind = T::kind();
             files.iter().fold((), |(), file| {
                 let mut summary = Summary {
                     file,
                     kind,
                     domain_count: 0,
                     comment_count: 0,
                     blank_count: 0,
                     errors: HashMap::new(),
                 };
                 file.data
                     .lines()
                     .fold((), |(), line| match T::parse_value(line) {
                         Ok(val) => match val {
                             Value::Domain(dom) => {
                                 summary.domain_count = summary.domain_count.saturating_add(1);
                                 doms.insert(dom.into());
                             }
                             Value::Comment(_) => {
                                 summary.comment_count = summary.comment_count.saturating_add(1);
                             }
                             Value::Blank => {
                                 summary.blank_count = summary.blank_count.saturating_add(1);
                             }
                         },
                         Err(err) => {
                             let count = summary.errors.entry(err).or_insert(0);
                             *count = count.saturating_add(1);
                         }
                     });
                 summaries.push(summary);
             });
         }
         let mut summaries = Vec::with_capacity(
             self.adblock.len() + self.domain.len() + self.hosts.len() + self.wildcard.len(),
         );
         insert::<Adblock<'_>>(doms, self.adblock.as_slice(), &mut summaries);
         insert::<DomainOnly<'_>>(doms, self.domain.as_slice(), &mut summaries);
         insert::<Hosts<'_>>(doms, self.hosts.as_slice(), &mut summaries);
         insert::<Wildcard<'_>>(doms, self.wildcard.as_slice(), &mut summaries);
         summaries
     }
     /// Returns `true` iff there are no files.
     #[inline]
     #[must_use]
     pub fn is_empty(&self) -> bool {
         self.adblock.is_empty()
             && self.domain.is_empty()
             && self.hosts.is_empty()
             && self.wildcard.is_empty()
     }
 }
 impl Default for Files {
     #[inline]
     fn default() -> Self {
         Self::new()
     }
 }
 /// Block and unblock [`Files`] stored on the local file system.
 #[derive(Debug)]
 pub struct LocalFiles {
     /// Local file system files containing domains to not block.
     pub unblock: Files,
     /// Local file system files containing domains to block.
     pub block: Files,
 }
 impl LocalFiles {
     /// Reads all block and unblock files in the `adblock/`, `domain/`, `hosts/`, and `wildcard/` directories
     /// under `dir/block/` and `dir/unblock/` respectively.
     ///
     /// # Errors
     ///
     /// Returns [`io::Error`] iff reading said files causes an error. Note that
     /// it is _not_ an error if a directory does not exist.
     #[expect(
         clippy::wildcard_enum_match_arm,
         reason = "too many to enumerate manually"
     )]
     #[inline]
     pub fn from_path(dir: AbsFilePath<true>) -> Result<Option<Self>, io::Error> {
         /// Checks if `path` exists.
         fn exists<P: AsRef<Path>>(path: P) -> Result<bool, io::Error> {
             fs::metadata(path).map_or_else(
                 |err| match err.kind() {
                     ErrorKind::NotFound => Ok(false),
                     _ => Err(err),
                 },
                 |_| Ok(true),
             )
         }
         /// Reads all files stored in `adblock/`, `domain/`, `hosts/`, and `wildcard/`
         /// directories under `dir/name/`.
         fn get_files(
             mut dir: PathBuf,
             files: &mut Files,
             name: &str,
         ) -> Result<PathBuf, io::Error> {
             /// Reads all files under `dir/name/`.
             fn get_file(
                 files: &mut Vec<File>,
                 mut dir: PathBuf,
                 name: &str,
             ) -> Result<PathBuf, io::Error> {
                 dir.push(name);
                 if exists(dir.as_path())? {
                     for entry in fs::read_dir(dir.as_path())? {
                         let file = entry?;
                         if !file.file_type()?.is_dir() {
                             let path = file.path();
                             files.push(fs::read_to_string(path.as_path()).map(|data| File {
                                 name: Name::Path(AbsFilePath::<false> { path }),
                                 data,
                             })?);
                         }
                     }
                 }
                 dir.pop();
                 Ok(dir)
             }
             dir.push(name);
             if exists(dir.as_path())? {
                 get_file(&mut files.adblock, dir, "adblock/")
                     .and_then(|dir2| get_file(&mut files.domain, dir2, "domain/"))
                     .and_then(|dir2| get_file(&mut files.hosts, dir2, "hosts/"))
                     .and_then(|dir2| get_file(&mut files.wildcard, dir2, "wildcard/"))
                     .map(|mut dir2| {
                         dir2.pop();
                         dir2
                     })
             } else {
                 dir.pop();
                 Ok(dir)
             }
         }
         let mut unblock = Files::new();
         let mut block = Files::new();
         get_files(PathBuf::from(dir), &mut unblock, "unblock/").and_then(|dir2| {
             get_files(dir2, &mut block, "block/").map(|_| {
                 if unblock.is_empty() && block.is_empty() {
                     None
                 } else {
                     Some(Self { unblock, block })
                 }
             })
         })
     }
 }
 /// Error returned when downloading text files from HTTP(S) servers.
 #[derive(Debug)]
 pub enum ExtFileErr {
     /// Error when a task exceeds the specified timeout.
     Timeout(Elapsed),
     /// HTTP(S) error when attempting to download a file.
     Http(reqwest::Error),
     /// Error when a task fails to complete.
     Join(JoinError),
     /// Error when a file is not valid UTF-8.
     InvalidUtf8(FromUtf8Error),
 }
 impl Display for ExtFileErr {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Timeout(ref err) => err.fmt(f),
             Self::Http(ref err) => err.fmt(f),
             Self::Join(ref err) => err.fmt(f),
             Self::InvalidUtf8(ref err) => err.fmt(f),
         }
     }
 }
 impl From<Elapsed> for ExtFileErr {
     #[inline]
     fn from(value: Elapsed) -> Self {
         Self::Timeout(value)
     }
 }
 impl From<reqwest::Error> for ExtFileErr {
     #[inline]
     fn from(value: reqwest::Error) -> Self {
         Self::Http(value)
     }
 }
 impl From<JoinError> for ExtFileErr {
     #[inline]
     fn from(value: JoinError) -> Self {
         Self::Join(value)
     }
 }
 impl From<FromUtf8Error> for ExtFileErr {
     #[inline]
     fn from(value: FromUtf8Error) -> Self {
         Self::InvalidUtf8(value)
     }
 }
 impl Error for ExtFileErr {}
 /// Tasks of downloaded files from HTTP(S) servers.
 #[derive(Debug)]
 pub struct ExternalFiles {
     /// [`Adblock`]-based files.
     pub adblock: JoinSet<Result<File, ExtFileErr>>,
     /// [`DomainOnly`]-based files.
     pub domain: JoinSet<Result<File, ExtFileErr>>,
     /// [`Hosts`]-based files.
     pub hosts: JoinSet<Result<File, ExtFileErr>>,
     /// [`Wildcard`]-based files.
     pub wildcard: JoinSet<Result<File, ExtFileErr>>,
 }
 impl ExternalFiles {
     /// Returns `ExternalFiles` containing files downloaded
     /// from the `HashSet`s.
     #[inline]
     #[must_use]
     pub fn new_with_urls(
         client: &'static Client,
         adblock_urls: HashSet<HttpUrl>,
         domain_urls: HashSet<HttpUrl>,
         hosts_urls: HashSet<HttpUrl>,
         wildcard_urls: HashSet<HttpUrl>,
     ) -> Self {
         let mut val = Self::new();
         val.add_adblock(client, adblock_urls);
         val.add_domain(client, domain_urls);
         val.add_hosts(client, hosts_urls);
         val.add_wildcard(client, wildcard_urls);
         val
     }
     /// Returns an empty `ExternalFiles`.
     #[inline]
     #[must_use]
     pub fn new() -> Self {
         Self {
             adblock: JoinSet::new(),
             domain: JoinSet::new(),
             hosts: JoinSet::new(),
             wildcard: JoinSet::new(),
         }
     }
     /// Downloads the [`Adblock`] files from `urls` and adds them to [`ExternalFiles::adblock`].
     #[inline]
     pub fn add_adblock(&mut self, client: &'static Client, urls: HashSet<HttpUrl>) {
         Self::get_external_files(&mut self.adblock, client, urls);
     }
     /// Downloads the [`DomainOnly`] files from `urls` and adds them to [`ExternalFiles::domain`].
     #[inline]
     pub fn add_domain(&mut self, client: &'static Client, urls: HashSet<HttpUrl>) {
         Self::get_external_files(&mut self.domain, client, urls);
     }
     /// Downloads the [`Hosts`] files from `urls` and adds them to [`ExternalFiles::hosts`].
     #[inline]
     pub fn add_hosts(&mut self, client: &'static Client, urls: HashSet<HttpUrl>) {
         Self::get_external_files(&mut self.hosts, client, urls);
     }
     /// Downloads the [`Wildcard`] files from `urls` and adds them to [`ExternalFiles::wildcard`].
     #[inline]
     pub fn add_wildcard(&mut self, client: &'static Client, urls: HashSet<HttpUrl>) {
         Self::get_external_files(&mut self.wildcard, client, urls);
     }
     /// Downloads the files from `urls` and converts them to `String`s adding the
     /// tasks to `set`.
     #[expect(clippy::iter_over_hash_type, reason = "order does not matter")]
     fn get_external_files(
         set: &mut JoinSet<Result<File, ExtFileErr>>,
         client: &'static Client,
         urls: HashSet<HttpUrl>,
     ) {
         for url in Into::<HashSet<HttpUrl>>::into(urls) {
             let url_clone = url.clone();
             set.spawn(async {
                 let resp = client
                     .get::<Url>(url_clone.into())
                     .send()
                     .await?
                     .error_for_status()?;
                 resp.bytes().await.map_or_else(
                     |err| Err(ExtFileErr::Http(err)),
                     |bytes| {
                         String::from_utf8(bytes.into())
                             .map_err(ExtFileErr::InvalidUtf8)
                             .map(|data| File {
                                 name: Name::Url(url),
                                 data,
                             })
                     },
                 )
             });
         }
     }
 }
 impl Default for ExternalFiles {
     #[inline]
     fn default() -> Self {
         Self::new()
     }
 }