ascii_domain

dom.rs (57813B)

---

 extern crate alloc;
 #[cfg(test)]
 /// Unit tests.
 mod tests;
 use crate::char_set::{ASCII_HYPHEN_DIGITS_LETTERS, AllowedAscii};
 use alloc::{string::String, vec::Vec};
 use core::{
     borrow::Borrow,
     cmp::Ordering,
     convert,
     error::Error,
     fmt::{self, Display, Formatter},
     hash::{Hash, Hasher},
     iter::FusedIterator,
     num::NonZeroU8,
     ops::Deref,
     str,
 };
 /// The `AllowedAscii` used by `Rfc1123Domain`.
 static RFC_CHARS: &AllowedAscii<[u8; 63]> = &ASCII_HYPHEN_DIGITS_LETTERS;
 /// Returned by [`Domain::cmp_by_domain_ordering`].
 ///
 /// It is more informative than [`Ordering`] in that it
 /// distinguishes between a `Domain` that is greater than another `Domain` due to a [`Label`] being greater
 /// from a `Domain` that has the same `Label`s as another but simply more.
 ///
 /// Another way to view this is that [`Self::Shorter`] is "closer" to being [`Self::Equal`] than [`Self::Less`]
 /// since the `Domain`s are still part of the same branch in the DNS hierarchy. Ditto for [`Self::Longer`].
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum DomainOrdering {
     /// The `Domain` is less than another since a `Label` was less.
     Less,
     /// The `Domain` is less than other but only because it had fewer `Label`s.
     Shorter,
     /// The `Domain` is equal to another.
     Equal,
     /// The `Domain` is greater than another but only because it had more `Label`s.
     Longer,
     /// The `Domain` is greater than another since a `Label` was greater.
     Greater,
 }
 impl Display for DomainOrdering {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Less => f.write_str("less since a label was less"),
             Self::Shorter => f.write_str("less since there were fewer labels"),
             Self::Equal => f.write_str("equal"),
             Self::Longer => f.write_str("greater since there were more labels"),
             Self::Greater => f.write_str("greater since a label was greater"),
         }
     }
 }
 impl From<DomainOrdering> for Ordering {
     #[inline]
     fn from(value: DomainOrdering) -> Self {
         match value {
             DomainOrdering::Less | DomainOrdering::Shorter => Self::Less,
             DomainOrdering::Equal => Self::Equal,
             DomainOrdering::Longer | DomainOrdering::Greater => Self::Greater,
         }
     }
 }
 /// A domain that consists of at least one [`Label`] with each `Label` only containing the ASCII `u8`s in
 /// the [`AllowedAscii`] passed to [`Self::try_from_bytes`].
 ///
 /// The total length of a `Domain` is at most
 /// 253 bytes[^note] in length including the `b'.'` separator. The trailing `b'.'`, if one exists, is always
 /// ignored.
 ///
 /// This is more restrictive than what a domain is allowed to be per the
 /// [Domain Name System (DNS)](https://www.rfc-editor.org/rfc/rfc2181) since all octets/`u8`s are allowed in a
 /// label. Additionally there is no way to represent the root domain.
 ///
 /// Last, ASCII uppercase letters are treated as lowercase; however for better comparison performance
 /// that doesn't lead to intermediate memory allocations, two `Domain`s should consist entirely of the same
 /// case.
 ///
 /// [^note]: It is a common misconception that the max length of a domain is 255, but that is only true for
 ///          domains in _wire_ format. In representation format, which `Domain` can be thought of when only visible
 ///          ASCII bytes are used, the max length is 253 when the last byte is not `b'.'`; otherwise the max length is
 ///          254. This is due to the fact that there is no way to explicitly represent the root label which in wire format
 ///          contributes one byte due to each label being preceded by the octet that represents its length.
 ///
 /// Note this only contains `T`, so this is allocation-free and the same size as `T`.
 #[derive(Clone, Copy, Debug)]
 pub struct Domain<T> {
     /// The domain value. `value.as_ref().len()` is guaranteed to have length between 1 and 253 when the last `u8`
     /// is not `b'.'`; otherwise the length is between 2 and 254.
     /// Guaranteed to only contain `b'.'` and the ASCII `u8`s in `allowed_ascii`.
     value: T,
 }
 impl<T> Domain<T> {
     /// A reference to the contained `T`.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(*Domain::try_from_bytes("example.com.", &ASCII_LOWERCASE).unwrap().as_inner() == "example.com.");
     /// ```
     #[inline]
     pub const fn as_inner(&self) -> &T {
         &self.value
     }
     /// Same as [`Self::as_inner`] except `self` is consumed.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com.", &ASCII_LOWERCASE).unwrap().into_inner() == "example.com.");
     /// ```
     #[inline]
     pub fn into_inner(self) -> T {
         self.value
     }
 }
 impl<T: AsRef<[u8]>> Domain<T> {
     /// Returns `true` iff the domain contains a trailing `b'.'`.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com.", &ASCII_LOWERCASE).unwrap().contains_trailing_dot());
     /// ```
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "comments explain their correctness"
     )]
     #[inline]
     pub fn contains_trailing_dot(&self) -> bool {
         let bytes = self.value.as_ref();
         // This won't underflow or `panic` since `Domain`s are not empty.
         bytes[bytes.len() - 1] == b'.'
     }
     /// The domain without a trailing `b'.'` if there was one.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LETTERS};
     /// assert!(Domain::try_from_bytes("Example.com.", &ASCII_LETTERS).unwrap().as_str() == "Example.com");
     /// ```
     #[inline]
     pub fn as_str(&self) -> &str {
         <&str>::from(Domain::<&str>::from(Domain::<&[u8]>::from(self)))
     }
     /// The domain without a trailing `b'.'` if there was one.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LETTERS};
     /// assert!(Domain::try_from_bytes("Example.com", &ASCII_LETTERS).unwrap().as_bytes() == b"Example.com");
     /// ```
     #[inline]
     pub fn as_bytes(&self) -> &[u8] {
         <&[u8]>::from(Domain::<&[u8]>::from(self))
     }
     /// The length of the `Domain`. This does _not_ include the trailing `b'.'` if there was one.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com.", &ASCII_LOWERCASE).unwrap().len().get() == 11);
     /// ```
     #[expect(
         unsafe_code,
         reason = "we enforce nonzero lengths, so NonZeroU8::new_unchecked is fine"
     )]
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::as_conversions,
         clippy::cast_possible_truncation,
         reason = "comments justify their correctness"
     )]
     #[inline]
     pub fn len(&self) -> NonZeroU8 {
         // No fear of underflow since the length of `value` is at least 1 _not including_ the
         // trailing `b'.'` if there was one.
         // `true as usize` is guaranteed to be 1 and `false as usize` is guaranteed to be 0.
         // No fear of truncation either since the length is guaranteed to be less than 255.
         // `Domain` is immutable ensuring such invariants are kept.
         let len = (self.value.as_ref().len() - usize::from(self.contains_trailing_dot())) as u8;
         // SAFETY:
         // The only way to construct a `Domain` is via `try_from_bytes` which ensures `len` is
         // is at least 1.
         unsafe { NonZeroU8::new_unchecked(len) }
     }
     /// Function that transforms `v` into a `Domain` by only allowing [`Label`]s to contain the ASCII `u8`s in
     /// `allowed_ascii`. A trailing `b'.'` is ignored.
     ///
     /// Note that while ASCII uppercase is treated as ASCII lowercase, `allowed_ascii` MUST still contain
     /// each ASCII `u8` (e.g., if `!allowed_ascii.contains(b'A')`, then `b'A'` is not allowed even if
     /// `allowed_ascii.contains(b'a')`).
     ///
     /// # Examples
     ///
     /// ```
     /// use ascii_domain::{dom::{Domain, DomainErr}, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com", &ASCII_LOWERCASE).is_ok());
     /// assert!(Domain::try_from_bytes("exam2ple.com", &ASCII_LOWERCASE).map_or_else(|err| err == DomainErr::InvalidByte(b'2'), |_| false));
     /// ```
     ///
     /// # Errors
     ///
     /// Returns [`DomainErr`] iff `v.as_ref()` is an invalid `Domain`.
     #[expect(
         clippy::arithmetic_side_effects,
         reason = "comment justifies its correctness"
     )]
     #[inline]
     pub fn try_from_bytes<T2: AsRef<[u8]>>(
         v: T,
         allowed_ascii: &AllowedAscii<T2>,
     ) -> Result<Self, DomainErr> {
         let val = v.as_ref();
         let value = val
             .split_last()
             .ok_or(DomainErr::Empty)
             .and_then(|(lst, rem)| {
                 if *lst == b'.' {
                     rem.split_last()
                         .ok_or(DomainErr::RootDomain)
                         .and_then(|(lst_2, _)| {
                             if *lst_2 == b'.' {
                                 Err(DomainErr::EmptyLabel)
                             } else {
                                 Ok(rem)
                             }
                         })
                 } else {
                     Ok(val)
                 }
             })?;
         if value.len() > 253 {
             Err(DomainErr::LenExceeds253(value.len()))
         } else {
             value
                 .iter()
                 .try_fold(0, |label_len, byt| {
                     let b = *byt;
                     if b == b'.' {
                         NonZeroU8::new(label_len).map_or(Err(DomainErr::EmptyLabel), |_| Ok(0))
                     } else if !allowed_ascii.contains(b) {
                         Err(DomainErr::InvalidByte(b))
                     } else if label_len == 63 {
                         Err(DomainErr::LabelLenExceeds63)
                     } else {
                         // This is less than 63 due to the above check, so this won't overflow;
                         Ok(label_len + 1)
                     }
                 })
                 .map(|_| Self { value: v })
         }
     }
     /// Returns an [`Iterator`] of [`Label`]s without consuming the `Domain`.
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com", &ASCII_LOWERCASE).unwrap().into_iter().next().unwrap().as_str() == "com");
     /// ```
     #[inline]
     pub fn iter(&self) -> LabelIter<'_> {
         LabelIter {
             domain: self.as_bytes(),
         }
     }
     /// Returns `true` iff `self` and `right` are part of the same branch in the DNS hierarchy.
     ///
     /// For example `www.example.com` and `example.com` are in the `same_branch`, but `example.com` and
     /// `foo.com` are not.
     ///
     /// Note that trailing `b'.'`s are ignored and ASCII uppercase and lowercase are treated the same.
     ///
     /// # Examples
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::{ASCII_LETTERS, ASCII_LOWERCASE}};
     /// let dom1 = Domain::try_from_bytes("Example.com", &ASCII_LETTERS).unwrap();
     /// let dom2 = Domain::try_from_bytes("www.example.com", &ASCII_LOWERCASE).unwrap();
     /// assert!(dom1.same_branch(&dom2));
     /// let dom3 = Domain::try_from_bytes("foo.com", &ASCII_LOWERCASE).unwrap();
     /// assert!(!dom1.same_branch(&dom3));
     /// ```
     #[inline]
     pub fn same_branch<T2: AsRef<[u8]>>(&self, right: &Domain<T2>) -> bool {
         // Faster to check the values as bytes and not iterate each `Label`.
         if self == right {
             true
         } else {
             self.iter()
                 .zip(right)
                 .try_fold(
                     (),
                     |(), (label, label2)| if label == label2 { Ok(()) } else { Err(()) },
                 )
                 .is_ok_and(|()| true)
         }
     }
     /// Same as [`Self::cmp_doms`] except returns [`DomainOrdering::Longer`] iff `self > right` due solely
     /// to having more [`Label`]s and [`DomainOrdering::Shorter`] iff `self < right` due solely to having
     /// fewer `Label`s.
     ///
     /// For example `example.com` < `www.example.com` and `bar.com` < `www.example.com`; but with this function,
     /// `example.com` is [`DomainOrdering::Shorter`] than `www.example.com` and `www.example.com` is
     /// [`DomainOrdering::Longer`] than `example.com`; while `bar.com` is [`DomainOrdering::Less`] than
     /// `www.example.com` and `www.example.com` is [`DomainOrdering::Greater`] than `bar.com`.
     ///
     /// In other words `DomainOrdering::Shorter` implies `Ordering::Less` and `DomainOrdering::Longer` implies
     /// `Ordering::Greater` with additional information pertaining to the quantity of `Label`s.
     ///
     /// # Examples
     ///
     /// ```
     /// use ascii_domain::{dom::{Domain, DomainOrdering}, char_set::{ASCII_LETTERS, ASCII_LOWERCASE}};
     /// let dom1 = Domain::try_from_bytes("Example.com", &ASCII_LETTERS).unwrap();
     /// assert!(matches!(dom1.cmp_by_domain_ordering(&dom1), DomainOrdering::Equal));
     /// let dom2 = Domain::try_from_bytes("www.example.com", &ASCII_LOWERCASE).unwrap();
     /// assert!(matches!(dom1.cmp_by_domain_ordering(&dom2), DomainOrdering::Shorter));
     /// assert!(matches!(dom2.cmp_by_domain_ordering(&dom1), DomainOrdering::Longer));
     /// let dom3 = Domain::try_from_bytes("foo.com", &ASCII_LOWERCASE).unwrap();
     /// assert!(matches!(dom1.cmp_by_domain_ordering(&dom3), DomainOrdering::Less));
     /// assert!(matches!(dom3.cmp_by_domain_ordering(&dom1), DomainOrdering::Greater));
     /// ```
     #[inline]
     pub fn cmp_by_domain_ordering<T2: AsRef<[u8]>>(&self, right: &Domain<T2>) -> DomainOrdering {
         // Faster to compare the entire value when we can instead each `Label`.
         if self == right {
             DomainOrdering::Equal
         } else {
             let mut right_iter = right.iter();
             self.iter()
                 .try_fold(false, |_, label| {
                     right_iter
                         .next()
                         .map_or(Ok(true), |label2| match label.cmp(&label2) {
                             Ordering::Less => Err(DomainOrdering::Less),
                             Ordering::Equal => Ok(false),
                             Ordering::Greater => Err(DomainOrdering::Greater),
                         })
                 })
                 .map_or_else(convert::identity, |flag| {
                     // We iterate `self` before `right`, so `flag` is `true` iff `right`
                     // has fewer `Label`s than `self`.
                     if flag {
                         DomainOrdering::Longer
                     } else {
                         // `self` has as many or fewer `Label`s than `right`; however if it had as many
                         // `Label`s as `right`, then all `Label`s are the same which is impossible since
                         // we already checked if `self == right`.
                         DomainOrdering::Shorter
                     }
                 })
         }
     }
     /// The total order that is defined follows the following hierarchy:
     /// 1. Pairwise comparisons of each [`Label`] starting from the TLDs.
     /// 2. If 1. evaluates as not equivalent, then return the result.
     /// 3. Return the comparison of `Label` counts.
     ///
     /// For example, `com` < `example.com` < `net` < `example.net`.
     ///
     /// This is the same as the [canonical DNS name order](https://datatracker.ietf.org/doc/html/rfc4034#section-6.1).
     /// ASCII uppercase is treated as ASCII lowercase and trailing `b'.'`s are ignored.
     /// The [`AllowedAscii`]s in the `Domain`s are ignored.
     ///
     /// # Examples
     ///
     /// ```
     /// use core::cmp::Ordering;
     /// use ascii_domain::{dom::Domain, char_set::{ASCII_LETTERS, ASCII_LOWERCASE}};
     /// let dom1 = Domain::try_from_bytes("Example.com", &ASCII_LETTERS).unwrap();
     /// assert!(matches!(dom1.cmp_doms(&dom1), Ordering::Equal));
     /// let dom2 = Domain::try_from_bytes("www.example.com", &ASCII_LOWERCASE).unwrap();
     /// assert!(matches!(dom1.cmp_doms(&dom2), Ordering::Less));
     /// assert!(matches!(dom2.cmp_doms(&dom1), Ordering::Greater));
     /// let dom3 = Domain::try_from_bytes("foo.com", &ASCII_LOWERCASE).unwrap();
     /// assert!(matches!(dom1.cmp_doms(&dom3), Ordering::Less));
     /// assert!(matches!(dom3.cmp_doms(&dom1), Ordering::Greater));
     /// ```
     #[inline]
     pub fn cmp_doms<T2: AsRef<[u8]>>(&self, right: &Domain<T2>) -> Ordering {
         self.cmp_by_domain_ordering(right).into()
     }
     /// Returns the first `Label`.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com", &ASCII_LOWERCASE).unwrap().first_label().as_str() == "example");
     /// ```
     #[expect(clippy::unreachable, reason = "bug in code, so we want to crash")]
     #[inline]
     pub fn first_label(&self) -> Label<'_> {
         self.iter()
             .next_back()
             .unwrap_or_else(|| unreachable!("there is a bug in Domain::try_from_bytes"))
     }
     /// Returns the last `Label` (i.e., the TLD).
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com", &ASCII_LOWERCASE).unwrap().tld().as_str() == "com");
     /// ```
     #[expect(clippy::unreachable, reason = "bug in code, so we want to crash")]
     #[inline]
     pub fn tld(&self) -> Label<'_> {
         self.iter()
             .next()
             .unwrap_or_else(|| unreachable!("there is a bug in Domain::try_from_bytes"))
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<Domain<T>> for Domain<T2> {
     /// Ignores the provided [`AllowedAscii`] and simply compares the two `Domain`s as [`Label`]s
     /// of bytes. Note uppercase ASCII is treated as lowercase ASCII and trailing `b'.'`s are ignored.
     #[inline]
     fn eq(&self, other: &Domain<T>) -> bool {
         self.as_bytes().eq_ignore_ascii_case(other.as_bytes())
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<&Domain<T>> for Domain<T2> {
     #[inline]
     fn eq(&self, other: &&Domain<T>) -> bool {
         *self == **other
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<Domain<T>> for &Domain<T2> {
     #[inline]
     fn eq(&self, other: &Domain<T>) -> bool {
         **self == *other
     }
 }
 impl<T: AsRef<[u8]>> Eq for Domain<T> {}
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialOrd<Domain<T>> for Domain<T2> {
     /// Consult [`Self::cmp_doms`].
     #[inline]
     fn partial_cmp(&self, other: &Domain<T>) -> Option<Ordering> {
         Some(self.cmp_doms(other))
     }
 }
 impl<T: AsRef<[u8]>> Ord for Domain<T> {
     /// Consult [`Self::cmp_doms`].
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         self.cmp_doms(other)
     }
 }
 impl<T: AsRef<[u8]>> Hash for Domain<T> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.as_bytes().to_ascii_lowercase().hash(state);
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> TryFrom<(T, &AllowedAscii<T2>)> for Domain<T> {
     type Error = DomainErr;
     #[inline]
     fn try_from(value: (T, &AllowedAscii<T2>)) -> Result<Self, Self::Error> {
         Self::try_from_bytes(value.0, value.1)
     }
 }
 impl<T: AsRef<[u8]>> Display for Domain<T> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str(self)
     }
 }
 impl<T: AsRef<[u8]>> AsRef<str> for Domain<T> {
     #[inline]
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 impl<T: AsRef<[u8]>> AsRef<[u8]> for Domain<T> {
     #[inline]
     fn as_ref(&self) -> &[u8] {
         self.as_bytes()
     }
 }
 impl<T: AsRef<[u8]>> Deref for Domain<T> {
     type Target = str;
     #[inline]
     fn deref(&self) -> &Self::Target {
         self.as_str()
     }
 }
 impl From<Domain<Vec<u8>>> for Domain<String> {
     #[expect(
         unsafe_code,
         reason = "we enforce ASCII, so String::from_utf8_unchecked is fine"
     )]
     #[inline]
     fn from(value: Domain<Vec<u8>>) -> Self {
         // SAFETY:
         // We only allow ASCII, so this is fine.
         let val = unsafe { String::from_utf8_unchecked(value.value) };
         Self { value: val }
     }
 }
 impl<'a: 'b, 'b, T: AsRef<[u8]>> From<&'a Domain<T>> for Domain<&'b [u8]> {
     #[inline]
     fn from(value: &'a Domain<T>) -> Self {
         Self {
             value: value.value.as_ref(),
         }
     }
 }
 impl<'a: 'b, 'b, T: AsRef<str>> From<&'a Domain<T>> for Domain<&'b str> {
     #[inline]
     fn from(value: &'a Domain<T>) -> Self {
         Self {
             value: value.value.as_ref(),
         }
     }
 }
 impl From<Domain<String>> for Domain<Vec<u8>> {
     #[inline]
     fn from(value: Domain<String>) -> Self {
         Self {
             value: value.value.into_bytes(),
         }
     }
 }
 impl<'a: 'b, 'b> From<Domain<&'a [u8]>> for Domain<&'b str> {
     #[expect(
         unsafe_code,
         reason = "we enforce ASCII, so str::from_utf8_unchecked is fine"
     )]
     #[inline]
     fn from(value: Domain<&'a [u8]>) -> Self {
         // SAFETY:
         // We only allow ASCII, so this is fine.
         let val = unsafe { str::from_utf8_unchecked(value.value) };
         Self { value: val }
     }
 }
 impl<'a: 'b, 'b> From<Domain<&'a str>> for Domain<&'b [u8]> {
     #[inline]
     fn from(value: Domain<&'a str>) -> Self {
         Self {
             value: value.value.as_bytes(),
         }
     }
 }
 impl From<Domain<Self>> for String {
     /// Returns the contained `String` _without_ a trailing `'.'` if there was one.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LETTERS};
     /// assert!(String::from(Domain::try_from_bytes(String::from("Example.com."), &ASCII_LETTERS).unwrap()).as_str() == "Example.com");
     /// ```
     #[inline]
     fn from(value: Domain<Self>) -> Self {
         if value.contains_trailing_dot() {
             let mut val = value.value;
             _ = val.pop();
             val
         } else {
             value.value
         }
     }
 }
 impl<'a: 'b, 'b> From<Domain<&'a str>> for &'b str {
     /// Returns the contained `str` _without_ a trailing `'.'` if there was one.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LETTERS};
     /// assert!(<&str>::from(Domain::try_from_bytes("Example.com.", &ASCII_LETTERS).unwrap()) == "Example.com");
     /// ```
     #[expect(
         unsafe_code,
         reason = "we enforce ASCII, so str::from_utf8_unchecked is fine"
     )]
     #[expect(clippy::indexing_slicing, reason = "comment justifies its correctness")]
     #[inline]
     fn from(value: Domain<&'a str>) -> Self {
         // Indexing won't `panic` since `value.len()` is at most as long as `value.value`.
         let utf8 = &value.value.as_bytes()[..value.len().get().into()];
         // SAFETY:
         // Only ASCII is allowed, so this is fine.
         unsafe { str::from_utf8_unchecked(utf8) }
     }
 }
 impl From<Domain<Self>> for Vec<u8> {
     /// Returns the contained `Vec` _without_ a trailing `b'.'` if there was one.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LETTERS};
     /// assert!(Vec::from(Domain::try_from_bytes(vec![b'F', b'o', b'o', b'.', b'c', b'o', b'm'], &ASCII_LETTERS).unwrap()).as_slice() == b"Foo.com");
     /// ```
     #[inline]
     fn from(value: Domain<Self>) -> Self {
         if value.contains_trailing_dot() {
             let mut val = value.value;
             _ = val.pop();
             val
         } else {
             value.value
         }
     }
 }
 impl<'a: 'b, 'b> From<Domain<&'a [u8]>> for &'b [u8] {
     /// Returns the contained slice _without_ a trailing `b'.'` if there was one.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LETTERS};
     /// assert!(<&[u8]>::from(Domain::try_from_bytes(b"Example.com.".as_slice(), &ASCII_LETTERS).unwrap()) == b"Example.com");
     /// ```
     #[expect(clippy::indexing_slicing, reason = "comment justifies its correctness")]
     #[inline]
     fn from(value: Domain<&'a [u8]>) -> Self {
         // Indexing won't `panic` since `value.len()` is at most as long as `value.value`.
         &value.value[..value.len().get().into()]
     }
 }
 /// Error returned from [`Domain::try_from_bytes`].
 #[expect(variant_size_differences, reason = "usize is fine in size")]
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum DomainErr {
     /// The domain was empty.
     Empty,
     /// The domain was the root domain that is to say it was the domain that only contained the root
     /// zone (i.e., `b'.'`).
     RootDomain,
     /// The length of the domain was greater than 253 not counting a terminating `b'.'` if there was one.
     LenExceeds253(usize),
     /// The domain contained at least one empty label.
     EmptyLabel,
     /// The domain contained at least one label whose length exceeded 63.
     LabelLenExceeds63,
     /// The domain contained an invalid byte value.
     InvalidByte(u8),
 }
 impl Display for DomainErr {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::Empty => f.write_str("domain is empty"),
             Self::RootDomain => f.write_str("domain is the root domain"),
             Self::LenExceeds253(len) => write!(
                 f,
                 "domain has length {len} which is greater than the max length of 253"
             ),
             Self::EmptyLabel => f.write_str("domain has an empty label"),
             Self::LabelLenExceeds63 => {
                 f.write_str("domain has a label that exceeds the max length of 63")
             }
             Self::InvalidByte(byt) => {
                 write!(f, "domain has a label with the invalid byte value {byt}")
             }
         }
     }
 }
 impl Error for DomainErr {}
 /// A label of a [`Domain`]. The total length of a `Label` is inclusively between 1 and 63.
 #[derive(Clone, Copy, Debug)]
 pub struct Label<'a> {
     /// The label value.
     value: &'a str,
 }
 impl<'a> Label<'a> {
     /// The label.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com", &ASCII_LOWERCASE).unwrap().into_iter().next().map_or(false, |label| label.as_str() == "com"));
     /// ```
     #[inline]
     #[must_use]
     pub const fn as_str(self) -> &'a str {
         self.value
     }
     /// Returns `true` iff the label only contains ASCII letters.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com", &ASCII_LOWERCASE).unwrap().into_iter().next().map_or(false, |label| label.is_alphabetic()));
     /// ```
     #[inline]
     #[must_use]
     pub fn is_alphabetic(self) -> bool {
         self.value
             .as_bytes()
             .iter()
             .try_fold((), |(), byt| {
                 if byt.is_ascii_alphabetic() {
                     Ok(())
                 } else {
                     Err(())
                 }
             })
             .is_ok()
     }
     /// Returns `true` iff the label only contains ASCII digits.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_DIGITS_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.123", &ASCII_DIGITS_LOWERCASE).unwrap().into_iter().next().map_or(false, |label| label.is_digits()));
     /// ```
     #[inline]
     #[must_use]
     pub fn is_digits(self) -> bool {
         self.value
             .as_bytes()
             .iter()
             .try_fold((), |(), byt| {
                 if byt.is_ascii_digit() {
                     Ok(())
                 } else {
                     Err(())
                 }
             })
             .is_ok()
     }
     /// Returns `true` iff the label only contains ASCII digits or letters.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_DIGITS_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.1com", &ASCII_DIGITS_LOWERCASE).unwrap().into_iter().next().map_or(false, |label| label.is_alphanumeric()));
     /// ```
     #[inline]
     #[must_use]
     pub fn is_alphanumeric(self) -> bool {
         self.value
             .as_bytes()
             .iter()
             .try_fold((), |(), byt| {
                 if byt.is_ascii_alphanumeric() {
                     Ok(())
                 } else {
                     Err(())
                 }
             })
             .is_ok()
     }
     /// Returns `true` iff the label only contains ASCII hyphen, digits, or letters.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_HYPHEN_DIGITS_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.1-com", &ASCII_HYPHEN_DIGITS_LOWERCASE).unwrap().into_iter().next().map_or(false, |label| label.is_hyphen_or_alphanumeric()));
     /// ```
     #[inline]
     #[must_use]
     pub fn is_hyphen_or_alphanumeric(self) -> bool {
         self.value
             .as_bytes()
             .iter()
             .try_fold((), |(), byt| {
                 if *byt == b'-' || byt.is_ascii_alphanumeric() {
                     Ok(())
                 } else {
                     Err(())
                 }
             })
             .is_ok()
     }
     /// The length of the `Label`. This is inclusively between 1 and 63.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::{dom::Domain, char_set::ASCII_LOWERCASE};
     /// assert!(Domain::try_from_bytes("example.com.", &ASCII_LOWERCASE).unwrap().into_iter().next().map_or(false, |label| label.len().get() == 3));
     /// ```
     #[expect(
         unsafe_code,
         reason = "we enforce label lengths, so NonZeroU8::new_unchecked is fine"
     )]
     #[expect(
         clippy::as_conversions,
         clippy::cast_possible_truncation,
         reason = "comments justify their correctness"
     )]
     #[inline]
     #[must_use]
     pub const fn len(self) -> NonZeroU8 {
         // The max length of a `Label` is 63.
         let len = self.value.len() as u8;
         // SAFETY:
         // `Label`s are never empty.
         unsafe { NonZeroU8::new_unchecked(len) }
     }
 }
 impl PartialEq<Label<'_>> for Label<'_> {
     #[inline]
     fn eq(&self, other: &Label<'_>) -> bool {
         self.value.eq_ignore_ascii_case(other.value)
     }
 }
 impl PartialEq<&Label<'_>> for Label<'_> {
     #[inline]
     fn eq(&self, other: &&Label<'_>) -> bool {
         *self == **other
     }
 }
 impl PartialEq<Label<'_>> for &Label<'_> {
     #[inline]
     fn eq(&self, other: &Label<'_>) -> bool {
         **self == *other
     }
 }
 impl Eq for Label<'_> {}
 impl PartialOrd<Label<'_>> for Label<'_> {
     #[inline]
     fn partial_cmp(&self, other: &Label<'_>) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 impl Ord for Label<'_> {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         self.value
             .to_ascii_lowercase()
             .cmp(&other.value.to_ascii_lowercase())
     }
 }
 impl Hash for Label<'_> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.value.to_ascii_lowercase().hash(state);
     }
 }
 impl Display for Label<'_> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.write_str(self.value)
     }
 }
 impl<'a> AsRef<[u8]> for Label<'a> {
     #[inline]
     fn as_ref(&self) -> &'a [u8] {
         self.value.as_bytes()
     }
 }
 impl<'a> AsRef<str> for Label<'a> {
     #[inline]
     fn as_ref(&self) -> &'a str {
         self.value
     }
 }
 impl<'a> Deref for Label<'a> {
     type Target = str;
     #[inline]
     fn deref(&self) -> &'a Self::Target {
         self.value
     }
 }
 /// [`Iterator`] that iterates [`Label`]s from a [`Domain`] or [`Rfc1123Domain`] starting from the TLD down.
 ///
 /// This iterates `Label`s on demand; so if repeated iteration is desired, it may be better to collect the `Label`s
 /// in a collection (e.g., [`Vec`]) than create the iterator again. This is also why [`ExactSizeIterator`] is not
 /// implemented.
 #[derive(Clone, Debug)]
 pub struct LabelIter<'a> {
     /// Domain as ASCII.
     domain: &'a [u8],
 }
 impl<'a> Iterator for LabelIter<'a> {
     type Item = Label<'a>;
     #[expect(
         unsafe_code,
         reason = "we only allow ASCII, so str::from_utf8_unchecked is fine"
     )]
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "comments justify their correctness"
     )]
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         (!self.domain.is_empty()).then(|| {
             self.domain
                 .iter()
                 .rev()
                 .try_fold(1, |count, byt| {
                     if *byt == b'.' {
                         let len = self.domain.len();
                         // `count` < `len` since there is at least one more `u8` before `b'.'`.
                         let idx = len - count;
                         // `idx + 1` < `len` since `count` is > 1 since `Label`s are never empty.
                         let ascii = &self.domain[idx + 1..len];
                         // SAFETY:
                         // We only allow ASCII, so this is safe.
                         let value = unsafe { str::from_utf8_unchecked(ascii) };
                         self.domain = &self.domain[..idx];
                         Err(Label { value })
                     } else {
                         Ok(count + 1)
                     }
                 })
                 .map_or_else(convert::identity, |_| {
                     // SAFETY:
                     // We only allow ASCII, so this is safe.
                     let value = unsafe { str::from_utf8_unchecked(self.domain) };
                     self.domain = &[];
                     Label { value }
                 })
         })
     }
     #[inline]
     fn last(mut self) -> Option<Self::Item>
     where
         Self: Sized,
     {
         self.next_back()
     }
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         if self.domain.is_empty() {
             (0, Some(0))
         } else {
             // The max size of a `Label` is 63; and all but the last have a `b'.'` that follow it.
             // This means the fewest `Label`s possible is the floor of the length divided by 64 with
             // the added requirement that it's at least one since we know the domain is not empty.
             // The min size of a `Label` is 1; and all but the last have a `b'.'` that follow it.
             // This means the max number of `Label`s is the ceiling of the length divided by 2.
             (
                 (self.domain.len() >> 6).max(1),
                 Some(self.domain.len().div_ceil(2)),
             )
         }
     }
 }
 impl FusedIterator for LabelIter<'_> {}
 impl DoubleEndedIterator for LabelIter<'_> {
     #[expect(
         unsafe_code,
         reason = "we only allow ASCII, so str::from_utf8_unchecked is fine"
     )]
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "comments justify their correctness"
     )]
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         (!self.domain.is_empty()).then(|| {
             self.domain
                 .iter()
                 .try_fold(0, |count, byt| {
                     if *byt == b'.' {
                         // `count + 1` < `self.domain.len()` since there is at least one more `Label` and `Label`s
                         // are not empty.
                         let ascii = &self.domain[..count];
                         // SAFETY:
                         // We only allow ASCII, so this is safe.
                         let value = unsafe { str::from_utf8_unchecked(ascii) };
                         // `count + 1` < `self.domain.len()` since there is at least one more `Label` and `Label`s
                         // are not empty.
                         self.domain = &self.domain[count + 1..];
                         Err(Label { value })
                     } else {
                         Ok(count + 1)
                     }
                 })
                 .map_or_else(convert::identity, |_| {
                     // SAFETY:
                     // We only allow ASCII, so this is safe.
                     let value = unsafe { str::from_utf8_unchecked(self.domain) };
                     self.domain = &[];
                     Label { value }
                 })
         })
     }
 }
 impl<'a, T: AsRef<[u8]>> IntoIterator for &'a Domain<T> {
     type Item = Label<'a>;
     type IntoIter = LabelIter<'a>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         LabelIter {
             domain: self.as_bytes(),
         }
     }
 }
 impl<'a> IntoIterator for Domain<&'a str> {
     type Item = Label<'a>;
     type IntoIter = LabelIter<'a>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         LabelIter {
             domain: <&str>::from(self).as_bytes(),
         }
     }
 }
 impl<'a> IntoIterator for Domain<&'a [u8]> {
     type Item = Label<'a>;
     type IntoIter = LabelIter<'a>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         LabelIter {
             domain: <&[u8]>::from(self),
         }
     }
 }
 /// Error returned from [`Rfc1123Domain::try_from`] and [`Rfc1123Domain::try_from_bytes`].
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub enum Rfc1123Err {
     /// The inputs was not a valid [`Domain`].
     DomainErr(DomainErr),
     /// A [`Label`] of [`Domain`] starts with an ASCII hyphen.
     LabelStartsWithAHyphen,
     /// A [`Label`] of [`Domain`] ends with an ASCII hyphen.
     LabelEndsWithAHyphen,
     /// The last [`Label`] (i.e., TLD) was invalid which means it was not all ASCII letters nor
     /// had length of at least five with the first 4 characters being `xn--`.
     InvalidTld,
 }
 impl Display for Rfc1123Err {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match *self {
             Self::DomainErr(err) => err.fmt(f),
             Self::LabelStartsWithAHyphen => {
                 f.write_str("a label in the domain starts with a hyphen")
             }
             Self::LabelEndsWithAHyphen => f.write_str("a label in the domain ends with a hyphen"),
             Self::InvalidTld => f.write_str("the TLD in the domain was not all letters nor had length of at least five with the first 4 characters being 'xn--'")
         }
     }
 }
 impl Error for Rfc1123Err {}
 /// **TL;DR** Wrapper type around a [`Domain`] that enforces conformance to
 /// [RFC 1123](https://www.rfc-editor.org/rfc/rfc1123#page-13).
 ///
 /// * Each [`Label`] must only contain ASCII digits, letters, or hyphen.
 /// * Each `Label` must not begin or end with a hyphen.
 /// * The last `Label` (i.e., TLD) must either contain only ASCII letters or have length of at least five and
 ///   begin with `xn--`.
 /// ---
 /// Unsurprisingly, RFC 1123 is not super precise as it uses "host name" to mean label and also domain:
 /// "Host software MUST handle host names \[labels\] of up to 63 characters and SHOULD handle host
 /// names \[domains\] of up to 255 characters". It also states that only "one aspect of host name \[label\]
 /// syntax is hereby changed" from [RFC 952](https://www.rfc-editor.org/rfc/rfc952): "the restriction on the
 /// first character is relaxed to allow either a letter or a digit". Despite that, it goes on to mention other
 /// restrictions not mentioned in RFC 952: "the highest-level component label will be alphabetic". It is therefore
 /// important to understand how this type interprets that RFC and why it does so.
 ///
 /// The primary issue with RFC 1123 is the unjustified comment about the TLD being alphabetic. It is given
 /// as if it is common knowledge. As explained by (the rejected)
 /// [Errata 1353](https://www.rfc-editor.org/errata/eid1353), there seemed to be the assumption that the TLDs
 /// at the time would be the only ones that would ever exist or at least that the format of them would always be
 /// true. This leads to several possible interpretations:
 ///
 /// * Strictest: enforce the TLD is one of the TLDs that existed at the time of the RFC.
 /// * Strict: enforce the TLD has the same format as the TLDs at the time (i.e., two or three letters long).
 /// * Literal: enforce the TLD is alphabetic regardless of the lack of justification.
 /// * Relaxed: enforce the "spirit" that the TLD must exist.
 /// * More relaxed: enforce the "spirit" that the TLD must have the same format of a valid TLD.
 /// * Much more relaxed: enforce the "spirit" that the domain cannot have the form of an IPv4 address.
 /// * Most relaxed: treat TLDs no differently than other labels (i.e., don't make assumptions about what will be
 ///   a valid TLD in the future).
 ///
 /// RFC 1123 is not obsolete, and it is clear from more recent RFCs like
 /// [RFC 5891](https://www.rfc-editor.org/rfc/rfc5891) that it is designed to be a foundation (i.e., domains that
 /// are valid per newer RFCs are valid per RFC 1123). Clearly due to RFCs like RFC 5891, requiring the TLD
 /// to be alphabetic or exactly two or three characters long would violate that. For those reasons the strictest,
 /// strict, and literal interpretations are rejected.
 ///
 /// Assuming TLDs are static is absurd, and relying on some dynamic list of TLDs is undesirable. For that reason
 /// the relaxed interpretation is rejected.
 ///
 /// Enforcing that domains do not have the form of an IPv4 address opens up the question of what is an IPv4
 /// address? Should leading 0s be allowed? What about hexadecimal? Should there be length limits for each octet?
 /// It also has the undesirable effect where subdomains that are all numeric exist but their parent domain does
 /// not which goes against the hierarchical nature of DNS. For those reasons the much more relaxed interpretation
 /// is rejected.
 ///
 /// Treating TLDs no differently than other labels is nice from a consistency perspective, but it suffers from
 /// the fact that domains that have the form of an IPv4 address are now allowed. For that reason the most
 /// relaxed interpretation is rejected.
 ///
 /// [ICANN](https://newgtlds.icann.org/sites/default/files/guidebook-full-04jun12-en.pdf) requires TLDs to either
 /// be alphabetic or a valid A-label per RFC 5891. Verifying a label is a valid A-label is not a cheap operation
 /// though. For that reason the more relaxed interpretation is accepted but with a twist: fake and valid A-labels
 /// are allowed in addition to entirely alphabetic labels. More specifically the TLD must either contain only
 /// letters or must be at least five characters long with the first 4 characters being `xn--`.
 ///
 /// If one wants to enforce the literal interpretation, one can use [`Self::is_literal_interpretation`]. Similarly,
 /// if one wants to enforce the strict interpretation, one can use [`Self::is_strict_interpretation`].
 #[derive(Clone, Copy, Debug)]
 pub struct Rfc1123Domain<T> {
     /// The domain.
     dom: Domain<T>,
 }
 impl<T> Rfc1123Domain<T> {
     /// Returns a reference to the contained [`Domain`].
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::dom::Rfc1123Domain;
     /// assert!(Rfc1123Domain::try_from_bytes("example.com").unwrap().domain().len().get() == 11);
     /// ```
     #[inline]
     pub const fn domain(&self) -> &Domain<T> {
         &self.dom
     }
     /// Returns the contained [`Domain`] consuming `self`.
     ///
     /// # Example
     ///
     /// ```
     /// use ascii_domain::dom::Rfc1123Domain;
     /// assert!(Rfc1123Domain::try_from_bytes("example.com").unwrap().into_domain().len().get() == 11);
     /// ```
     #[inline]
     pub fn into_domain(self) -> Domain<T> {
         self.dom
     }
 }
 impl<T: AsRef<[u8]>> Rfc1123Domain<T> {
     /// Function that transforms `v` into an `Rfc1123Domain` by only allowing [`Label`]s to contain the ASCII `u8`s
     /// in [`ASCII_HYPHEN_DIGITS_LETTERS`] with each `Label` not starting or ending with a `b'-'`. A trailing `b'.'`
     /// is ignored. The last `Label` (i.e., TLD) must either only contain ASCII letters or must have length of at
     /// least five with the first 4 bytes being `b"xn--"`.
     ///
     /// Unliked calling [`Domain::try_from_bytes`] then [`Rfc1123Domain::try_from`] which performs two traversals
     /// of `v`, this performs a single traversal of `v`.
     ///
     /// # Examples
     ///
     /// ```
     /// use ascii_domain::dom::{Rfc1123Domain, Rfc1123Err};
     /// assert!(Rfc1123Domain::try_from_bytes("example.com").is_ok());
     /// assert!(Rfc1123Domain::try_from_bytes("example.xn--abc").is_ok());
     /// assert!(Rfc1123Domain::try_from_bytes("a-.com").map_or_else(|err| err == Rfc1123Err::LabelEndsWithAHyphen, |_| false));
     /// ```
     ///
     /// # Errors
     ///
     /// Returns [`Rfc1123Err`] iff `v.as_ref()` is an invalid `Rfc1123Domain`.
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         reason = "comments justify their correctness"
     )]
     #[expect(clippy::redundant_else, reason = "prefer else with else-if")]
     #[inline]
     pub fn try_from_bytes(v: T) -> Result<Self, Rfc1123Err> {
         // The easiest implementation would be redirecting to `Domain::try_from_bytes`; and upon success,
         // verify each `Label` doesn't begin or end with a hyphen. That requires traversing `v` twice though.
         // We opt to traverse just once.
         let val = v.as_ref();
         let value = match val.last() {
             None => return Err(Rfc1123Err::DomainErr(DomainErr::Empty)),
             Some(byt) => {
                 let b = *byt;
                 if b == b'.' {
                     if val.len() == 1 {
                         return Err(Rfc1123Err::DomainErr(DomainErr::RootDomain));
                     }
                     // We know `val.len` is at least 2.
                     let len = val.len() - 1;
                     let lst = val[len - 1];
                     if lst == b'.' {
                         return Err(Rfc1123Err::DomainErr(DomainErr::EmptyLabel));
                     } else if lst == b'-' {
                         return Err(Rfc1123Err::LabelEndsWithAHyphen);
                     } else {
                         &val[..len]
                     }
                 } else if b == b'-' {
                     return Err(Rfc1123Err::LabelEndsWithAHyphen);
                 } else {
                     val
                 }
             }
         };
         if value.len() > 253 {
             Err(Rfc1123Err::DomainErr(DomainErr::LenExceeds253(value.len())))
         } else {
             let mut count = 0;
             value
                 .iter()
                 .try_fold(0, |label_len, byt| {
                     let b = *byt;
                     if b == b'.' {
                         NonZeroU8::new(label_len).map_or(
                             Err(Rfc1123Err::DomainErr(DomainErr::EmptyLabel)),
                             |_| {
                                 // We verify the last character in the `Label` is not a hyphen.
                                 // `count` > 0 since `label_len` > 0 and `count` < `value.len()` since
                                 // it's the index of the `b'.'`.
                                 if value[count - 1] == b'-' {
                                     Err(Rfc1123Err::LabelEndsWithAHyphen)
                                 } else {
                                     Ok(0)
                                 }
                             },
                         )
                     } else if !RFC_CHARS.contains(b) {
                         Err(Rfc1123Err::DomainErr(DomainErr::InvalidByte(b)))
                     } else if b == b'-' && label_len == 0 {
                         Err(Rfc1123Err::LabelStartsWithAHyphen)
                     } else if label_len == 63 {
                         Err(Rfc1123Err::DomainErr(DomainErr::LabelLenExceeds63))
                     } else {
                         // This caps at 253, so no overflow.
                         count += 1;
                         // This is less than 64 due to the above check, so this won't overflow;
                         Ok(label_len + 1)
                     }
                 })
                 .and_then(|tld_len| {
                     // `tld_len <= value.len()`.
                     let tld = &value[value.len() - usize::from(tld_len)..];
                     if (tld
                         .split_at_checked(4)
                         .is_some_and(|(fst, rem)| !rem.is_empty() && fst == b"xn--"))
                         || tld
                             .iter()
                             .try_fold((), |(), byt| {
                                 if byt.is_ascii_alphabetic() {
                                     Ok(())
                                 } else {
                                     Err(())
                                 }
                             })
                             .is_ok()
                     {
                         Ok(())
                     } else {
                         Err(Rfc1123Err::InvalidTld)
                     }
                 })
                 .map(|()| Self {
                     dom: Domain { value: v },
                 })
         }
     }
     /// Returns `true` iff the domain adheres to the literal interpretation of RFC 1123. For more information
     /// read the description of [`Rfc1123Domain`].
     ///
     /// # Examples
     ///
     /// ```
     /// use ascii_domain::dom::Rfc1123Domain;
     /// assert!(Rfc1123Domain::try_from_bytes("example.commmm").unwrap().is_literal_interpretation());
     /// assert!(!Rfc1123Domain::try_from_bytes("example.xn--abc").unwrap().is_literal_interpretation());
     /// ```
     #[inline]
     pub fn is_literal_interpretation(&self) -> bool {
         self.dom.tld().is_alphabetic()
     }
     /// Returns `true` iff the domain adheres to the strict interpretation of RFC 1123. For more information
     /// read the description of [`Rfc1123Domain`].
     ///
     /// # Examples
     ///
     /// ```
     /// use ascii_domain::dom::Rfc1123Domain;
     /// assert!(Rfc1123Domain::try_from_bytes("example.Com").unwrap().is_strict_interpretation());
     /// assert!(!Rfc1123Domain::try_from_bytes("example.comm").unwrap().is_strict_interpretation());
     /// ```
     #[inline]
     pub fn is_strict_interpretation(&self) -> bool {
         let tld = self.dom.tld();
         (2..4).contains(&tld.len().get()) && tld.is_alphabetic()
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<Rfc1123Domain<T>> for Rfc1123Domain<T2> {
     #[inline]
     fn eq(&self, other: &Rfc1123Domain<T>) -> bool {
         self.dom == other.dom
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<&Rfc1123Domain<T>> for Rfc1123Domain<T2> {
     #[inline]
     fn eq(&self, other: &&Rfc1123Domain<T>) -> bool {
         self.dom == other.dom
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<Rfc1123Domain<T>> for &Rfc1123Domain<T2> {
     #[inline]
     fn eq(&self, other: &Rfc1123Domain<T>) -> bool {
         self.dom == other.dom
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<Rfc1123Domain<T>> for Domain<T2> {
     #[inline]
     fn eq(&self, other: &Rfc1123Domain<T>) -> bool {
         *self == other.dom
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<Rfc1123Domain<T>> for &Domain<T2> {
     #[inline]
     fn eq(&self, other: &Rfc1123Domain<T>) -> bool {
         **self == other.dom
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<&Rfc1123Domain<T>> for Domain<T2> {
     #[inline]
     fn eq(&self, other: &&Rfc1123Domain<T>) -> bool {
         *self == other.dom
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<Domain<T>> for Rfc1123Domain<T2> {
     #[inline]
     fn eq(&self, other: &Domain<T>) -> bool {
         self.dom == *other
     }
 }
 impl<T: AsRef<[u8]>> Eq for Rfc1123Domain<T> {}
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialOrd<Rfc1123Domain<T>> for Rfc1123Domain<T2> {
     #[inline]
     fn partial_cmp(&self, other: &Rfc1123Domain<T>) -> Option<Ordering> {
         self.dom.partial_cmp(&other.dom)
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialOrd<Rfc1123Domain<T>> for Domain<T2> {
     #[inline]
     fn partial_cmp(&self, other: &Rfc1123Domain<T>) -> Option<Ordering> {
         self.partial_cmp(&other.dom)
     }
 }
 impl<T: AsRef<[u8]>, T2: AsRef<[u8]>> PartialOrd<Domain<T>> for Rfc1123Domain<T2> {
     #[inline]
     fn partial_cmp(&self, other: &Domain<T>) -> Option<Ordering> {
         self.dom.partial_cmp(other)
     }
 }
 impl<T: AsRef<[u8]>> Ord for Rfc1123Domain<T> {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         self.dom.cmp(&other.dom)
     }
 }
 impl<T: AsRef<[u8]>> Hash for Rfc1123Domain<T> {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.dom.hash(state);
     }
 }
 impl<T> AsRef<Domain<T>> for Rfc1123Domain<T> {
     #[inline]
     fn as_ref(&self) -> &Domain<T> {
         &self.dom
     }
 }
 impl<T> Borrow<Domain<T>> for Rfc1123Domain<T> {
     #[inline]
     fn borrow(&self) -> &Domain<T> {
         &self.dom
     }
 }
 impl<T> Deref for Rfc1123Domain<T> {
     type Target = Domain<T>;
     #[inline]
     fn deref(&self) -> &Self::Target {
         &self.dom
     }
 }
 impl<T> From<Rfc1123Domain<T>> for Domain<T> {
     #[inline]
     fn from(value: Rfc1123Domain<T>) -> Self {
         value.dom
     }
 }
 impl From<Rfc1123Domain<Vec<u8>>> for Rfc1123Domain<String> {
     #[inline]
     fn from(value: Rfc1123Domain<Vec<u8>>) -> Self {
         Self {
             dom: Domain::<String>::from(value.dom),
         }
     }
 }
 impl<'a: 'b, 'b, T: AsRef<[u8]>> From<&'a Rfc1123Domain<T>> for Rfc1123Domain<&'b [u8]> {
     #[inline]
     fn from(value: &'a Rfc1123Domain<T>) -> Self {
         Self {
             dom: Domain::<&'b [u8]>::from(&value.dom),
         }
     }
 }
 impl<'a: 'b, 'b, T: AsRef<str>> From<&'a Rfc1123Domain<T>> for Rfc1123Domain<&'b str> {
     #[inline]
     fn from(value: &'a Rfc1123Domain<T>) -> Self {
         Self {
             dom: Domain::<&'b str>::from(&value.dom),
         }
     }
 }
 impl From<Rfc1123Domain<String>> for Rfc1123Domain<Vec<u8>> {
     #[inline]
     fn from(value: Rfc1123Domain<String>) -> Self {
         Self {
             dom: Domain::<Vec<u8>>::from(value.dom),
         }
     }
 }
 impl<'a: 'b, 'b> From<Rfc1123Domain<&'a [u8]>> for Rfc1123Domain<&'b str> {
     #[inline]
     fn from(value: Rfc1123Domain<&'a [u8]>) -> Self {
         Self {
             dom: Domain::<&'b str>::from(value.dom),
         }
     }
 }
 impl<'a: 'b, 'b> From<Rfc1123Domain<&'a str>> for Rfc1123Domain<&'b [u8]> {
     #[inline]
     fn from(value: Rfc1123Domain<&'a str>) -> Self {
         Self {
             dom: Domain::<&'b [u8]>::from(value.dom),
         }
     }
 }
 impl<T: AsRef<[u8]>> TryFrom<Domain<T>> for Rfc1123Domain<T> {
     type Error = Rfc1123Err;
     #[expect(
         clippy::arithmetic_side_effects,
         clippy::indexing_slicing,
         clippy::unreachable,
         reason = "comments explain their correctness"
     )]
     #[inline]
     fn try_from(value: Domain<T>) -> Result<Self, Self::Error> {
         let mut labels = value.iter();
         let tld = labels
             .next()
             .unwrap_or_else(|| unreachable!("there is a bug in Domain::try_from_bytes"));
         if tld.is_alphabetic()
             || tld
                 .split_at_checked(4)
                 .is_some_and(|(fst, rem)| !rem.is_empty() && fst == "xn--")
         {
             labels
                 .try_fold((), |(), label| {
                     let bytes = label.value.as_bytes();
                     // `Label`s are never empty, so the below indexing is fine.
                     // Underflow won't occur for the same reason.
                     if bytes[0] == b'-' {
                         Err(Rfc1123Err::LabelStartsWithAHyphen)
                     } else if bytes[bytes.len() - 1] == b'-' {
                         Err(Rfc1123Err::LabelEndsWithAHyphen)
                     } else {
                         bytes.iter().try_fold((), |(), byt| match *byt {
                             b'-' | b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z' => Ok(()),
                             val => Err(Rfc1123Err::DomainErr(DomainErr::InvalidByte(val))),
                         })
                     }
                 })
                 .map(|()| Self { dom: value })
         } else {
             Err(Rfc1123Err::InvalidTld)
         }
     }
 }
 impl<T: AsRef<[u8]>> Display for Rfc1123Domain<T> {
     #[inline]
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         self.dom.fmt(f)
     }
 }
 impl<'a, T: AsRef<[u8]>> IntoIterator for &'a Rfc1123Domain<T> {
     type Item = Label<'a>;
     type IntoIter = LabelIter<'a>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         LabelIter {
             domain: self.dom.as_bytes(),
         }
     }
 }
 impl<'a> IntoIterator for Rfc1123Domain<&'a str> {
     type Item = Label<'a>;
     type IntoIter = LabelIter<'a>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         LabelIter {
             domain: <&str>::from(self.dom).as_bytes(),
         }
     }
 }
 impl<'a> IntoIterator for Rfc1123Domain<&'a [u8]> {
     type Item = Label<'a>;
     type IntoIter = LabelIter<'a>;
     #[inline]
     fn into_iter(self) -> Self::IntoIter {
         LabelIter {
             domain: <&[u8]>::from(self.dom),
         }
     }
 }