rpz

dom.rs (68143B)

---

 use crate::dom_count_auto_gen::proper_subdomain_count;
 use ascii_domain::{
     char_set::{ASCII_FIREFOX, AllowedAscii},
     dom::{Domain, DomainErr, DomainOrdering},
 };
 use core::{
     borrow::Borrow,
     cmp::Ordering,
     convert,
     fmt::{self, Display, Formatter},
     hash::{Hash, Hasher},
     num::NonZeroU8,
     ops::Deref,
     str,
 };
 use num_bigint::BigUint;
 use std::{
     error,
     io::{Error, Write},
 };
 use superset_map::SetOrd;
 use zfc::{BoundedCardinality, Cardinality, Set};
 /// Unit tests.
 #[cfg(test)]
 mod tests;
 /// One.
 const ONE: NonZeroU8 = NonZeroU8::new(1).unwrap();
 /// Error returned when an invalid string is passed to [`Adblock::parse_value`], [`DomainOnly::parse_value`],
 /// [`Hosts::parse_value`], [`Wildcard::parse_value`], or [`RpzDomain::parse_value`].
 #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub enum FirefoxDomainErr {
     /// The domain is invalid based on [`Domain`] using [`ASCII_FIREFOX`].
     InvalidDomain(DomainErr),
     /// The domain had a TLD that was not all letters nor length of at least five beginning with `b"xn--"`.
     InvalidTld,
     /// The string passed to [`Adblock::parse_value`] contained `$`.
     InvalidAdblockDomain,
     /// The string passed to [`Hosts::parse_value`] did not conform
     /// to the required [`Hosts`] format.
     InvalidHostsIP,
     /// The length of the non-wildcard portion of the string passed to
     /// [`Wildcard::parse_value`] was at least 252 which means there are
     /// no proper subdomains.
     InvalidWildcardDomain,
 }
 impl Display for FirefoxDomainErr {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::InvalidDomain(err) => err.fmt(f),
             Self::InvalidTld => f.write_str("domain had a TLD that was not all letters nor at least five characters long starting with 'xn--'"),
             Self::InvalidAdblockDomain => f.write_str("Adblock-style domain contained a '$'"),
             Self::InvalidHostsIP => f.write_str("hosts-style domain does not begin with the IP '::', '::1', '0.0.0.0', or '127.0.0.1' followed by at least one space or tab"),
             Self::InvalidWildcardDomain => f.write_str("non-wildcard portion of a wildcard domain had length of at least 252 which means there are 0 proper subdomains"),
         }
     }
 }
 impl error::Error for FirefoxDomainErr {}
 /// The ASCII we allow domains to have.
 const CHARS: &AllowedAscii<[u8; 78]> = &ASCII_FIREFOX;
 /// Parses a `[u8]` into a `Domain` using `CHARS` with the added restriction that the `Domain` has a TLD
 /// that is either all letters or has length of at least five and begins with `b"xn--"`.
 #[expect(clippy::indexing_slicing, reason = "we verify manually")]
 fn domain_icann_tld<'a: 'b, 'b>(val: &'a [u8]) -> Result<Domain<&'b str>, FirefoxDomainErr> {
     Domain::try_from_bytes(val, CHARS)
         .map_err(FirefoxDomainErr::InvalidDomain)
         .and_then(|dom| {
             let tld = dom.tld();
             // `tld.as_bytes()[..4]` won't panic since we check before that that the length is at least 5.
             if tld.is_alphabetic() || (tld.len().get() > 4 && tld.as_bytes()[..4] == *b"xn--") {
                 Ok(dom.into())
             } else {
                 Err(FirefoxDomainErr::InvalidTld)
             }
         })
 }
 /// Action taken by a DNS server when a domain matches.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum RpzAction {
     /// Send `NXDOMAIN` reply.
     Nxdomain,
     /// Send `NODATA` reply.
     Nodata,
     /// Do nothing; continue as normal.
     Passthru,
     /// Drop the query.
     Drop,
     /// Answer over TCP.
     TcpOnly,
 }
 impl Display for RpzAction {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Nxdomain => f.write_str("NXDOMAIN"),
             Self::Nodata => f.write_str("NODATA"),
             Self::Passthru => f.write_str("PASSTHRU"),
             Self::Drop => f.write_str("DROP"),
             Self::TcpOnly => f.write_str("TCP-Only"),
         }
     }
 }
 impl PartialEq<&Self> for RpzAction {
     #[inline]
     fn eq(&self, other: &&Self) -> bool {
         *self == **other
     }
 }
 impl PartialEq<RpzAction> for &RpzAction {
     #[inline]
     fn eq(&self, other: &RpzAction) -> bool {
         **self == *other
     }
 }
 /// Writes the following line with `writer` based on `action`:
 /// * `RpzAction::Nxdomain`: `<dom> CNAME .`.
 /// * `RpzAction::Nodata`: `<dom> CNAME *.`.
 /// * `RpzAction::Passthru`: `<dom> CNAME rpz-passthru.`.
 /// * `RpzAction::Drop`: `<dom> CNAME rpz-drop.`.
 /// * `RpzAction::TcpOnly`: `<dom> CNAME rpz-tcp-only.`.
 ///
 /// `*.` is prepended to `<dom>` iff `wildcard`.
 ///
 /// # Errors
 ///
 /// Returns [`Error`] iff [`writeln`] does.
 #[inline]
 pub fn write_rpz_line<W: Write, T>(
     mut writer: W,
     dom: &Domain<T>,
     action: RpzAction,
     wildcard: bool,
 ) -> Result<(), Error>
 where
     Domain<T>: Display,
 {
     writeln!(
         writer,
         "{}{} CNAME {}.",
         if wildcard { "*." } else { "" },
         dom,
         match action {
             RpzAction::Nxdomain => "",
             RpzAction::Nodata => "*",
             RpzAction::Passthru => "rpz-passthru",
             RpzAction::Drop => "rpz-drop",
             RpzAction::TcpOnly => "rpz-tcp-only",
         }
     )
 }
 /// Type that can be returned by [`Domain`]-like parsers (e.g., [`Adblock`]).
 #[derive(Clone, Copy, Debug)]
 pub enum Value<'a, T: ParsedDomain<'a>> {
     /// The parsed value is a domain.
     Domain(T),
     /// The parsed value is a comment.
     Comment(&'a str),
     /// The parsed value is blank or just [ASCII whitespace](https://infra.spec.whatwg.org/#ascii-whitespace).
     Blank,
 }
 impl<'a, T: ParsedDomain<'a>> Value<'a, T> {
     /// Returns `true` iff `self` is a [`Self::Domain`].
     #[inline]
     pub const fn is_domain(&self) -> bool {
         match *self {
             Self::Domain(_) => true,
             Self::Comment(_) | Self::Blank => false,
         }
     }
     /// Returns `true` iff `self` is a [`Self::Comment`].
     #[inline]
     pub const fn is_comment(&self) -> bool {
         match *self {
             Self::Comment(_) => true,
             Self::Domain(_) | Self::Blank => false,
         }
     }
     /// Returns `true` iff `self` is a [`Self::Blank`].
     #[inline]
     pub const fn is_blank(&self) -> bool {
         matches!(*self, Value::Blank)
     }
     /// Returns the contained [`Self::Domain`] value.
     ///
     /// # Panics
     ///
     /// Panics iff `self` is [`Self::Comment`] or [`Self::Blank`].
     #[expect(clippy::panic, reason = "bug if called incorrectly")]
     #[inline]
     pub fn unwrap_domain(self) -> T {
         match self {
             Self::Domain(dom) => dom,
             Self::Comment(_) | Self::Blank => {
                 panic!("called `ParsedDomain::unwrap_domain()` on a `Comment` or `Blank` value")
             }
         }
     }
     /// Returns the contained [`prim@str`] in [`Self::Comment`].
     ///
     /// # Panics
     ///
     /// Panics iff `self` is [`Self::Domain`] or [`Self::Blank`].
     #[expect(clippy::panic, reason = "bug if called incorrectly")]
     #[inline]
     pub fn unwrap_comment(self) -> &'a str {
         match self {
             Self::Comment(com) => com,
             Self::Domain(_) | Self::Blank => {
                 panic!("called `ParsedDomain::unwrap_comment()` on a `Domain` or `Blank` value")
             }
         }
     }
     /// Returns [`unit`] when `self` is [`Self::Blank`].
     ///
     /// # Panics
     ///
     /// Panics iff `self` is [`Self::Domain`] or [`Self::Comment`].
     #[expect(clippy::panic, reason = "bug if called incorrectly")]
     #[inline]
     pub fn unwrap_blank(self) {
         match self {
             Self::Blank => {}
             Self::Domain(_) | Self::Comment(_) => {
                 panic!("called `ParsedDomain::unwrap_blank()` on a `Domain` or `Comment` value")
             }
         }
     }
 }
 /// Structure of a [`Domain`]-like type that can parse [`prim@str`]s into [`Value`]s.
 ///
 /// When parsed into a [`Value::Domain`], the domain can be written to a
 /// [response policy zone (RPZ)](https://en.wikipedia.org/wiki/Response_policy_zone) file.
 pub trait ParsedDomain<'a>: Sized {
     /// The error returned from [`Self::parse_value`].
     type Error;
     /// Parses a `str` into a `Value`.
     /// # Errors
     ///
     /// Errors iff `val` is unable to be parsed into a `Value`.
     fn parse_value<'b: 'a>(val: &'b str) -> Result<Value<'a, Self>, Self::Error>;
     /// Reference to the contained `Domain`.
     fn domain(&self) -> &Domain<&'a str>;
     /// Writes `self` as RPZ lines via `writer`.
     ///
     /// # Errors
     ///
     /// Errors iff `writer` errors.
     fn write_to_rpz<W: Write>(&self, action: RpzAction, writer: W) -> Result<(), Error>;
 }
 /// Domain constructed from an
 /// [Adblock-style rule](https://adguard-dns.io/kb/general/dns-filtering-syntax/#adblock-style-syntax).
 ///
 /// Specifically the domain must conform to the following extended regex:
 ///
 /// `^<ws>*(\|\|)?<ws>*<domain><ws>*\^?<ws>*$`
 ///
 /// where `<domain>` conforms to a valid [`Domain`] based on [`ASCII_FIREFOX`] with the added requirement that it
 /// does not contain `$`, the TLD is either all letters or at least length five and begins with `xn--`, and `<ws>` is any sequence of
 /// [ASCII whitespace](https://infra.spec.whatwg.org/#ascii-whitespace).
 ///
 /// Comments are any lines that start with `!` or `#` (ignoring whitespace). Any in-line comments after a valid
 /// domain are ignored and will be parsed into a [`Value::Domain`].
 ///
 /// Note that this means some valid Adblock-style rules are not considered valid since such rules often contain
 /// path information or modifiers (e.g., “third-party”), but this only considers domain-only rules.
 #[derive(Clone, Debug)]
 pub struct Adblock<'a> {
     /// The `Domain`.
     domain: Domain<&'a str>,
     /// `true` iff `domain` represents all subdomains. Note that this includes `domain` itself.
     subdomains: bool,
 }
 impl Adblock<'_> {
     /// Returns `true` iff the contained [`Domain`] represents all subdomains. Note this includes the
     /// `Domain` itself.
     #[inline]
     #[must_use]
     pub const fn is_subdomains(&self) -> bool {
         self.subdomains
     }
     /// Since `DomainOnly` and `Hosts` are treated the same, we have this helper function that can be used
     /// for both.
     #[must_use]
     fn cmp_dom(&self, other: &Domain<&str>) -> Ordering {
         match self.domain.cmp_by_domain_ordering(other) {
             DomainOrdering::Less => Ordering::Less,
             DomainOrdering::Shorter => {
                 if self.subdomains {
                     Ordering::Greater
                 } else {
                     Ordering::Less
                 }
             }
             DomainOrdering::Equal => {
                 if self.subdomains {
                     Ordering::Greater
                 } else {
                     Ordering::Equal
                 }
             }
             DomainOrdering::Longer | DomainOrdering::Greater => Ordering::Greater,
         }
     }
     /// The total order that is defined follows the following hierarchy:
     /// 1. Pairwise comparisons of each [`ascii_domain::dom::Label`] starting from the TLDs.
     /// 2. If 1. evaluates as not equivalent, then return the result.
     /// 3. If `self` represents a single `Domain` (i.e., `!self.is_subdomains()`),
     ///    then return the comparison of label counts.
     /// 4. `self` is greater.
     ///
     /// For example, `com` `<` `example.com` `<` `||example.com` `<` `||com` `<` `net` `<` `example.net` `<` `||example.net` `<` `||net`.
     #[inline]
     #[must_use]
     pub fn cmp_domain_only(&self, other: &DomainOnly<'_>) -> Ordering {
         self.cmp_dom(&other.domain)
     }
     /// Same as [`Adblock::cmp_domain_only`].
     #[inline]
     #[must_use]
     pub fn cmp_hosts(&self, other: &Hosts<'_>) -> Ordering {
         self.cmp_dom(&other.domain)
     }
     /// The total order that is defined follows the following hierarchy:
     /// 1. Pairwise comparisons of each [`ascii_domain::dom::Label`] starting from the TLDs.
     /// 2. If 1. evaluates as not equivalent, then return the result.
     /// 3. If both domains represent a single `Domain`, then return the comparison
     ///    of label counts.
     /// 4. If one domain represents a single `Domain`, then return that that domain is less.
     /// 5. If the label counts are the same, `self` is greater.
     /// 6. Return the inverse of the comparison of label counts.
     ///
     /// For example the following is a sequence of domains in
     /// ascending order:
     ///
     /// `bar.com`, `www.bar.com`, `*.www.bar.com`, `||www.bar.com`, `*.bar.com`, `||bar.com`, `example.com`, `www.example.com`, `*.www.example.com`, `||www.example.com`, `*.example.com`, `||example.com`, `foo.com`, `www.foo.com`, `*.foo.com`, `*.com`, `example.net`, `*.net`
     #[inline]
     #[must_use]
     pub fn cmp_wildcard(&self, other: &Wildcard<'_>) -> Ordering {
         match self.domain.cmp_by_domain_ordering(&other.domain) {
             DomainOrdering::Less => Ordering::Less,
             DomainOrdering::Shorter => {
                 if self.subdomains {
                     Ordering::Greater
                 } else {
                     Ordering::Less
                 }
             }
             DomainOrdering::Equal => {
                 if self.subdomains {
                     Ordering::Greater
                 } else if other.proper_subdomains {
                     Ordering::Less
                 } else {
                     Ordering::Equal
                 }
             }
             DomainOrdering::Longer => {
                 if self.subdomains {
                     if other.proper_subdomains {
                         Ordering::Less
                     } else {
                         Ordering::Greater
                     }
                 } else if other.proper_subdomains {
                     Ordering::Less
                 } else {
                     Ordering::Greater
                 }
             }
             DomainOrdering::Greater => Ordering::Greater,
         }
     }
     /// Same as [`Adblock::cardinality`] except that a `BigUint` is returned. Note the count _includes_
     /// the `Domain` itself when `self.is_subdomains()`.
     ///
     /// `!self.is_subdomains()` ⇔ `self.domain_count() == BigUint::new(vec![1])`.
     #[expect(clippy::arithmetic_side_effects, reason = "arbitrary-sized arithmetic")]
     #[inline]
     #[must_use]
     pub fn domain_count(&self) -> BigUint {
         if self.subdomains {
             proper_subdomain_count(&self.domain) + BigUint::new(vec![1])
         } else {
             BigUint::new(vec![1])
         }
     }
 }
 impl Display for Adblock<'_> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "{}{}",
             if self.subdomains { "||" } else { "" },
             self.domain
         )
     }
 }
 impl PartialEq<Adblock<'_>> for Adblock<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         self.domain == other.domain && self.subdomains == other.subdomains
     }
 }
 impl PartialEq<&Adblock<'_>> for Adblock<'_> {
     #[inline]
     fn eq(&self, other: &&Adblock<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Adblock<'_>> for &Adblock<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<DomainOnly<'_>> for Adblock<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         !self.subdomains && self.domain == other.domain
     }
 }
 impl PartialEq<&DomainOnly<'_>> for Adblock<'_> {
     #[inline]
     fn eq(&self, other: &&DomainOnly<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<DomainOnly<'_>> for &Adblock<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&Adblock<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &&Adblock<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Adblock<'_>> for &DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<Hosts<'_>> for Adblock<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         !self.subdomains && self.domain == other.domain
     }
 }
 impl PartialEq<&Hosts<'_>> for Adblock<'_> {
     #[inline]
     fn eq(&self, other: &&Hosts<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Hosts<'_>> for &Adblock<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&Adblock<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &&Adblock<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Adblock<'_>> for &Hosts<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<Wildcard<'_>> for Adblock<'_> {
     #[expect(clippy::suspicious_operation_groupings, reason = "false positive")]
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         !(self.subdomains || other.proper_subdomains) && self.domain == other.domain
     }
 }
 impl PartialEq<&Wildcard<'_>> for Adblock<'_> {
     #[inline]
     fn eq(&self, other: &&Wildcard<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Wildcard<'_>> for &Adblock<'_> {
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&Adblock<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &&Adblock<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Adblock<'_>> for &Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         **self == *other
     }
 }
 impl Eq for Adblock<'_> {}
 impl Hash for Adblock<'_> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.domain.hash(state);
     }
 }
 impl PartialOrd<Adblock<'_>> for Adblock<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Adblock<'_>) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 impl Ord for Adblock<'_> {
     /// The total order that is defined follows the following hierarchy:
     /// 1. Pairwise comparisons of each [`ascii_domain::dom::Label`] starting from the TLDs.
     /// 2. If 1. evaluates as not equivalent, then return the result.
     /// 3. If both domains represent a single `Domain`, then return the comparison
     ///    of label counts.
     /// 4. If one domain represents a single `Domain`, then return that that domain is less.
     /// 5. Return the inverse of the comparison of label counts.
     ///
     /// For example, `com` `<` `example.com` `<` `||example.com` `<` `||com` `<` `net` `<` `example.net` `<` `||example.net` `<` `||net`.
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         match self.domain.cmp_by_domain_ordering(&other.domain) {
             DomainOrdering::Less => Ordering::Less,
             DomainOrdering::Shorter => {
                 if self.subdomains {
                     Ordering::Greater
                 } else {
                     Ordering::Less
                 }
             }
             DomainOrdering::Equal => {
                 if self.subdomains {
                     if other.subdomains {
                         Ordering::Equal
                     } else {
                         Ordering::Greater
                     }
                 } else if other.subdomains {
                     Ordering::Less
                 } else {
                     Ordering::Equal
                 }
             }
             DomainOrdering::Longer => {
                 if self.subdomains {
                     if other.subdomains {
                         Ordering::Less
                     } else {
                         Ordering::Greater
                     }
                 } else if other.subdomains {
                     Ordering::Less
                 } else {
                     Ordering::Greater
                 }
             }
             DomainOrdering::Greater => Ordering::Greater,
         }
     }
 }
 impl PartialOrd<DomainOnly<'_>> for Adblock<'_> {
     #[inline]
     fn partial_cmp(&self, other: &DomainOnly<'_>) -> Option<Ordering> {
         Some(self.cmp_domain_only(other))
     }
 }
 impl PartialOrd<Hosts<'_>> for Adblock<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Hosts<'_>) -> Option<Ordering> {
         Some(self.cmp_hosts(other))
     }
 }
 impl PartialOrd<Wildcard<'_>> for Adblock<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Wildcard<'_>) -> Option<Ordering> {
         Some(self.cmp_wildcard(other))
     }
 }
 impl<'a> Set for Adblock<'a> {
     type Elem = Domain<&'a str>;
     #[inline]
     fn bounded_cardinality(&self) -> BoundedCardinality {
         BoundedCardinality::from_biguint_exact(self.domain_count())
     }
     #[inline]
     fn cardinality(&self) -> Option<Cardinality> {
         Some(Cardinality::Finite(self.domain_count()))
     }
     #[inline]
     fn contains<Q>(&self, elem: &Q) -> bool
     where
         Q: Borrow<Self::Elem> + Eq + ?Sized,
     {
         if self.subdomains {
             matches!(
                 self.domain.cmp_by_domain_ordering(elem.borrow()),
                 DomainOrdering::Shorter
             )
         } else {
             self.domain == *elem.borrow()
         }
     }
     #[inline]
     fn is_proper_subset(&self, val: &Self) -> bool {
         // A single domain can never be a proper superset. Subdomains` cannot be a proper superset if it has
         // more labels or the same number of labels as another subdomains. In all other cases, we need to
         // recursively check from the TLD that the labels are the same.
         val.subdomains
             && match val.domain.cmp_by_domain_ordering(&self.domain) {
                 DomainOrdering::Less | DomainOrdering::Longer | DomainOrdering::Greater => false,
                 DomainOrdering::Shorter => true,
                 DomainOrdering::Equal => !self.subdomains,
             }
     }
     #[inline]
     fn is_subset(&self, val: &Self) -> bool {
         self == val || self.is_proper_subset(val)
     }
 }
 impl SetOrd for Adblock<'_> {}
 impl<'a> Deref for Adblock<'a> {
     type Target = Domain<&'a str>;
     #[inline]
     fn deref(&self) -> &Self::Target {
         &self.domain
     }
 }
 impl<'a> ParsedDomain<'a> for Adblock<'a> {
     type Error = FirefoxDomainErr;
     #[expect(
         unsafe_code,
         clippy::indexing_slicing,
         reason = "we carefully verify what we are doing"
     )]
     #[inline]
     fn parse_value<'b: 'a>(val: &'b str) -> Result<Value<'a, Self>, Self::Error> {
         // First remove leading whitepace. Then check for comments via '#' and '!'. Return Blank iff empty.
         // Return Comment iff '#' or '!' is the first character. Remove trailing whitespace. Next remove the
         // last byte if it is '^' as well as whitespace before. Next track and remove '||' at the beginning
         // and any subsequent whitespace.
         let mut value = val.as_bytes().trim_ascii_start();
         value.first().map_or_else(
             || Ok(Value::Blank),
             |byt| {
                 if *byt == b'#' || *byt == b'!' {
                     // SAFETY:
                     // `value` came from `val` with leading ASCII whitespace removed which is still valid UTF-8
                     // since the first byte is '#' or '$' the remaining bytes is still valid UTF-8.
                     let comment = unsafe { str::from_utf8_unchecked(&value[1..]) };
                     Ok(Value::Comment(comment))
                 } else {
                     value = value.trim_ascii_end();
                     let len = value.len().wrapping_sub(1);
                     value = value.get(len).map_or(value, |byt2| {
                         if *byt2 == b'^' {
                             value[..len].trim_ascii_end()
                         } else {
                             value
                         }
                     });
                     let (subdomains, val2) = value.get(..2).map_or_else(
                         || (false, value),
                         |fst| {
                             if fst == b"||" {
                                 (true, value[2..].trim_ascii_start())
                             } else {
                                 (false, value)
                             }
                         },
                     );
                     // `Domain`s allow `$`, but we don't want to allow that symbol for Adblock-style rules.
                     val2.iter()
                         .try_fold((), |(), byt2| {
                             if *byt2 == b'$' {
                                 Err(FirefoxDomainErr::InvalidAdblockDomain)
                             } else {
                                 Ok(())
                             }
                         })
                         .and_then(|()| {
                             domain_icann_tld(val2).map(|domain| {
                                 // A domain of length 252 or 253 can't have subdomains due to there not being enough
                                 // characters.
                                 Value::Domain(Self {
                                     subdomains: if domain.len().get() > 251 {
                                         false
                                     } else {
                                         subdomains
                                     },
                                     domain,
                                 })
                             })
                         })
                 }
             },
         )
     }
     #[inline]
     fn domain(&self) -> &Domain<&'a str> {
         &self.domain
     }
     #[inline]
     fn write_to_rpz<W: Write>(&self, action: RpzAction, mut writer: W) -> Result<(), Error> {
         write_rpz_line(&mut writer, self.domain(), action, false).and_then(|()| {
             if self.subdomains {
                 write_rpz_line(writer, self.domain(), action, true)
             } else {
                 Ok(())
             }
         })
     }
 }
 /// Domain constructed from a
 /// [domains-only rule](https://adguard-dns.io/kb/general/dns-filtering-syntax/#domains-only-syntax).
 ///
 /// Specifically the domain must conform to the following extended regex:
 ///
 /// `^<ws>*<domain><ws>*(#.*)?$`
 ///
 /// where `<domain>` conforms to a valid [`Domain`] based on [`ASCII_FIREFOX`], the TLD is either all letters
 /// or at least length five and begins with `xn--`, and `<ws>` is any sequence of [ASCII whitespace](https://infra.spec.whatwg.org/#ascii-whitespace).
 ///
 /// Comments are any lines that start with `#` (ignoring whitespace). Any in-line comments after a valid domain
 /// are ignored and will be parsed into a [`Value::Domain`].
 #[derive(Clone, Debug)]
 pub struct DomainOnly<'a> {
     /// The `Domain`.
     domain: Domain<&'a str>,
 }
 impl DomainOnly<'_> {
     /// Read [`Adblock::cmp_domain_only`].
     #[inline]
     #[must_use]
     pub fn cmp_adblock(&self, other: &Adblock<'_>) -> Ordering {
         other.cmp_domain_only(self).reverse()
     }
     /// Read [`Domain::cmp`].
     #[inline]
     #[must_use]
     pub fn cmp_hosts(&self, other: &Hosts<'_>) -> Ordering {
         self.domain.cmp(&other.domain)
     }
     /// Read [`Wildcard::cmp_domain_only`].
     #[inline]
     #[must_use]
     pub fn cmp_wildcard(&self, other: &Wildcard<'_>) -> Ordering {
         other.cmp_domain_only(self).reverse()
     }
     /// Same as [`DomainOnly::cardinality`] except that a `NonZeroU8` is returned.
     ///
     /// The value is always 1.
     #[inline]
     #[must_use]
     pub const fn domain_count(&self) -> NonZeroU8 {
         ONE
     }
 }
 impl PartialEq<DomainOnly<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         self.domain == other.domain
     }
 }
 impl PartialEq<DomainOnly<'_>> for &DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&DomainOnly<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &&DomainOnly<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Adblock<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         other == self
     }
 }
 impl PartialEq<Hosts<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         self.domain == other.domain
     }
 }
 impl PartialEq<&Hosts<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &&Hosts<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Hosts<'_>> for &DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&DomainOnly<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &&DomainOnly<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<DomainOnly<'_>> for &Hosts<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<Wildcard<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         !other.proper_subdomains && self.domain == other.domain
     }
 }
 impl PartialEq<&Wildcard<'_>> for DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &&Wildcard<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Wildcard<'_>> for &DomainOnly<'_> {
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&DomainOnly<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &&DomainOnly<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<DomainOnly<'_>> for &Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         **self == *other
     }
 }
 impl Eq for DomainOnly<'_> {}
 impl Hash for DomainOnly<'_> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.domain.hash(state);
     }
 }
 impl PartialOrd<DomainOnly<'_>> for DomainOnly<'_> {
     #[inline]
     fn partial_cmp(&self, other: &DomainOnly<'_>) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 impl Ord for DomainOnly<'_> {
     /// Read [`Domain::cmp`].
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         self.domain.cmp(&other.domain)
     }
 }
 impl PartialOrd<Adblock<'_>> for DomainOnly<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Adblock<'_>) -> Option<Ordering> {
         Some(self.cmp_adblock(other))
     }
 }
 impl PartialOrd<Hosts<'_>> for DomainOnly<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Hosts<'_>) -> Option<Ordering> {
         Some(self.cmp_hosts(other))
     }
 }
 impl PartialOrd<Wildcard<'_>> for DomainOnly<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Wildcard<'_>) -> Option<Ordering> {
         Some(self.cmp_wildcard(other))
     }
 }
 impl Display for DomainOnly<'_> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         self.domain.fmt(f)
     }
 }
 impl<'a> Set for DomainOnly<'a> {
     type Elem = Domain<&'a str>;
     #[inline]
     fn bounded_cardinality(&self) -> BoundedCardinality {
         BoundedCardinality::from_biguint_exact(self.domain_count().get().into())
     }
     #[inline]
     fn cardinality(&self) -> Option<Cardinality> {
         Some(Cardinality::Finite(self.domain_count().get().into()))
     }
     #[inline]
     fn contains<Q>(&self, elem: &Q) -> bool
     where
         Q: Borrow<Self::Elem> + Eq + ?Sized,
     {
         self.domain == *elem.borrow()
     }
     #[inline]
     fn is_proper_subset(&self, _: &Self) -> bool {
         false
     }
     #[inline]
     fn is_subset(&self, val: &Self) -> bool {
         self == val
     }
 }
 impl SetOrd for DomainOnly<'_> {}
 impl<'a> Deref for DomainOnly<'a> {
     type Target = Domain<&'a str>;
     #[inline]
     fn deref(&self) -> &Self::Target {
         &self.domain
     }
 }
 impl<'a> ParsedDomain<'a> for DomainOnly<'a> {
     type Error = FirefoxDomainErr;
     #[expect(
         unsafe_code,
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "we verify all use is correct"
     )]
     #[inline]
     fn parse_value<'b: 'a>(val: &'b str) -> Result<Value<'a, Self>, Self::Error> {
         let value = val.as_bytes().trim_ascii_start();
         value.first().map_or_else(
             || Ok(Value::Blank),
             |byt| {
                 if *byt == b'#' {
                     // SAFETY:
                     // `value` came from `val` with leading ASCII whitespace removed which is still valid UTF-8
                     // since the first byte is '#' or '$' the remaining bytes are still valid UTF-8.
                     let comment = unsafe { str::from_utf8_unchecked(&value[1..]) };
                     Ok(Value::Comment(comment))
                 } else {
                     domain_icann_tld(
                         value[..value
                             .iter()
                             .try_fold(0, |i, byt2| if *byt2 == b'#' { Err(i) } else { Ok(i + 1) })
                             .unwrap_or_else(convert::identity)]
                             .trim_ascii_end(),
                     )
                     .map(|domain| Value::Domain(Self { domain }))
                 }
             },
         )
     }
     #[inline]
     fn domain(&self) -> &Domain<&'a str> {
         &self.domain
     }
     #[inline]
     fn write_to_rpz<W: Write>(&self, action: RpzAction, mut writer: W) -> Result<(), Error> {
         write_rpz_line(&mut writer, self.domain(), action, false)
     }
 }
 /// Domain constructed from a
 /// [`hosts(5)`-style rule](https://adguard-dns.io/kb/general/dns-filtering-syntax/#etc-hosts-syntax).
 ///
 /// Specifically the domain must conform to the following extended regex:
 ///
 /// `^<ws>*<ip><ws>+<domain><ws>*(#.*)?$`
 ///
 /// where `<domain>` conforms to a valid [`Domain`] based on [`ASCII_FIREFOX`], the TLD is either all letters
 /// or at least length five and begins with `xn--`, `<ws>` is any sequence of
 /// [ASCII whitespace](https://infra.spec.whatwg.org/#ascii-whitespace), and `<ip>` is one of the following:
 ///
 /// `::`, `::1`, `0.0.0.0`, or `127.0.0.1`.
 ///
 /// Comments are any lines that start with `#` (ignoring whitespace). Any in-line comments after a valid domain
 /// are ignored and will be parsed into a [`Value::Domain`].
 #[derive(Clone, Debug)]
 pub struct Hosts<'a> {
     /// The `Domain`.
     domain: Domain<&'a str>,
 }
 impl Hosts<'_> {
     /// Read [`Adblock::cmp_hosts`].
     #[inline]
     #[must_use]
     pub fn cmp_adblock(&self, other: &Adblock<'_>) -> Ordering {
         other.cmp_hosts(self).reverse()
     }
     /// Read [`DomainOnly::cmp_hosts`].
     #[inline]
     #[must_use]
     pub fn cmp_domain_only(&self, other: &DomainOnly<'_>) -> Ordering {
         other.cmp_hosts(self).reverse()
     }
     /// Read [`Wildcard::cmp_hosts`].
     #[inline]
     #[must_use]
     pub fn cmp_wildcard(&self, other: &Wildcard<'_>) -> Ordering {
         other.cmp_hosts(self).reverse()
     }
     /// Same as [`Hosts::cardinality`] except that a `NonZeroU8` is returned.
     ///
     /// The value is always 1.
     #[inline]
     #[must_use]
     pub const fn domain_count(&self) -> NonZeroU8 {
         ONE
     }
 }
 impl PartialEq<Hosts<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         self.domain == other.domain
     }
 }
 impl PartialEq<Hosts<'_>> for &Hosts<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&Hosts<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &&Hosts<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Adblock<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         other == self
     }
 }
 impl PartialEq<DomainOnly<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         other == self
     }
 }
 impl PartialEq<Wildcard<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         !other.proper_subdomains && self.domain == other.domain
     }
 }
 impl PartialEq<&Wildcard<'_>> for Hosts<'_> {
     #[inline]
     fn eq(&self, other: &&Wildcard<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Wildcard<'_>> for &Hosts<'_> {
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&Hosts<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &&Hosts<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Hosts<'_>> for &Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         **self == *other
     }
 }
 impl Eq for Hosts<'_> {}
 impl Hash for Hosts<'_> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.domain.hash(state);
     }
 }
 impl PartialOrd<Hosts<'_>> for Hosts<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Hosts<'_>) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 impl Ord for Hosts<'_> {
     /// Read [`Domain::cmp`].
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         self.domain.cmp(&other.domain)
     }
 }
 impl PartialOrd<Adblock<'_>> for Hosts<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Adblock<'_>) -> Option<Ordering> {
         Some(self.cmp_adblock(other))
     }
 }
 impl PartialOrd<DomainOnly<'_>> for Hosts<'_> {
     #[inline]
     fn partial_cmp(&self, other: &DomainOnly<'_>) -> Option<Ordering> {
         Some(self.cmp_domain_only(other))
     }
 }
 impl PartialOrd<Wildcard<'_>> for Hosts<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Wildcard<'_>) -> Option<Ordering> {
         Some(self.cmp_wildcard(other))
     }
 }
 impl Display for Hosts<'_> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         self.domain.fmt(f)
     }
 }
 impl<'a> Set for Hosts<'a> {
     type Elem = Domain<&'a str>;
     #[inline]
     fn bounded_cardinality(&self) -> BoundedCardinality {
         BoundedCardinality::from_biguint_exact(self.domain_count().get().into())
     }
     #[inline]
     fn cardinality(&self) -> Option<Cardinality> {
         Some(Cardinality::Finite(self.domain_count().get().into()))
     }
     #[inline]
     fn contains<Q>(&self, elem: &Q) -> bool
     where
         Q: Borrow<Self::Elem> + Eq + ?Sized,
     {
         self.domain == *elem.borrow()
     }
     #[inline]
     fn is_proper_subset(&self, _: &Self) -> bool {
         false
     }
     #[inline]
     fn is_subset(&self, val: &Self) -> bool {
         self == val
     }
 }
 impl SetOrd for Hosts<'_> {}
 impl<'a> Deref for Hosts<'a> {
     type Target = Domain<&'a str>;
     #[inline]
     fn deref(&self) -> &Self::Target {
         &self.domain
     }
 }
 impl<'a> ParsedDomain<'a> for Hosts<'a> {
     type Error = FirefoxDomainErr;
     #[expect(
         unsafe_code,
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "carefully verified use is correct"
     )]
     #[inline]
     fn parse_value<'b: 'a>(val: &'b str) -> Result<Value<'a, Self>, Self::Error> {
         let mut value = val.as_bytes().trim_ascii_start();
         value.first().map_or_else(
             || Ok(Value::Blank),
             |byt| {
                 if *byt == b'#' {
                     // SAFETY:
                     // `value` came from `val` with leading ASCII whitespace removed which is still valid UTF-8
                     // since the first byte is '#' or '$' the remaining bytes is still valid UTF-8.
                     let comment = unsafe { str::from_utf8_unchecked(&value[1..]) };
                     Ok(Value::Comment(comment))
                 } else {
                     value = value
                         .get(..3)
                         .ok_or(FirefoxDomainErr::InvalidHostsIP)
                         .and_then(|fst| {
                             if fst == b"::1" {
                                 Ok(&value[3..])
                             } else if &value[..2] == b"::" {
                                 Ok(&value[2..])
                             } else {
                                 value
                                     .get(..7)
                                     .ok_or(FirefoxDomainErr::InvalidHostsIP)
                                     .and_then(|fst2| {
                                         if fst2 == b"0.0.0.0" {
                                             Ok(&value[7..])
                                         } else {
                                             value
                                                 .get(..9)
                                                 .ok_or(FirefoxDomainErr::InvalidHostsIP)
                                                 .and_then(|fst3| {
                                                     if fst3 == b"127.0.0.1" {
                                                         Ok(&value[9..])
                                                     } else {
                                                         Err(FirefoxDomainErr::InvalidHostsIP)
                                                     }
                                                 })
                                         }
                                     })
                             }
                         })?;
                     let len = value.len();
                     value = value.trim_ascii_start();
                     if len == value.len() {
                         // There has to be at least one space or tab between the IP and domain.
                         Err(FirefoxDomainErr::InvalidHostsIP)
                     } else {
                         domain_icann_tld(
                             value[..value
                                 .iter()
                                 .try_fold(
                                     0,
                                     |i, byt2| if *byt2 == b'#' { Err(i) } else { Ok(i + 1) },
                                 )
                                 .unwrap_or_else(convert::identity)]
                                 .trim_ascii_end(),
                         )
                         .map(|domain| Value::Domain(Self { domain }))
                     }
                 }
             },
         )
     }
     #[inline]
     fn domain(&self) -> &Domain<&'a str> {
         &self.domain
     }
     #[inline]
     fn write_to_rpz<W: Write>(&self, action: RpzAction, mut writer: W) -> Result<(), Error> {
         write_rpz_line(&mut writer, self.domain(), action, false)
     }
 }
 /// Domain constructed from a
 /// [wildcard domain rule](https://pgl.yoyo.org/adservers/serverlist.php?hostformat=adblock&showintro=0&mimetype=plaintext).
 ///
 /// Specifically the domain must conform to the following extended regex:
 ///
 /// `^<ws>*(\*\.)?<domain><ws>*(#.*)?$`
 ///
 /// where `<domain>` conforms to a valid [`Domain`] based on [`ASCII_FIREFOX`], the TLD is either all letters
 /// or at least length five and begins with `xn--`, and `<ws>` is any sequence of
 /// [ASCII whitespace](https://infra.spec.whatwg.org/#ascii-whitespace).
 ///
 /// If `domain` begins with `*.`, then `domain` must have length less than 252.
 ///
 /// Comments are any lines that start with `#` (ignoring whitespace). Any in-line comments after a valid domain
 /// are ignored and will be parsed into a [`Value::Domain`].
 #[derive(Clone, Debug)]
 pub struct Wildcard<'a> {
     /// The `Domain`.
     domain: Domain<&'a str>,
     /// `true` iff `domain` represents all proper subdomains. Note that this does _not_ include `domain` itself.
     proper_subdomains: bool,
 }
 impl Wildcard<'_> {
     /// Returns `true` iff the contained [`Domain`] represents all proper subdomains. Note this does _not_
     /// include the `Domain` itself.
     #[inline]
     #[must_use]
     pub const fn is_proper_subdomains(&self) -> bool {
         self.proper_subdomains
     }
     /// Read [`Adblock::cmp_wildcard`].
     #[inline]
     #[must_use]
     pub fn cmp_adblock(&self, other: &Adblock<'_>) -> Ordering {
         other.cmp_wildcard(self).reverse()
     }
     /// Since `DomainOnly` and `Hosts` are treated the same, we have this helper function that can be used
     /// for both.
     #[must_use]
     fn cmp_dom(&self, other: &Domain<&str>) -> Ordering {
         match self.domain.cmp_by_domain_ordering(other) {
             DomainOrdering::Less => Ordering::Less,
             DomainOrdering::Shorter => {
                 if self.proper_subdomains {
                     Ordering::Greater
                 } else {
                     Ordering::Less
                 }
             }
             DomainOrdering::Equal => {
                 if self.proper_subdomains {
                     Ordering::Greater
                 } else {
                     Ordering::Equal
                 }
             }
             DomainOrdering::Longer | DomainOrdering::Greater => Ordering::Greater,
         }
     }
     /// The total order that is defined follows the following hierarchy:
     /// 1. Pairwise comparisons of each [`ascii_domain::dom::Label`] starting from the TLDs.
     /// 2. If 1. evaluates as not equivalent, then return the result.
     /// 3. If `self` represents a single `Domain` (i.e., `!self.is_proper_subdomains()`),
     ///    then return the comparison of label counts.
     /// 4. Return `self` is greater.
     ///
     /// For example, `com` `<` `example.com` `<` `*.example.com` `<` `*.com` `<` `net` `<` `example.net` `<` `*.example.net` `<` `*.net`.
     #[inline]
     #[must_use]
     pub fn cmp_domain_only(&self, other: &DomainOnly<'_>) -> Ordering {
         self.cmp_dom(&other.domain)
     }
     /// Read [`Wildcard::cmp_domain_only`].
     #[inline]
     #[must_use]
     pub fn cmp_hosts(&self, other: &Hosts<'_>) -> Ordering {
         self.cmp_dom(&other.domain)
     }
     /// Same as [`Wildcard::cardinality`] except that a `BigUint` is returned. Note the count does _not_ include
     /// the `Domain` itself when `self.is_proper_subdomains()`.
     ///
     /// `!self.is_proper_subdomains()` ⇔ `self.domain_count() == BigUint::new(vec![1])`.
     #[inline]
     #[must_use]
     pub fn domain_count(&self) -> BigUint {
         if self.proper_subdomains {
             proper_subdomain_count(&self.domain)
         } else {
             BigUint::new(vec![1])
         }
     }
 }
 impl PartialEq<Wildcard<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         self.domain == other.domain && self.proper_subdomains == other.proper_subdomains
     }
 }
 impl PartialEq<Wildcard<'_>> for &Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &Wildcard<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&Wildcard<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &&Wildcard<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Adblock<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &Adblock<'_>) -> bool {
         other == self
     }
 }
 impl PartialEq<DomainOnly<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &DomainOnly<'_>) -> bool {
         other == self
     }
 }
 impl PartialEq<Hosts<'_>> for Wildcard<'_> {
     #[inline]
     fn eq(&self, other: &Hosts<'_>) -> bool {
         other == self
     }
 }
 impl Eq for Wildcard<'_> {}
 impl Hash for Wildcard<'_> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.domain.hash(state);
     }
 }
 impl PartialOrd<Wildcard<'_>> for Wildcard<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Wildcard<'_>) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 impl Ord for Wildcard<'_> {
     /// The total order that is defined follows the following hierarchy:
     /// 1. Pairwise comparisons of each [`ascii_domain::dom::Label`] starting from the TLDs.
     /// 2. If 1. evaluates as not equivalent, then return the result.
     /// 3. If both domains represent a single `Domain`, then return the comparison
     ///    of label counts.
     /// 4. If one domain represents a single `Domain`, then return that that domain is less.
     /// 5. Return the inverse of the comparison of label counts.
     ///
     /// For example, `com` `<` `example.com` `<` `*.example.com` `<` `*.com` `<` `net` `<` `example.net` `<` `*.example.net` `<` `*.net`.
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         match self.domain.cmp_by_domain_ordering(&other.domain) {
             DomainOrdering::Less => Ordering::Less,
             DomainOrdering::Shorter => {
                 if self.proper_subdomains {
                     Ordering::Greater
                 } else {
                     Ordering::Less
                 }
             }
             DomainOrdering::Equal => {
                 if self.proper_subdomains {
                     if other.proper_subdomains {
                         Ordering::Equal
                     } else {
                         Ordering::Greater
                     }
                 } else if other.proper_subdomains {
                     Ordering::Less
                 } else {
                     Ordering::Equal
                 }
             }
             DomainOrdering::Longer => {
                 if self.proper_subdomains {
                     if other.proper_subdomains {
                         Ordering::Less
                     } else {
                         Ordering::Greater
                     }
                 } else if other.proper_subdomains {
                     Ordering::Less
                 } else {
                     Ordering::Greater
                 }
             }
             DomainOrdering::Greater => Ordering::Greater,
         }
     }
 }
 impl PartialOrd<Adblock<'_>> for Wildcard<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Adblock<'_>) -> Option<Ordering> {
         Some(self.cmp_adblock(other))
     }
 }
 impl PartialOrd<DomainOnly<'_>> for Wildcard<'_> {
     #[inline]
     fn partial_cmp(&self, other: &DomainOnly<'_>) -> Option<Ordering> {
         Some(self.cmp_domain_only(other))
     }
 }
 impl PartialOrd<Hosts<'_>> for Wildcard<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Hosts<'_>) -> Option<Ordering> {
         Some(self.cmp_hosts(other))
     }
 }
 impl Display for Wildcard<'_> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         write!(
             f,
             "{}{}",
             if self.proper_subdomains { "*." } else { "" },
             self.domain
         )
     }
 }
 impl<'a> Set for Wildcard<'a> {
     type Elem = Domain<&'a str>;
     #[inline]
     fn bounded_cardinality(&self) -> BoundedCardinality {
         BoundedCardinality::from_biguint_exact(self.domain_count())
     }
     #[inline]
     fn cardinality(&self) -> Option<Cardinality> {
         Some(Cardinality::Finite(self.domain_count()))
     }
     #[inline]
     fn contains<Q>(&self, elem: &Q) -> bool
     where
         Q: Borrow<Self::Elem> + Eq + ?Sized,
     {
         if self.proper_subdomains {
             self.domain.cmp_by_domain_ordering(elem.borrow()) == DomainOrdering::Shorter
         } else {
             self.domain == *elem.borrow()
         }
     }
     #[inline]
     fn is_proper_subset(&self, val: &Self) -> bool {
         // A single domain can never be a proper superset. Proper subdomains cannot be a proper superset if it
         // has more labels or the same number of labels as another domain. In all other cases, we need to
         // recursively check from the TLD that the labels are the same.
         val.proper_subdomains
             && val.domain.cmp_by_domain_ordering(&self.domain) == DomainOrdering::Shorter
     }
     #[inline]
     fn is_subset(&self, val: &Self) -> bool {
         self == val || self.is_proper_subset(val)
     }
 }
 impl SetOrd for Wildcard<'_> {}
 impl<'a> Deref for Wildcard<'a> {
     type Target = Domain<&'a str>;
     #[inline]
     fn deref(&self) -> &Self::Target {
         &self.domain
     }
 }
 impl<'a> ParsedDomain<'a> for Wildcard<'a> {
     type Error = FirefoxDomainErr;
     #[expect(
         unsafe_code,
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "need them all. care has been taken."
     )]
     #[inline]
     fn parse_value<'b: 'a>(val: &'b str) -> Result<Value<'a, Self>, Self::Error> {
         let value = val.as_bytes().trim_ascii_start();
         value.first().map_or_else(
             || Ok(Value::Blank),
             |byt| {
                 if *byt == b'#' {
                     // SAFETY:
                     // `value` came from `val` with leading ASCII whitespace removed which is still valid UTF-8
                     // since the first byte is '#' or '$' the remaining bytes is still valid UTF-8.
                     let comment = unsafe { str::from_utf8_unchecked(&value[1..]) };
                     Ok(Value::Comment(comment))
                 } else {
                     let (proper_subdomains, val2) = value.get(..2).map_or_else(
                         || (false, value),
                         |fst| {
                             if fst == b"*." {
                                 (true, &value[2..])
                             } else {
                                 (false, value)
                             }
                         },
                     );
                     domain_icann_tld(
                         val2[..val2
                             .iter()
                             .try_fold(0, |i, byt2| if *byt2 == b'#' { Err(i) } else { Ok(i + 1) })
                             .unwrap_or_else(convert::identity)]
                             .trim_ascii_end(),
                     )
                     .and_then(|domain| {
                         if proper_subdomains {
                             if domain.len().get() > 251 {
                                 Err(FirefoxDomainErr::InvalidWildcardDomain)
                             } else {
                                 Ok(Value::Domain(Self {
                                     domain,
                                     proper_subdomains: true,
                                 }))
                             }
                         } else {
                             Ok(Value::Domain(Self {
                                 domain,
                                 proper_subdomains,
                             }))
                         }
                     })
                 }
             },
         )
     }
     #[inline]
     fn domain(&self) -> &Domain<&'a str> {
         &self.domain
     }
     #[inline]
     fn write_to_rpz<W: Write>(&self, action: RpzAction, mut writer: W) -> Result<(), Error> {
         write_rpz_line(&mut writer, self.domain(), action, self.proper_subdomains)
     }
 }
 /// A [`Domain`] in a [response policy zone (RPZ)](https://en.wikipedia.org/wiki/Response_policy_zone) file.
 #[derive(Clone, Debug)]
 pub enum RpzDomain<'a> {
     /// An `Adblock` domain.
     Adblock(Adblock<'a>),
     /// A `DomainOnly` domain.
     DomainOnly(DomainOnly<'a>),
     /// A `Hosts` domain.
     Hosts(Hosts<'a>),
     /// A `Wildcard` domain.
     Wildcard(Wildcard<'a>),
 }
 impl RpzDomain<'_> {
     /// Returns `true` iff `self` represents a single [`Domain`].
     #[inline]
     #[must_use]
     pub const fn is_domain(&self) -> bool {
         match *self {
             Self::Adblock(ref dom) => !dom.subdomains,
             Self::DomainOnly(_) | Self::Hosts(_) => true,
             Self::Wildcard(ref dom) => !dom.proper_subdomains,
         }
     }
     /// Returns `true` iff `self` represents proper subdomains of the contained [`Domain`] (i.e.,
     /// is a [`Wildcard`] such that [`Wildcard::is_proper_subdomains`]).
     #[inline]
     #[must_use]
     pub const fn is_proper_subdomains(&self) -> bool {
         match *self {
             Self::Adblock(_) | Self::DomainOnly(_) | Self::Hosts(_) => false,
             Self::Wildcard(ref dom) => dom.proper_subdomains,
         }
     }
     /// Returns `true` iff `self` represents subdomains of the contained [`Domain`] (i.e., is an
     /// [`Adblock`] such that [`Adblock::is_subdomains`]).
     #[inline]
     #[must_use]
     pub const fn is_subdomains(&self) -> bool {
         match *self {
             Self::Adblock(ref dom) => dom.subdomains,
             Self::DomainOnly(_) | Self::Hosts(_) | Self::Wildcard(_) => false,
         }
     }
     /// Returns the count of [`Domain`]s represented by `self`. This function is the same as
     /// [`RpzDomain::cardinality`] except that it returns a `BigUint`.
     #[inline]
     #[must_use]
     pub fn domain_count(&self) -> BigUint {
         match *self {
             Self::Adblock(ref dom) => dom.domain_count(),
             Self::DomainOnly(ref dom) => dom.domain_count().get().into(),
             Self::Hosts(ref dom) => dom.domain_count().get().into(),
             Self::Wildcard(ref dom) => dom.domain_count(),
         }
     }
 }
 impl PartialEq<RpzDomain<'_>> for RpzDomain<'_> {
     #[inline]
     fn eq(&self, other: &RpzDomain<'_>) -> bool {
         match *self {
             Self::Adblock(ref dom) => match *other {
                 RpzDomain::Adblock(ref dom2) => dom == dom2,
                 RpzDomain::DomainOnly(ref dom2) => dom == dom2,
                 RpzDomain::Hosts(ref dom2) => dom == dom2,
                 RpzDomain::Wildcard(ref dom2) => dom == dom2,
             },
             Self::DomainOnly(ref dom) => match *other {
                 RpzDomain::Adblock(ref dom2) => dom == dom2,
                 RpzDomain::DomainOnly(ref dom2) => dom == dom2,
                 RpzDomain::Hosts(ref dom2) => dom == dom2,
                 RpzDomain::Wildcard(ref dom2) => dom == dom2,
             },
             Self::Hosts(ref dom) => match *other {
                 RpzDomain::Adblock(ref dom2) => dom == dom2,
                 RpzDomain::DomainOnly(ref dom2) => dom == dom2,
                 RpzDomain::Hosts(ref dom2) => dom == dom2,
                 RpzDomain::Wildcard(ref dom2) => dom == dom2,
             },
             Self::Wildcard(ref dom) => match *other {
                 RpzDomain::Adblock(ref dom2) => dom == dom2,
                 RpzDomain::DomainOnly(ref dom2) => dom == dom2,
                 RpzDomain::Hosts(ref dom2) => dom == dom2,
                 RpzDomain::Wildcard(ref dom2) => dom == dom2,
             },
         }
     }
 }
 impl PartialEq<RpzDomain<'_>> for &RpzDomain<'_> {
     #[inline]
     fn eq(&self, other: &RpzDomain<'_>) -> bool {
         **self == *other
     }
 }
 impl PartialEq<&RpzDomain<'_>> for RpzDomain<'_> {
     #[inline]
     fn eq(&self, other: &&RpzDomain<'_>) -> bool {
         *self == **other
     }
 }
 impl Eq for RpzDomain<'_> {}
 impl Hash for RpzDomain<'_> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.domain().hash(state);
     }
 }
 impl PartialOrd<RpzDomain<'_>> for RpzDomain<'_> {
     #[inline]
     fn partial_cmp(&self, other: &RpzDomain<'_>) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 impl Ord for RpzDomain<'_> {
     /// The total order that is defined follows the following hierarchy:
     /// 1. Pairwise comparisons of each [`ascii_domain::dom::Label`] starting from the TLDs.
     /// 2. If 1. evaluates as not equivalent, then return the result.
     /// 3. If both domains represent a single `Domain`, then return the comparison
     ///    of label counts.
     /// 4. If one domain represents a single `Domain`, then return that that domain is less.
     /// 5. If the label counts are the same and exactly one domain represents proper subdomains, the other domain is greater.
     /// 6. Return the inverse of the comparison of label counts.
     ///
     /// For example the following is a sequence of domains in
     /// ascending order:
     ///
     /// `bar.com`, `www.bar.com`, `*.www.bar.com`, `||www.bar.com`, `*.bar.com`, `||bar.com`, `example.com`, `www.example.com`, `*.www.example.com`, `||www.example.com`, `*.example.com`, `||example.com`, `foo.com`, `www.foo.com`, `*.foo.com`, `*.com`, `example.net`, `*.net`.
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         match *self {
             Self::Adblock(ref dom) => match *other {
                 Self::Adblock(ref dom2) => dom.cmp(dom2),
                 Self::DomainOnly(ref dom2) => dom.cmp_domain_only(dom2),
                 Self::Hosts(ref dom2) => dom.cmp_hosts(dom2),
                 Self::Wildcard(ref dom2) => dom.cmp_wildcard(dom2),
             },
             Self::DomainOnly(ref dom) => match *other {
                 Self::Adblock(ref dom2) => dom.cmp_adblock(dom2),
                 Self::DomainOnly(ref dom2) => dom.cmp(dom2),
                 Self::Hosts(ref dom2) => dom.cmp_hosts(dom2),
                 Self::Wildcard(ref dom2) => dom.cmp_wildcard(dom2),
             },
             Self::Hosts(ref dom) => match *other {
                 Self::Adblock(ref dom2) => dom.cmp_adblock(dom2),
                 Self::DomainOnly(ref dom2) => dom.cmp_domain_only(dom2),
                 Self::Hosts(ref dom2) => dom.cmp(dom2),
                 Self::Wildcard(ref dom2) => dom.cmp_wildcard(dom2),
             },
             Self::Wildcard(ref dom) => match *other {
                 Self::Adblock(ref dom2) => dom.cmp_adblock(dom2),
                 Self::DomainOnly(ref dom2) => dom.cmp_domain_only(dom2),
                 Self::Hosts(ref dom2) => dom.cmp_hosts(dom2),
                 Self::Wildcard(ref dom2) => dom.cmp(dom2),
             },
         }
     }
 }
 impl Display for RpzDomain<'_> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Adblock(ref dom) => dom.fmt(f),
             Self::DomainOnly(ref dom) => dom.fmt(f),
             Self::Hosts(ref dom) => dom.fmt(f),
             Self::Wildcard(ref dom) => dom.fmt(f),
         }
     }
 }
 impl<'a> Set for RpzDomain<'a> {
     type Elem = Domain<&'a str>;
     #[inline]
     fn bounded_cardinality(&self) -> BoundedCardinality {
         BoundedCardinality::from_biguint_exact(self.domain_count())
     }
     #[inline]
     fn cardinality(&self) -> Option<Cardinality> {
         Some(Cardinality::Finite(self.domain_count()))
     }
     #[inline]
     fn contains<Q>(&self, elem: &Q) -> bool
     where
         Q: Borrow<Self::Elem> + Eq + ?Sized,
     {
         match *self {
             Self::Adblock(ref dom) => dom.contains(elem),
             Self::DomainOnly(ref dom) => dom.contains(elem),
             Self::Hosts(ref dom) => dom.contains(elem),
             Self::Wildcard(ref dom) => dom.contains(elem),
         }
     }
     #[inline]
     fn is_proper_subset(&self, val: &Self) -> bool {
         match *val {
             Self::Adblock(ref dom) => {
                 dom.subdomains
                     && match *self {
                         Self::Adblock(ref dom2) => {
                             dom.domain.cmp_by_domain_ordering(&dom2.domain)
                                 == DomainOrdering::Shorter
                         }
                         Self::DomainOnly(ref dom2) => matches!(
                             dom.domain.cmp_by_domain_ordering(&dom2.domain),
                             DomainOrdering::Shorter | DomainOrdering::Equal
                         ),
                         Self::Hosts(ref dom2) => matches!(
                             dom.domain.cmp_by_domain_ordering(&dom2.domain),
                             DomainOrdering::Shorter | DomainOrdering::Equal
                         ),
                         Self::Wildcard(ref dom2) => matches!(
                             dom.domain.cmp_by_domain_ordering(&dom2.domain),
                             DomainOrdering::Shorter | DomainOrdering::Equal
                         ),
                     }
             }
             Self::DomainOnly(_) | Self::Hosts(_) => false,
             Self::Wildcard(ref dom) => {
                 dom.proper_subdomains
                     && match *self {
                         Self::Adblock(ref dom2) => {
                             dom.domain.cmp_by_domain_ordering(&dom2.domain)
                                 == DomainOrdering::Shorter
                         }
                         Self::DomainOnly(ref dom2) => {
                             dom.domain.cmp_by_domain_ordering(&dom2.domain)
                                 == DomainOrdering::Shorter
                         }
                         Self::Hosts(ref dom2) => {
                             dom.domain.cmp_by_domain_ordering(&dom2.domain)
                                 == DomainOrdering::Shorter
                         }
                         Self::Wildcard(ref dom2) => {
                             dom.domain.cmp_by_domain_ordering(&dom2.domain)
                                 == DomainOrdering::Shorter
                         }
                     }
             }
         }
     }
     #[inline]
     fn is_subset(&self, val: &Self) -> bool {
         self == val || self.is_proper_subset(val)
     }
 }
 impl SetOrd for RpzDomain<'_> {}
 impl<'a> Deref for RpzDomain<'a> {
     type Target = Domain<&'a str>;
     #[inline]
     fn deref(&self) -> &Self::Target {
         match *self {
             Self::Adblock(ref dom) => &dom.domain,
             Self::DomainOnly(ref dom) => &dom.domain,
             Self::Hosts(ref dom) => &dom.domain,
             Self::Wildcard(ref dom) => &dom.domain,
         }
     }
 }
 impl<'a: 'b, 'b> From<Adblock<'a>> for RpzDomain<'b> {
     #[inline]
     fn from(value: Adblock<'a>) -> Self {
         Self::Adblock(value)
     }
 }
 impl<'a: 'b, 'b> From<DomainOnly<'a>> for RpzDomain<'b> {
     #[inline]
     fn from(value: DomainOnly<'a>) -> Self {
         Self::DomainOnly(value)
     }
 }
 impl<'a: 'b, 'b> From<Hosts<'a>> for RpzDomain<'b> {
     #[inline]
     fn from(value: Hosts<'a>) -> Self {
         Self::Hosts(value)
     }
 }
 impl<'a: 'b, 'b> From<Wildcard<'a>> for RpzDomain<'b> {
     #[inline]
     fn from(value: Wildcard<'a>) -> Self {
         Self::Wildcard(value)
     }
 }
 impl<'a> ParsedDomain<'a> for RpzDomain<'a> {
     type Error = FirefoxDomainErr;
     #[inline]
     fn parse_value<'b: 'a>(val: &'b str) -> Result<Value<'a, Self>, Self::Error> {
         DomainOnly::parse_value(val).map_or_else(
             |_| {
                 Hosts::parse_value(val).map_or_else(
                     |_| {
                         Wildcard::parse_value(val).map_or_else(
                             |_| {
                                 Adblock::parse_value(val).map(|value| match value {
                                     Value::Domain(dom) => Value::Domain(Self::Adblock(dom)),
                                     Value::Comment(com) => Value::Comment(com),
                                     Value::Blank => Value::Blank,
                                 })
                             },
                             |value| {
                                 Ok(match value {
                                     Value::Domain(dom) => Value::Domain(Self::Wildcard(dom)),
                                     Value::Comment(com) => Value::Comment(com),
                                     Value::Blank => Value::Blank,
                                 })
                             },
                         )
                     },
                     |value| {
                         Ok(match value {
                             Value::Domain(dom) => Value::Domain(Self::Hosts(dom)),
                             Value::Comment(com) => Value::Comment(com),
                             Value::Blank => Value::Blank,
                         })
                     },
                 )
             },
             |value| {
                 Ok(match value {
                     Value::Domain(dom) => Value::Domain(Self::DomainOnly(dom)),
                     Value::Comment(com) => Value::Comment(com),
                     Value::Blank => Value::Blank,
                 })
             },
         )
     }
     #[inline]
     fn domain(&self) -> &Domain<&'a str> {
         match *self {
             Self::Adblock(ref dom) => &dom.domain,
             Self::DomainOnly(ref dom) => &dom.domain,
             Self::Hosts(ref dom) => &dom.domain,
             Self::Wildcard(ref dom) => &dom.domain,
         }
     }
     #[inline]
     fn write_to_rpz<W: Write>(&self, action: RpzAction, writer: W) -> Result<(), Error> {
         match *self {
             Self::Adblock(ref dom) => dom.write_to_rpz(action, writer),
             Self::DomainOnly(ref dom) => dom.write_to_rpz(action, writer),
             Self::Hosts(ref dom) => dom.write_to_rpz(action, writer),
             Self::Wildcard(ref dom) => dom.write_to_rpz(action, writer),
         }
     }
 }