ascii_domain 0.6.6

extern crate alloc;
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),
        }
    }
}
#[cfg(test)]
mod tests {
    extern crate alloc;
    use super::{Domain, DomainErr, Rfc1123Domain, Rfc1123Err};
    use crate::char_set::{ASCII_FIREFOX, ASCII_HYPHEN_DIGITS_LETTERS, AllowedAscii};
    use alloc::borrow::ToOwned;
    use core::cmp::Ordering;
    use serde_json as _;
    #[test]
    fn test_dom_parse() {
        let allowed_ascii = ASCII_FIREFOX;
        // Test empty is error.
        assert!(
            Domain::try_from_bytes("", &allowed_ascii)
                .map_or_else(|e| e == DomainErr::Empty, |_| false)
        );
        // Test root domain.
        assert!(
            Domain::try_from_bytes(".", &allowed_ascii)
                .map_or_else(|e| e == DomainErr::RootDomain, |_| false)
        );
        // Test empty label is error.
        assert!(
            Domain::try_from_bytes("a..com", &allowed_ascii)
                .map_or_else(|e| e == DomainErr::EmptyLabel, |_| false)
        );
        assert!(
            Domain::try_from_bytes("a..", &allowed_ascii)
                .map_or_else(|e| e == DomainErr::EmptyLabel, |_| false)
        );
        assert!(
            Domain::try_from_bytes("..", &allowed_ascii)
                .map_or_else(|e| e == DomainErr::EmptyLabel, |_| false)
        );
        // Test label too long.
        let val = "www.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com";
        // 4 + 64 + 4
        assert!(val.len() == 72);
        assert!(
            Domain::try_from_bytes(val, &allowed_ascii)
                .map_or_else(|e| e == DomainErr::LabelLenExceeds63, |_| false)
        );
        assert!(
            Domain::try_from_bytes(
                "www.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com",
                &allowed_ascii
            )
            .map_or(false, |d| d.len().get() == 71)
        );
        // Test domain too long.
        assert!(Domain::try_from_bytes("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", &allowed_ascii).map_or_else(|e| e == DomainErr::LenExceeds253(254), |_| false));
        assert!(Domain::try_from_bytes("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", &allowed_ascii).map_or(false, |d| d.len().get() == 253 ));
        // Test max labels.
        assert!(Domain::try_from_bytes("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a", &allowed_ascii).map_or_else(|e| e == DomainErr::LenExceeds253(255), |_| false));
        assert!(Domain::try_from_bytes("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a", &allowed_ascii).map_or(false, |d| d.iter().count() == 127 && d.len().get() == 253));
        assert!(Domain::try_from_bytes("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.", &allowed_ascii).map_or(false, |d| d.iter().count() == 127 && d.len().get() == 253));
        // Test removal of trailing '.'.
        assert!(
            Domain::try_from_bytes("com.", &allowed_ascii).map_or(false, |d| d.as_str() == "com")
        );
        // Test single label.
        assert!(Domain::try_from_bytes("c", &allowed_ascii).map_or(false, |d| d.as_str() == "c"));
        // Test case-insensitivity.
        assert!(
            Domain::try_from_bytes("wwW.ExAMple.COm", &allowed_ascii).map_or(false, |d| {
                Domain::try_from_bytes("www.example.com", &allowed_ascii)
                    .map_or(false, |d2| d == d2 && d.cmp(&d2) == Ordering::Equal)
            })
        );
        assert!(
            Domain::try_from_bytes("ww_W.com", &allowed_ascii).map_or(false, |d| {
                Domain::try_from_bytes("Ww_w.com", &allowed_ascii)
                    .map_or(false, |d2| d == d2 && d.cmp(&d2) == Ordering::Equal)
            })
        );
        // Test valid bytes
        let mut input;
        let mut counter = 0;
        for i in 0..=127 {
            input = [i];
            match i {
                b'!'
                | b'$'
                | b'&'..=b')'
                | b'+'..=b'-'
                | b'0'..=b'9'
                | b';'
                | b'='
                | b'A'..=b'Z'
                | b'_'..=b'{'
                | b'}'..=b'~' => {
                    counter += 1;
                    assert!(
                        Domain::try_from_bytes(input, &allowed_ascii).map_or(false, |d| d
                            .value
                            .len()
                            == 1
                            && d.value == input)
                    )
                }
                b'.' => {
                    let input2 = b"a.";
                    assert!(
                        Domain::try_from_bytes(input2, &allowed_ascii).map_or(false, |d| d
                            .len()
                            .get()
                            == 1
                            && d.value == input2)
                    )
                }
                _ => assert!(
                    Domain::try_from_bytes(input, &allowed_ascii)
                        .map_or_else(|e| e == DomainErr::InvalidByte(i), |_| false)
                ),
            }
        }
        assert!(counter == 78);
    }
    #[test]
    fn test_dom_iter() {
        let allowed_ascii = ASCII_FIREFOX;
        assert!(
            Domain::try_from_bytes("www.example.com", &allowed_ascii).map_or(false, |d| {
                let mut iter = d.iter();
                let Some(l) = iter.next() else {
                    return false;
                };
                if l.value != "com" {
                    return false;
                }
                let Some(l) = iter.next() else { return false };
                if l.value != "example" {
                    return false;
                }
                let Some(l) = iter.next() else {
                    return false;
                };
                if l.value != "www" {
                    return false;
                }
                iter.next().is_none()
            })
        );
        assert!(
            Domain::try_from_bytes("www.example.com", &allowed_ascii).map_or(false, |d| {
                let mut iter = d.iter();
                let Some(l) = iter.next_back() else {
                    return false;
                };
                if l.value != "www" {
                    return false;
                }
                let Some(l) = iter.next_back() else {
                    return false;
                };
                if l.value != "example" {
                    return false;
                }
                let Some(l) = iter.next_back() else {
                    return false;
                };
                if l.value != "com" {
                    return false;
                }
                iter.next_back().is_none()
            })
        );
        assert!(
            Domain::try_from_bytes("www.example.com", &allowed_ascii).map_or(false, |d| {
                let mut iter = d.iter();
                let Some(l) = iter.next_back() else {
                    return false;
                };
                if l.value != "www" {
                    return false;
                }
                let Some(l) = iter.next() else { return false };
                if l.value != "com" {
                    return false;
                }
                let Some(l) = iter.next_back() else {
                    return false;
                };
                if l.value != "example" {
                    return false;
                }
                iter.next().is_none() && iter.next_back().is_none()
            })
        );
    }
    #[test]
    fn rfc1123() {
        assert!(
            Domain::try_from_bytes("example.com", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or(false, |dom| dom.as_str() == "example.com")
            )
        );
        assert!(
            AllowedAscii::try_from_unique_ascii(b"exampl!co".to_owned()).map_or(false, |ascii| {
                Domain::try_from_bytes("exampl!e.com", &ascii).map_or(false, |dom| {
                    Rfc1123Domain::try_from(dom).map_or_else(
                        |e| e == Rfc1123Err::DomainErr(DomainErr::InvalidByte(b'!')),
                        |_| false,
                    )
                })
            })
        );
        assert!(
            Domain::try_from_bytes("example-.com", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or_else(|e| e == Rfc1123Err::LabelEndsWithAHyphen, |_| false)
            )
        );
        assert!(
            Domain::try_from_bytes("-example.com", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or_else(|e| e == Rfc1123Err::LabelStartsWithAHyphen, |_| false)
            )
        );
        assert!(
            Domain::try_from_bytes("example.c1m", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or_else(|e| e == Rfc1123Err::InvalidTld, |_| false)
            )
        );
        assert!(
            Domain::try_from_bytes("example.commm", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or(false, |rfc| rfc.is_literal_interpretation())
            )
        );
        assert!(
            Domain::try_from_bytes("example.xn--abc", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or(false, |rfc| !rfc.is_literal_interpretation())
            )
        );
        assert!(
            Domain::try_from_bytes("example.com", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or(false, |rfc| rfc.is_strict_interpretation())
            )
        );
        assert!(
            Domain::try_from_bytes("example.comm", &ASCII_HYPHEN_DIGITS_LETTERS).map_or(
                false,
                |dom| Rfc1123Domain::try_from(dom)
                    .map_or(false, |rfc| !rfc.is_strict_interpretation())
            )
        );
    }
    #[test]
    fn test_tld() {
        assert!(
            Domain::try_from_bytes("example.com", &ASCII_HYPHEN_DIGITS_LETTERS)
                .map_or(false, |dom| dom.tld().as_str() == "com",)
        );
    }
    #[test]
    fn test_rfc1123_parse() {
        // Test empty is error.
        assert!(
            Rfc1123Domain::try_from_bytes("")
                .map_or_else(|e| e == Rfc1123Err::DomainErr(DomainErr::Empty), |_| false)
        );
        // Test root domain.
        assert!(Rfc1123Domain::try_from_bytes(".").map_or_else(
            |e| e == Rfc1123Err::DomainErr(DomainErr::RootDomain),
            |_| false
        ));
        // Test empty label is error.
        assert!(Rfc1123Domain::try_from_bytes("a..com").map_or_else(
            |e| e == Rfc1123Err::DomainErr(DomainErr::EmptyLabel),
            |_| false
        ));
        assert!(Rfc1123Domain::try_from_bytes("a..").map_or_else(
            |e| e == Rfc1123Err::DomainErr(DomainErr::EmptyLabel),
            |_| false
        ));
        assert!(Rfc1123Domain::try_from_bytes("..").map_or_else(
            |e| e == Rfc1123Err::DomainErr(DomainErr::EmptyLabel),
            |_| false
        ));
        // Test label too long.
        let val = "www.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com";
        // 4 + 64 + 4
        assert!(val.len() == 72);
        assert!(Rfc1123Domain::try_from_bytes(val).map_or_else(
            |e| e == Rfc1123Err::DomainErr(DomainErr::LabelLenExceeds63),
            |_| false
        ));
        assert!(
            Rfc1123Domain::try_from_bytes(
                "www.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com",
            )
            .map_or(false, |d| d.len().get() == 71)
        );
        // Test domain too long.
        assert!(Rfc1123Domain::try_from_bytes("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").map_or_else(|e| e == Rfc1123Err::DomainErr(DomainErr::LenExceeds253(254)), |_| false));
        assert!(Rfc1123Domain::try_from_bytes("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").map_or(false, |d| d.len().get() == 253 ));
        // Test max labels.
        assert!(Rfc1123Domain::try_from_bytes("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a").map_or_else(|e| e == Rfc1123Err::DomainErr(DomainErr::LenExceeds253(255)), |_| false));
        assert!(Rfc1123Domain::try_from_bytes("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a").map_or(false, |d| d.iter().count() == 127 && d.len().get() == 253));
        assert!(Rfc1123Domain::try_from_bytes("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.").map_or(false, |d| d.iter().count() == 127 && d.len().get() == 253));
        // Test removal of trailing '.'.
        assert!(Rfc1123Domain::try_from_bytes("com.").map_or(false, |d| d.as_str() == "com"));
        // Test single label.
        assert!(Rfc1123Domain::try_from_bytes("c").map_or(false, |d| d.as_str() == "c"));
        // Test ends with hyphen.
        assert!(
            Rfc1123Domain::try_from_bytes("-")
                .map_or_else(|err| err == Rfc1123Err::LabelEndsWithAHyphen, |_| false)
        );
        assert!(
            Rfc1123Domain::try_from_bytes("-.")
                .map_or_else(|err| err == Rfc1123Err::LabelEndsWithAHyphen, |_| false)
        );
        assert!(
            Rfc1123Domain::try_from_bytes("a.com.-")
                .map_or_else(|err| err == Rfc1123Err::LabelEndsWithAHyphen, |_| false)
        );
        assert!(
            Rfc1123Domain::try_from_bytes("a.com-")
                .map_or_else(|err| err == Rfc1123Err::LabelEndsWithAHyphen, |_| false)
        );
        assert!(
            Rfc1123Domain::try_from_bytes("a-.com")
                .map_or_else(|err| err == Rfc1123Err::LabelEndsWithAHyphen, |_| false)
        );
        // Test starts with hyphen.
        assert!(
            Rfc1123Domain::try_from_bytes("a.-com")
                .map_or_else(|err| err == Rfc1123Err::LabelStartsWithAHyphen, |_| false)
        );
        assert!(
            Rfc1123Domain::try_from_bytes("-a.com")
                .map_or_else(|err| err == Rfc1123Err::LabelStartsWithAHyphen, |_| false)
        );
        // Test case-insensitivity.
        assert!(
            Rfc1123Domain::try_from_bytes("wwW.ExAMple.COm").map_or(false, |d| {
                Rfc1123Domain::try_from_bytes("www.example.com")
                    .map_or(false, |d2| d == d2 && d.cmp(&d2) == Ordering::Equal)
            })
        );
        assert!(
            Rfc1123Domain::try_from_bytes("ww-W.com").map_or(false, |d| {
                Rfc1123Domain::try_from_bytes("Ww-w.com")
                    .map_or(false, |d2| d == d2 && d.cmp(&d2) == Ordering::Equal)
            })
        );
        assert!(
            Rfc1123Domain::try_from_bytes("1.1.1.1")
                .map_or_else(|err| err == Rfc1123Err::InvalidTld, |_| false)
        );
    }
}