const unsafe fn from_parts(year: i32, is_leap_year: bool, ordinal: u16) -> Self {
        debug_assert!(year >= MIN_YEAR);
        debug_assert!(year <= MAX_YEAR);
        debug_assert!(ordinal != 0);
        debug_assert!(ordinal <= range_validated::days_in_year(year));
        debug_assert!(range_validated::is_leap_year(year) == is_leap_year);

        Self {
            // Safety: `ordinal` is not zero.
            value: unsafe {
                NonZero::new_unchecked((year << 10) | ((is_leap_year as i32) << 9) | ordinal as i32)
            },
        }
    }

    /// Construct a `Date` from the year and ordinal values, the validity of which must be
    /// guaranteed by the caller.
    ///
    /// # Safety
    ///
    /// - `year` must be in the range `MIN_YEAR..=MAX_YEAR`.
    /// - `ordinal` must be non-zero and at most the number of days in `year`.
    #[doc(hidden)]
    #[inline]
    #[track_caller]
    pub const unsafe fn __from_ordinal_date_unchecked(year: i32, ordinal: u16) -> Self {
        // Safety: The caller must guarantee that `ordinal` is not zero and that the year is in
        // range.
        unsafe { Self::from_parts(year, range_validated::is_leap_year(year), ordinal) }
    }

    pub(crate) const unsafe fn new_unchecked(seconds: i64, nanoseconds: i32) -> Self {
        Self::new_ranged_unchecked(
            seconds,
            // Safety: The caller must uphold the safety invariants.
            unsafe { Nanoseconds::new_unchecked(nanoseconds) },
        )
    }

    /// Create a new `Duration` without checking the validity of the components.
    #[inline]
    #[track_caller]
    pub(crate) const fn new_ranged_unchecked(seconds: i64, nanoseconds: Nanoseconds) -> Self {
        if seconds < 0 {
            debug_assert!(nanoseconds.get() <= 0);
        } else if seconds > 0 {
            debug_assert!(nanoseconds.get() >= 0);
        }

        Self {
            seconds,
            nanoseconds,
            padding: Padding::Optimize,
        }
    }

    /// Create a new `Duration` with the provided seconds and nanoseconds. If nanoseconds is at
    /// least ±10<sup>9</sup>, it will wrap to the number of seconds.
    ///
    /// ```rust
    /// # use time::{Duration, ext::NumericalDuration};
    /// assert_eq!(Duration::new(1, 0), 1.seconds());
    /// assert_eq!(Duration::new(-1, 0), (-1).seconds());
    /// assert_eq!(Duration::new(1, 2_000_000_000), 3.seconds());
    /// ```
    ///
    /// # Panics
    ///
    /// This may panic if an overflow occurs.
    #[inline]
    #[track_caller]
    pub const fn new(mut seconds: i64, mut nanoseconds: i32) -> Self {
        seconds = seconds
            .checked_add(nanoseconds as i64 / Nanosecond::per_t::<i64>(Second))
            .expect("overflow constructing `time::Duration`");
        nanoseconds %= Nanosecond::per_t::<i32>(Second);

        if seconds > 0 && nanoseconds < 0 {
            // `seconds` cannot overflow here because it is positive.
            seconds -= 1;
            nanoseconds += Nanosecond::per_t::<i32>(Second);
        } else if seconds < 0 && nanoseconds > 0 {
            // `seconds` cannot overflow here because it is negative.
            seconds += 1;
            nanoseconds -= Nanosecond::per_t::<i32>(Second);
        }

        // Safety: `nanoseconds` is in range due to the modulus above.
        unsafe { Self::new_unchecked(seconds, nanoseconds) }

            if index > 6 {
                return None;
            }
            // Safety: Values zero thru six are valid variants, while values greater than six have
            // already been excluded above. We know at least one element matched because the bitmask
            // is non-zero.
            let weekday = unsafe { core::mem::transmute::<u8, Weekday>(index.truncate()) };

            // For the "short" repr, we've already validated the full text expected. For the "long"
            // repr, we need to validate the remaining characters.
            if modifiers.repr == modifier::WeekdayRepr::Short {
                return Some(ParsedItem(rest, weekday));
            }

            let expected_remaining = match weekday {
                Weekday::Monday | Weekday::Friday | Weekday::Sunday => b"day".as_slice(),
                Weekday::Tuesday => b"sday".as_slice(),
                Weekday::Wednesday => b"nesday".as_slice(),
                Weekday::Thursday => b"rsday".as_slice(),
                Weekday::Saturday => b"urday".as_slice(),
            };

            if modifiers.case_sensitive {
                rest.strip_prefix(expected_remaining)
                    .map(|remaining| ParsedItem(remaining, weekday))
            } else {
                let (head, tail) = rest.split_at_checked(expected_remaining.len())?;
                core::iter::zip(head, expected_remaining)
                    .all(|(a, b)| a.eq_ignore_ascii_case(b))
                    .then_some(ParsedItem(tail, weekday))
            }
        }
        modifier::WeekdayRepr::Sunday | modifier::WeekdayRepr::Monday => {
            let [digit, rest @ ..] = input else {
                return None;
            };
            let mut digit = digit
                .wrapping_sub(b'0')
                .wrapping_sub(u8::from(modifiers.one_indexed));
            if digit > 6 {
                return None;
            }

            if modifiers.repr == modifier::WeekdayRepr::Sunday {
                // Remap so that Sunday comes after Saturday, not before Monday.
                digit = (digit + 6) % 7;
            }
            // Safety: Values zero thru six are valid variants.
            let weekday = unsafe { core::mem::transmute::<u8, Weekday>(digit) };
            Some(ParsedItem(rest, weekday))
        }