feat: migrate from Cedar to SpiceDB authorization system

This is a major architectural change that replaces the Cedar policy-based
authorization system with SpiceDB's relation-based authorization.

Key changes:

- Migrate from Rust to Go implementation
- Replace Cedar policies with SpiceDB schema and relationships
- Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks
- Update build system and dependencies for Go ecosystem
- Maintain Envoy integration for external authorization

This change enables more flexible permission modeling through SpiceDB's
Google Zanzibar inspired relation-based system, supporting complex
hierarchical permissions that were difficult to express in Cedar.

Breaking change: Existing Cedar policies and Rust-based configuration
will no longer work and need to be migrated to SpiceDB schema.

14 files changed, 0 insertions, 3313 deletions

diff --git a/vendor/time/src/format_description/borrowed_format_item.rs b/vendor/time/src/format_description/borrowed_format_item.rs
deleted file mode 100644
index 2e97efd4..00000000
--- a/vendor/time/src/format_description/borrowed_format_item.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-//! A format item with borrowed data.
-
-#[cfg(feature = "alloc")]
-use alloc::string::String;
-#[cfg(feature = "alloc")]
-use core::fmt;
-
-use crate::error;
-use crate::format_description::Component;
-
-/// A complete description of how to format and parse a type.
-#[non_exhaustive]
-#[cfg_attr(not(feature = "alloc"), derive(Debug))]
-#[derive(Clone, PartialEq, Eq)]
-pub enum BorrowedFormatItem<'a> {
-    /// Bytes that are formatted as-is.
-    ///
-    /// **Note**: These bytes **should** be UTF-8, but are not required to be. The value is passed
-    /// through `String::from_utf8_lossy` when necessary.
-    Literal(&'a [u8]),
-    /// A minimal representation of a single non-literal item.
-    Component(Component),
-    /// A series of literals or components that collectively form a partial or complete
-    /// description.
-    Compound(&'a [Self]),
-    /// A `FormatItem` that may or may not be present when parsing. If parsing fails, there
-    /// will be no effect on the resulting `struct`.
-    ///
-    /// This variant has no effect on formatting, as the value is guaranteed to be present.
-    Optional(&'a Self),
-    /// A series of `FormatItem`s where, when parsing, the first successful parse is used. When
-    /// formatting, the first element of the slice is used.  An empty slice is a no-op when
-    /// formatting or parsing.
-    First(&'a [Self]),
-}
-
-#[cfg(feature = "alloc")]
-impl fmt::Debug for BorrowedFormatItem<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Literal(literal) => f.write_str(&String::from_utf8_lossy(literal)),
-            Self::Component(component) => component.fmt(f),
-            Self::Compound(compound) => compound.fmt(f),
-            Self::Optional(item) => f.debug_tuple("Optional").field(item).finish(),
-            Self::First(items) => f.debug_tuple("First").field(items).finish(),
-        }
-    }
-}
-
-impl From<Component> for BorrowedFormatItem<'_> {
-    fn from(component: Component) -> Self {
-        Self::Component(component)
-    }
-}
-
-impl TryFrom<BorrowedFormatItem<'_>> for Component {
-    type Error = error::DifferentVariant;
-
-    fn try_from(value: BorrowedFormatItem<'_>) -> Result<Self, Self::Error> {
-        match value {
-            BorrowedFormatItem::Component(component) => Ok(component),
-            _ => Err(error::DifferentVariant),
-        }
-    }
-}
-
-impl<'a> From<&'a [BorrowedFormatItem<'_>]> for BorrowedFormatItem<'a> {
-    fn from(items: &'a [BorrowedFormatItem<'_>]) -> Self {
-        Self::Compound(items)
-    }
-}
-
-impl<'a> TryFrom<BorrowedFormatItem<'a>> for &[BorrowedFormatItem<'a>] {
-    type Error = error::DifferentVariant;
-
-    fn try_from(value: BorrowedFormatItem<'a>) -> Result<Self, Self::Error> {
-        match value {
-            BorrowedFormatItem::Compound(items) => Ok(items),
-            _ => Err(error::DifferentVariant),
-        }
-    }
-}
-
-impl PartialEq<Component> for BorrowedFormatItem<'_> {
-    fn eq(&self, rhs: &Component) -> bool {
-        matches!(self, Self::Component(component) if component == rhs)
-    }
-}
-
-impl PartialEq<BorrowedFormatItem<'_>> for Component {
-    fn eq(&self, rhs: &BorrowedFormatItem<'_>) -> bool {
-        rhs == self
-    }
-}
-
-impl PartialEq<&[Self]> for BorrowedFormatItem<'_> {
-    fn eq(&self, rhs: &&[Self]) -> bool {
-        matches!(self, Self::Compound(compound) if compound == rhs)
-    }
-}
-
-impl PartialEq<BorrowedFormatItem<'_>> for &[BorrowedFormatItem<'_>] {
-    fn eq(&self, rhs: &BorrowedFormatItem<'_>) -> bool {
-        rhs == self
-    }
-}
diff --git a/vendor/time/src/format_description/component.rs b/vendor/time/src/format_description/component.rs
deleted file mode 100644
index 9119c090..00000000
--- a/vendor/time/src/format_description/component.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//! Part of a format description.
-
-use crate::format_description::modifier;
-
-/// A component of a larger format description.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Component {
-    /// Day of the month.
-    Day(modifier::Day),
-    /// Month of the year.
-    Month(modifier::Month),
-    /// Ordinal day of the year.
-    Ordinal(modifier::Ordinal),
-    /// Day of the week.
-    Weekday(modifier::Weekday),
-    /// Week within the year.
-    WeekNumber(modifier::WeekNumber),
-    /// Year of the date.
-    Year(modifier::Year),
-    /// Hour of the day.
-    Hour(modifier::Hour),
-    /// Minute within the hour.
-    Minute(modifier::Minute),
-    /// AM/PM part of the time.
-    Period(modifier::Period),
-    /// Second within the minute.
-    Second(modifier::Second),
-    /// Subsecond within the second.
-    Subsecond(modifier::Subsecond),
-    /// Hour of the UTC offset.
-    OffsetHour(modifier::OffsetHour),
-    /// Minute within the hour of the UTC offset.
-    OffsetMinute(modifier::OffsetMinute),
-    /// Second within the minute of the UTC offset.
-    OffsetSecond(modifier::OffsetSecond),
-    /// A number of bytes to ignore when parsing. This has no effect on formatting.
-    Ignore(modifier::Ignore),
-    /// A Unix timestamp.
-    UnixTimestamp(modifier::UnixTimestamp),
-    /// The end of input. Parsing this component will fail if there is any input remaining. This
-    /// component neither affects formatting nor consumes any input when parsing.
-    End(modifier::End),
-}
diff --git a/vendor/time/src/format_description/mod.rs b/vendor/time/src/format_description/mod.rs
deleted file mode 100644
index 9e7d5202..00000000
--- a/vendor/time/src/format_description/mod.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-//! Description of how types should be formatted and parsed.
-//!
-//! The formatted value will be output to the provided writer. Format descriptions can be
-//! [well-known](crate::format_description::well_known) or obtained by using the
-//! [`format_description!`](crate::macros::format_description) macro or a function listed below.
-//!
-//! For examples, see the implementors of [Formattable](crate::formatting::Formattable),
-//! e.g. [`well_known::Rfc3339`].
-
-mod borrowed_format_item;
-mod component;
-pub mod modifier;
-#[cfg(feature = "alloc")]
-mod owned_format_item;
-#[cfg(feature = "alloc")]
-mod parse;
-
-pub use borrowed_format_item::BorrowedFormatItem;
-#[doc(hidden)]
-#[deprecated(since = "0.3.37", note = "use `BorrowedFormatItem` for clarity")]
-pub use borrowed_format_item::BorrowedFormatItem as FormatItem;
-#[cfg(feature = "alloc")]
-pub use owned_format_item::OwnedFormatItem;
-
-pub use self::component::Component;
-#[cfg(feature = "alloc")]
-pub use self::parse::{
-    parse, parse_borrowed, parse_owned, parse_strftime_borrowed, parse_strftime_owned,
-};
-
-/// Well-known formats, typically standards.
-pub mod well_known {
-    pub mod iso8601;
-    mod rfc2822;
-    mod rfc3339;
-
-    #[doc(inline)]
-    pub use iso8601::Iso8601;
-    pub use rfc2822::Rfc2822;
-    pub use rfc3339::Rfc3339;
-}
diff --git a/vendor/time/src/format_description/modifier.rs b/vendor/time/src/format_description/modifier.rs
deleted file mode 100644
index 82fca805..00000000
--- a/vendor/time/src/format_description/modifier.rs
+++ /dev/null
@@ -1,434 +0,0 @@
-//! Various modifiers for components.
-
-use core::num::NonZeroU16;
-
-/// Day of the month.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Day {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-}
-
-/// The representation of a month.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum MonthRepr {
-    /// The number of the month (January is 1, December is 12).
-    Numerical,
-    /// The long form of the month name (e.g. "January").
-    Long,
-    /// The short form of the month name (e.g. "Jan").
-    Short,
-}
-
-/// Month of the year.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Month {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-    /// What form of representation should be used?
-    pub repr: MonthRepr,
-    /// Is the value case sensitive when parsing?
-    pub case_sensitive: bool,
-}
-
-/// Ordinal day of the year.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Ordinal {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-}
-
-/// The representation used for the day of the week.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum WeekdayRepr {
-    /// The short form of the weekday (e.g. "Mon").
-    Short,
-    /// The long form of the weekday (e.g. "Monday").
-    Long,
-    /// A numerical representation using Sunday as the first day of the week.
-    ///
-    /// Sunday is either 0 or 1, depending on the other modifier's value.
-    Sunday,
-    /// A numerical representation using Monday as the first day of the week.
-    ///
-    /// Monday is either 0 or 1, depending on the other modifier's value.
-    Monday,
-}
-
-/// Day of the week.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Weekday {
-    /// What form of representation should be used?
-    pub repr: WeekdayRepr,
-    /// When using a numerical representation, should it be zero or one-indexed?
-    pub one_indexed: bool,
-    /// Is the value case sensitive when parsing?
-    pub case_sensitive: bool,
-}
-
-/// The representation used for the week number.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum WeekNumberRepr {
-    /// Week 1 is the week that contains January 4.
-    Iso,
-    /// Week 1 begins on the first Sunday of the calendar year.
-    Sunday,
-    /// Week 1 begins on the first Monday of the calendar year.
-    Monday,
-}
-
-/// Week within the year.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct WeekNumber {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-    /// What kind of representation should be used?
-    pub repr: WeekNumberRepr,
-}
-
-/// The representation used for a year value.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum YearRepr {
-    /// The full value of the year.
-    Full,
-    /// All digits except the last two. Includes the sign, if any.
-    Century,
-    /// Only the last two digits of the year.
-    LastTwo,
-}
-
-/// The range of years that are supported.
-///
-/// This modifier has no effect when the year repr is [`LastTwo`](YearRepr::LastTwo).
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum YearRange {
-    /// Years between -9999 and 9999 are supported.
-    Standard,
-    /// Years between -999_999 and 999_999 are supported, with the sign being required if the year
-    /// contains more than four digits.
-    ///
-    /// If the `large-dates` feature is not enabled, this variant is equivalent to `Standard`.
-    Extended,
-}
-
-/// Year of the date.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Year {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-    /// What kind of representation should be used?
-    pub repr: YearRepr,
-    /// What range of years is supported?
-    pub range: YearRange,
-    /// Whether the value is based on the ISO week number or the Gregorian calendar.
-    pub iso_week_based: bool,
-    /// Whether the `+` sign is present when a positive year contains fewer than five digits.
-    pub sign_is_mandatory: bool,
-}
-
-/// Hour of the day.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Hour {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-    /// Is the hour displayed using a 12 or 24-hour clock?
-    pub is_12_hour_clock: bool,
-}
-
-/// Minute within the hour.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Minute {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-}
-
-/// AM/PM part of the time.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Period {
-    /// Is the period uppercase or lowercase?
-    pub is_uppercase: bool,
-    /// Is the value case sensitive when parsing?
-    ///
-    /// Note that when `false`, the `is_uppercase` field has no effect on parsing behavior.
-    pub case_sensitive: bool,
-}
-
-/// Second within the minute.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Second {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-}
-
-/// The number of digits present in a subsecond representation.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum SubsecondDigits {
-    /// Exactly one digit.
-    One,
-    /// Exactly two digits.
-    Two,
-    /// Exactly three digits.
-    Three,
-    /// Exactly four digits.
-    Four,
-    /// Exactly five digits.
-    Five,
-    /// Exactly six digits.
-    Six,
-    /// Exactly seven digits.
-    Seven,
-    /// Exactly eight digits.
-    Eight,
-    /// Exactly nine digits.
-    Nine,
-    /// Any number of digits (up to nine) that is at least one. When formatting, the minimum digits
-    /// necessary will be used.
-    OneOrMore,
-}
-
-/// Subsecond within the second.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Subsecond {
-    /// How many digits are present in the component?
-    pub digits: SubsecondDigits,
-}
-
-/// Hour of the UTC offset.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct OffsetHour {
-    /// Whether the `+` sign is present on positive values.
-    pub sign_is_mandatory: bool,
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-}
-
-/// Minute within the hour of the UTC offset.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct OffsetMinute {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-}
-
-/// Second within the minute of the UTC offset.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct OffsetSecond {
-    /// The padding to obtain the minimum width.
-    pub padding: Padding,
-}
-
-/// Type of padding to ensure a minimum width.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Padding {
-    /// A space character (` `) should be used as padding.
-    Space,
-    /// A zero character (`0`) should be used as padding.
-    Zero,
-    /// There is no padding. This can result in a width below the otherwise minimum number of
-    /// characters.
-    None,
-}
-
-/// Ignore some number of bytes.
-///
-/// This has no effect when formatting.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Ignore {
-    /// The number of bytes to ignore.
-    pub count: NonZeroU16,
-}
-
-// Needed as `Default` is deliberately not implemented for `Ignore`. The number of bytes to ignore
-// must be explicitly provided.
-impl Ignore {
-    /// Create an instance of `Ignore` with the provided number of bytes to ignore.
-    pub const fn count(count: NonZeroU16) -> Self {
-        Self { count }
-    }
-}
-
-/// The precision of a Unix timestamp.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum UnixTimestampPrecision {
-    /// Seconds since the Unix epoch.
-    Second,
-    /// Milliseconds since the Unix epoch.
-    Millisecond,
-    /// Microseconds since the Unix epoch.
-    Microsecond,
-    /// Nanoseconds since the Unix epoch.
-    Nanosecond,
-}
-
-/// A Unix timestamp.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct UnixTimestamp {
-    /// The precision of the timestamp.
-    pub precision: UnixTimestampPrecision,
-    /// Whether the `+` sign must be present for a non-negative timestamp.
-    pub sign_is_mandatory: bool,
-}
-
-/// The end of input.
-///
-/// There is currently not customization for this modifier.
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct End;
-
-/// Generate the provided code if and only if `pub` is present.
-macro_rules! if_pub {
-    (pub $(#[$attr:meta])*; $($x:tt)*) => {
-        $(#[$attr])*
-        ///
-        /// This function exists since [`Default::default()`] cannot be used in a `const` context.
-        /// It may be removed once that becomes possible. As the [`Default`] trait is in the
-        /// prelude, removing this function in the future will not cause any resolution failures for
-        /// the overwhelming majority of users; only users who use `#![no_implicit_prelude]` will be
-        /// affected. As such it will not be considered a breaking change.
-        $($x)*
-    };
-    ($($_:tt)*) => {};
-}
-
-/// Implement `Default` for the given type. This also generates an inherent implementation of a
-/// `default` method that is `const fn`, permitting the default value to be used in const contexts.
-// Every modifier should use this macro rather than a derived `Default`.
-macro_rules! impl_const_default {
-    ($($(#[$doc:meta])* $(@$pub:ident)? $type:ty => $default:expr;)*) => {$(
-        impl $type {
-            if_pub! {
-                $($pub)?
-                $(#[$doc])*;
-                pub const fn default() -> Self {
-                    $default
-                }
-            }
-        }
-
-        $(#[$doc])*
-        impl Default for $type {
-            fn default() -> Self {
-                $default
-            }
-        }
-    )*};
-}
-
-impl_const_default! {
-    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
-    @pub Day => Self { padding: Padding::Zero };
-    /// Creates a modifier that indicates the value uses the
-    /// [`Numerical`](Self::Numerical) representation.
-    MonthRepr => Self::Numerical;
-    /// Creates an instance of this type that indicates the value uses the
-    /// [`Numerical`](MonthRepr::Numerical) representation, is [padded with zeroes](Padding::Zero),
-    /// and is case-sensitive when parsing.
-    @pub Month => Self {
-        padding: Padding::Zero,
-        repr: MonthRepr::Numerical,
-        case_sensitive: true,
-    };
-    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
-    @pub Ordinal => Self { padding: Padding::Zero };
-    /// Creates a modifier that indicates the value uses the [`Long`](Self::Long) representation.
-    WeekdayRepr => Self::Long;
-    /// Creates a modifier that indicates the value uses the [`Long`](WeekdayRepr::Long)
-    /// representation and is case-sensitive when parsing. If the representation is changed to a
-    /// numerical one, the instance defaults to one-based indexing.
-    @pub Weekday => Self {
-        repr: WeekdayRepr::Long,
-        one_indexed: true,
-        case_sensitive: true,
-    };
-    /// Creates a modifier that indicates that the value uses the [`Iso`](Self::Iso) representation.
-    WeekNumberRepr => Self::Iso;
-    /// Creates a modifier that indicates that the value is [padded with zeroes](Padding::Zero)
-            /// and uses the [`Iso`](WeekNumberRepr::Iso) representation.
-    @pub WeekNumber => Self {
-        padding: Padding::Zero,
-        repr: WeekNumberRepr::Iso,
-    };
-    /// Creates a modifier that indicates the value uses the [`Full`](Self::Full) representation.
-    YearRepr => Self::Full;
-    /// Creates a modifier that indicates the value uses the [`Extended`](Self::Extended) range.
-    YearRange => Self::Extended;
-    /// Creates a modifier that indicates the value uses the [`Full`](YearRepr::Full)
-    /// representation, is [padded with zeroes](Padding::Zero), uses the Gregorian calendar as its
-    /// base, and only includes the year's sign if necessary.
-    @pub Year => Self {
-        padding: Padding::Zero,
-        repr: YearRepr::Full,
-        range: YearRange::Extended,
-        iso_week_based: false,
-        sign_is_mandatory: false,
-    };
-    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero) and
-    /// has the 24-hour representation.
-    @pub Hour => Self {
-        padding: Padding::Zero,
-        is_12_hour_clock: false,
-    };
-    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
-    @pub Minute => Self { padding: Padding::Zero };
-    /// Creates a modifier that indicates the value uses the upper-case representation and is
-    /// case-sensitive when parsing.
-    @pub Period => Self {
-        is_uppercase: true,
-        case_sensitive: true,
-    };
-    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
-    @pub Second => Self { padding: Padding::Zero };
-    /// Creates a modifier that indicates the stringified value contains [one or more
-    /// digits](Self::OneOrMore).
-    SubsecondDigits => Self::OneOrMore;
-    /// Creates a modifier that indicates the stringified value contains [one or more
-    /// digits](SubsecondDigits::OneOrMore).
-    @pub Subsecond => Self { digits: SubsecondDigits::OneOrMore };
-    /// Creates a modifier that indicates the value only uses a sign for negative values and is
-    /// [padded with zeroes](Padding::Zero).
-    @pub OffsetHour => Self {
-        sign_is_mandatory: false,
-        padding: Padding::Zero,
-    };
-    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
-    @pub OffsetMinute => Self { padding: Padding::Zero };
-    /// Creates a modifier that indicates the value is [padded with zeroes](Padding::Zero).
-    @pub OffsetSecond => Self { padding: Padding::Zero };
-    /// Creates a modifier that indicates the value is [padded with zeroes](Self::Zero).
-    Padding => Self::Zero;
-    /// Creates a modifier that indicates the value represents the [number of seconds](Self::Second)
-    /// since the Unix epoch.
-    UnixTimestampPrecision => Self::Second;
-    /// Creates a modifier that indicates the value represents the [number of
-    /// seconds](UnixTimestampPrecision::Second) since the Unix epoch. The sign is not mandatory.
-    @pub UnixTimestamp => Self {
-        precision: UnixTimestampPrecision::Second,
-        sign_is_mandatory: false,
-    };
-    /// Creates a modifier used to represent the end of input.
-    @pub End => End;
-}
diff --git a/vendor/time/src/format_description/owned_format_item.rs b/vendor/time/src/format_description/owned_format_item.rs
deleted file mode 100644
index 391e76f0..00000000
--- a/vendor/time/src/format_description/owned_format_item.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-//! A format item with owned data.
-
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::fmt;
-
-use crate::error;
-use crate::format_description::{BorrowedFormatItem, Component};
-
-/// A complete description of how to format and parse a type.
-#[non_exhaustive]
-#[derive(Clone, PartialEq, Eq)]
-pub enum OwnedFormatItem {
-    /// Bytes that are formatted as-is.
-    ///
-    /// **Note**: These bytes **should** be UTF-8, but are not required to be. The value is passed
-    /// through `String::from_utf8_lossy` when necessary.
-    Literal(Box<[u8]>),
-    /// A minimal representation of a single non-literal item.
-    Component(Component),
-    /// A series of literals or components that collectively form a partial or complete
-    /// description.
-    Compound(Box<[Self]>),
-    /// A `FormatItem` that may or may not be present when parsing. If parsing fails, there
-    /// will be no effect on the resulting `struct`.
-    ///
-    /// This variant has no effect on formatting, as the value is guaranteed to be present.
-    Optional(Box<Self>),
-    /// A series of `FormatItem`s where, when parsing, the first successful parse is used. When
-    /// formatting, the first element of the [`Vec`] is used. An empty [`Vec`] is a no-op when
-    /// formatting or parsing.
-    First(Box<[Self]>),
-}
-
-impl fmt::Debug for OwnedFormatItem {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Literal(literal) => f.write_str(&String::from_utf8_lossy(literal)),
-            Self::Component(component) => component.fmt(f),
-            Self::Compound(compound) => compound.fmt(f),
-            Self::Optional(item) => f.debug_tuple("Optional").field(item).finish(),
-            Self::First(items) => f.debug_tuple("First").field(items).finish(),
-        }
-    }
-}
-
-impl From<BorrowedFormatItem<'_>> for OwnedFormatItem {
-    fn from(item: BorrowedFormatItem<'_>) -> Self {
-        (&item).into()
-    }
-}
-
-impl From<&BorrowedFormatItem<'_>> for OwnedFormatItem {
-    fn from(item: &BorrowedFormatItem<'_>) -> Self {
-        match item {
-            BorrowedFormatItem::Literal(literal) => {
-                Self::Literal(literal.to_vec().into_boxed_slice())
-            }
-            BorrowedFormatItem::Component(component) => Self::Component(*component),
-            BorrowedFormatItem::Compound(compound) => Self::Compound(
-                compound
-                    .iter()
-                    .cloned()
-                    .map(Into::into)
-                    .collect::<Vec<_>>()
-                    .into_boxed_slice(),
-            ),
-            BorrowedFormatItem::Optional(item) => Self::Optional(Box::new((*item).into())),
-            BorrowedFormatItem::First(items) => Self::First(
-                items
-                    .iter()
-                    .cloned()
-                    .map(Into::into)
-                    .collect::<Vec<_>>()
-                    .into_boxed_slice(),
-            ),
-        }
-    }
-}
-
-impl From<Vec<BorrowedFormatItem<'_>>> for OwnedFormatItem {
-    fn from(items: Vec<BorrowedFormatItem<'_>>) -> Self {
-        items.as_slice().into()
-    }
-}
-
-impl<'a, T: AsRef<[BorrowedFormatItem<'a>]> + ?Sized> From<&T> for OwnedFormatItem {
-    fn from(items: &T) -> Self {
-        Self::Compound(
-            items
-                .as_ref()
-                .iter()
-                .cloned()
-                .map(Into::into)
-                .collect::<Vec<_>>()
-                .into_boxed_slice(),
-        )
-    }
-}
-
-impl From<Component> for OwnedFormatItem {
-    fn from(component: Component) -> Self {
-        Self::Component(component)
-    }
-}
-
-impl TryFrom<OwnedFormatItem> for Component {
-    type Error = error::DifferentVariant;
-
-    fn try_from(value: OwnedFormatItem) -> Result<Self, Self::Error> {
-        match value {
-            OwnedFormatItem::Component(component) => Ok(component),
-            _ => Err(error::DifferentVariant),
-        }
-    }
-}
-
-impl From<Vec<Self>> for OwnedFormatItem {
-    fn from(items: Vec<Self>) -> Self {
-        Self::Compound(items.into_boxed_slice())
-    }
-}
-
-impl TryFrom<OwnedFormatItem> for Vec<OwnedFormatItem> {
-    type Error = error::DifferentVariant;
-
-    fn try_from(value: OwnedFormatItem) -> Result<Self, Self::Error> {
-        match value {
-            OwnedFormatItem::Compound(items) => Ok(items.into_vec()),
-            _ => Err(error::DifferentVariant),
-        }
-    }
-}
-
-impl PartialEq<Component> for OwnedFormatItem {
-    fn eq(&self, rhs: &Component) -> bool {
-        matches!(self, Self::Component(component) if component == rhs)
-    }
-}
-
-impl PartialEq<OwnedFormatItem> for Component {
-    fn eq(&self, rhs: &OwnedFormatItem) -> bool {
-        rhs == self
-    }
-}
-
-impl PartialEq<&[Self]> for OwnedFormatItem {
-    fn eq(&self, rhs: &&[Self]) -> bool {
-        matches!(self, Self::Compound(compound) if &&**compound == rhs)
-    }
-}
-
-impl PartialEq<OwnedFormatItem> for &[OwnedFormatItem] {
-    fn eq(&self, rhs: &OwnedFormatItem) -> bool {
-        rhs == self
-    }
-}
diff --git a/vendor/time/src/format_description/parse/ast.rs b/vendor/time/src/format_description/parse/ast.rs
deleted file mode 100644
index cf13de89..00000000
--- a/vendor/time/src/format_description/parse/ast.rs
+++ /dev/null
@@ -1,384 +0,0 @@
-//! AST for parsing format descriptions.
-
-use alloc::boxed::Box;
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::iter;
-
-use super::{lexer, unused, Error, Location, Spanned, SpannedValue, Unused};
-use crate::internal_macros::bug;
-
-/// One part of a complete format description.
-pub(super) enum Item<'a> {
-    /// A literal string, formatted and parsed as-is.
-    ///
-    /// This should never be present inside a nested format description.
-    Literal(Spanned<&'a [u8]>),
-    /// A sequence of brackets. The first acts as the escape character.
-    ///
-    /// This should never be present if the lexer has `BACKSLASH_ESCAPE` set to `true`.
-    EscapedBracket {
-        /// The first bracket.
-        _first: Unused<Location>,
-        /// The second bracket.
-        _second: Unused<Location>,
-    },
-    /// Part of a type, along with its modifiers.
-    Component {
-        /// Where the opening bracket was in the format string.
-        _opening_bracket: Unused<Location>,
-        /// Whitespace between the opening bracket and name.
-        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
-        /// The name of the component.
-        name: Spanned<&'a [u8]>,
-        /// The modifiers for the component.
-        modifiers: Box<[Modifier<'a>]>,
-        /// Whitespace between the modifiers and closing bracket.
-        _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
-        /// Where the closing bracket was in the format string.
-        _closing_bracket: Unused<Location>,
-    },
-    /// An optional sequence of items.
-    Optional {
-        /// Where the opening bracket was in the format string.
-        opening_bracket: Location,
-        /// Whitespace between the opening bracket and "optional".
-        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
-        /// The "optional" keyword.
-        _optional_kw: Unused<Spanned<&'a [u8]>>,
-        /// Whitespace between the "optional" keyword and the opening bracket.
-        _whitespace: Unused<Spanned<&'a [u8]>>,
-        /// The items within the optional sequence.
-        nested_format_description: NestedFormatDescription<'a>,
-        /// Where the closing bracket was in the format string.
-        closing_bracket: Location,
-    },
-    /// The first matching parse of a sequence of items.
-    First {
-        /// Where the opening bracket was in the format string.
-        opening_bracket: Location,
-        /// Whitespace between the opening bracket and "first".
-        _leading_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
-        /// The "first" keyword.
-        _first_kw: Unused<Spanned<&'a [u8]>>,
-        /// Whitespace between the "first" keyword and the opening bracket.
-        _whitespace: Unused<Spanned<&'a [u8]>>,
-        /// The sequences of items to try.
-        nested_format_descriptions: Box<[NestedFormatDescription<'a>]>,
-        /// Where the closing bracket was in the format string.
-        closing_bracket: Location,
-    },
-}
-
-/// A format description that is nested within another format description.
-pub(super) struct NestedFormatDescription<'a> {
-    /// Where the opening bracket was in the format string.
-    pub(super) _opening_bracket: Unused<Location>,
-    /// The items within the nested format description.
-    pub(super) items: Box<[Item<'a>]>,
-    /// Where the closing bracket was in the format string.
-    pub(super) _closing_bracket: Unused<Location>,
-    /// Whitespace between the closing bracket and the next item.
-    pub(super) _trailing_whitespace: Unused<Option<Spanned<&'a [u8]>>>,
-}
-
-/// A modifier for a component.
-pub(super) struct Modifier<'a> {
-    /// Whitespace preceding the modifier.
-    pub(super) _leading_whitespace: Unused<Spanned<&'a [u8]>>,
-    /// The key of the modifier.
-    pub(super) key: Spanned<&'a [u8]>,
-    /// Where the colon of the modifier was in the format string.
-    pub(super) _colon: Unused<Location>,
-    /// The value of the modifier.
-    pub(super) value: Spanned<&'a [u8]>,
-}
-
-/// Parse the provided tokens into an AST.
-pub(super) fn parse<
-    'item: 'iter,
-    'iter,
-    I: Iterator<Item = Result<lexer::Token<'item>, Error>>,
-    const VERSION: usize,
->(
-    tokens: &'iter mut lexer::Lexed<I>,
-) -> impl Iterator<Item = Result<Item<'item>, Error>> + 'iter {
-    validate_version!(VERSION);
-    parse_inner::<_, false, VERSION>(tokens)
-}
-
-/// Parse the provided tokens into an AST. The const generic indicates whether the resulting
-/// [`Item`] will be used directly or as part of a [`NestedFormatDescription`].
-fn parse_inner<
-    'item,
-    I: Iterator<Item = Result<lexer::Token<'item>, Error>>,
-    const NESTED: bool,
-    const VERSION: usize,
->(
-    tokens: &mut lexer::Lexed<I>,
-) -> impl Iterator<Item = Result<Item<'item>, Error>> + '_ {
-    validate_version!(VERSION);
-    iter::from_fn(move || {
-        if NESTED && tokens.peek_closing_bracket().is_some() {
-            return None;
-        }
-
-        let next = match tokens.next()? {
-            Ok(token) => token,
-            Err(err) => return Some(Err(err)),
-        };
-
-        Some(match next {
-            lexer::Token::Literal(Spanned { value: _, span: _ }) if NESTED => {
-                bug!("literal should not be present in nested description")
-            }
-            lexer::Token::Literal(value) => Ok(Item::Literal(value)),
-            lexer::Token::Bracket {
-                kind: lexer::BracketKind::Opening,
-                location,
-            } => {
-                if version!(..=1) {
-                    if let Some(second_location) = tokens.next_if_opening_bracket() {
-                        Ok(Item::EscapedBracket {
-                            _first: unused(location),
-                            _second: unused(second_location),
-                        })
-                    } else {
-                        parse_component::<_, VERSION>(location, tokens)
-                    }
-                } else {
-                    parse_component::<_, VERSION>(location, tokens)
-                }
-            }
-            lexer::Token::Bracket {
-                kind: lexer::BracketKind::Closing,
-                location: _,
-            } if NESTED => {
-                bug!("closing bracket should be caught by the `if` statement")
-            }
-            lexer::Token::Bracket {
-                kind: lexer::BracketKind::Closing,
-                location: _,
-            } => {
-                bug!("closing bracket should have been consumed by `parse_component`")
-            }
-            lexer::Token::ComponentPart {
-                kind: _, // whitespace is significant in nested components
-                value,
-            } if NESTED => Ok(Item::Literal(value)),
-            lexer::Token::ComponentPart { kind: _, value: _ } => {
-                bug!("component part should have been consumed by `parse_component`")
-            }
-        })
-    })
-}
-
-/// Parse a component. This assumes that the opening bracket has already been consumed.
-fn parse_component<
-    'a,
-    I: Iterator<Item = Result<lexer::Token<'a>, Error>>,
-    const VERSION: usize,
->(
-    opening_bracket: Location,
-    tokens: &mut lexer::Lexed<I>,
-) -> Result<Item<'a>, Error> {
-    validate_version!(VERSION);
-    let leading_whitespace = tokens.next_if_whitespace();
-
-    let Some(name) = tokens.next_if_not_whitespace() else {
-        let span = match leading_whitespace {
-            Some(Spanned { value: _, span }) => span,
-            None => opening_bracket.to_self(),
-        };
-        return Err(Error {
-            _inner: unused(span.error("expected component name")),
-            public: crate::error::InvalidFormatDescription::MissingComponentName {
-                index: span.start.byte as usize,
-            },
-        });
-    };
-
-    if *name == b"optional" {
-        let Some(whitespace) = tokens.next_if_whitespace() else {
-            return Err(Error {
-                _inner: unused(name.span.error("expected whitespace after `optional`")),
-                public: crate::error::InvalidFormatDescription::Expected {
-                    what: "whitespace after `optional`",
-                    index: name.span.end.byte as usize,
-                },
-            });
-        };
-
-        let nested = parse_nested::<_, VERSION>(whitespace.span.end, tokens)?;
-
-        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
-            return Err(Error {
-                _inner: unused(opening_bracket.error("unclosed bracket")),
-                public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                    index: opening_bracket.byte as usize,
-                },
-            });
-        };
-
-        return Ok(Item::Optional {
-            opening_bracket,
-            _leading_whitespace: unused(leading_whitespace),
-            _optional_kw: unused(name),
-            _whitespace: unused(whitespace),
-            nested_format_description: nested,
-            closing_bracket,
-        });
-    }
-
-    if *name == b"first" {
-        let Some(whitespace) = tokens.next_if_whitespace() else {
-            return Err(Error {
-                _inner: unused(name.span.error("expected whitespace after `first`")),
-                public: crate::error::InvalidFormatDescription::Expected {
-                    what: "whitespace after `first`",
-                    index: name.span.end.byte as usize,
-                },
-            });
-        };
-
-        let mut nested_format_descriptions = Vec::new();
-        while let Ok(description) = parse_nested::<_, VERSION>(whitespace.span.end, tokens) {
-            nested_format_descriptions.push(description);
-        }
-
-        let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
-            return Err(Error {
-                _inner: unused(opening_bracket.error("unclosed bracket")),
-                public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                    index: opening_bracket.byte as usize,
-                },
-            });
-        };
-
-        return Ok(Item::First {
-            opening_bracket,
-            _leading_whitespace: unused(leading_whitespace),
-            _first_kw: unused(name),
-            _whitespace: unused(whitespace),
-            nested_format_descriptions: nested_format_descriptions.into_boxed_slice(),
-            closing_bracket,
-        });
-    }
-
-    let mut modifiers = Vec::new();
-    let trailing_whitespace = loop {
-        let Some(whitespace) = tokens.next_if_whitespace() else {
-            break None;
-        };
-
-        // This is not necessary for proper parsing, but provides a much better error when a nested
-        // description is used where it's not allowed.
-        if let Some(location) = tokens.next_if_opening_bracket() {
-            return Err(Error {
-                _inner: unused(
-                    location
-                        .to_self()
-                        .error("modifier must be of the form `key:value`"),
-                ),
-                public: crate::error::InvalidFormatDescription::InvalidModifier {
-                    value: String::from("["),
-                    index: location.byte as usize,
-                },
-            });
-        }
-
-        let Some(Spanned { value, span }) = tokens.next_if_not_whitespace() else {
-            break Some(whitespace);
-        };
-
-        let Some(colon_index) = value.iter().position(|&b| b == b':') else {
-            return Err(Error {
-                _inner: unused(span.error("modifier must be of the form `key:value`")),
-                public: crate::error::InvalidFormatDescription::InvalidModifier {
-                    value: String::from_utf8_lossy(value).into_owned(),
-                    index: span.start.byte as usize,
-                },
-            });
-        };
-        let key = &value[..colon_index];
-        let value = &value[colon_index + 1..];
-
-        if key.is_empty() {
-            return Err(Error {
-                _inner: unused(span.shrink_to_start().error("expected modifier key")),
-                public: crate::error::InvalidFormatDescription::InvalidModifier {
-                    value: String::new(),
-                    index: span.start.byte as usize,
-                },
-            });
-        }
-        if value.is_empty() {
-            return Err(Error {
-                _inner: unused(span.shrink_to_end().error("expected modifier value")),
-                public: crate::error::InvalidFormatDescription::InvalidModifier {
-                    value: String::new(),
-                    index: span.shrink_to_end().start.byte as usize,
-                },
-            });
-        }
-
-        modifiers.push(Modifier {
-            _leading_whitespace: unused(whitespace),
-            key: key.spanned(span.shrink_to_before(colon_index as u32)),
-            _colon: unused(span.start.offset(colon_index as u32)),
-            value: value.spanned(span.shrink_to_after(colon_index as u32)),
-        });
-    };
-
-    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
-        return Err(Error {
-            _inner: unused(opening_bracket.error("unclosed bracket")),
-            public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                index: opening_bracket.byte as usize,
-            },
-        });
-    };
-
-    Ok(Item::Component {
-        _opening_bracket: unused(opening_bracket),
-        _leading_whitespace: unused(leading_whitespace),
-        name,
-        modifiers: modifiers.into_boxed_slice(),
-        _trailing_whitespace: unused(trailing_whitespace),
-        _closing_bracket: unused(closing_bracket),
-    })
-}
-
-/// Parse a nested format description. The location provided is the the most recent one consumed.
-fn parse_nested<'a, I: Iterator<Item = Result<lexer::Token<'a>, Error>>, const VERSION: usize>(
-    last_location: Location,
-    tokens: &mut lexer::Lexed<I>,
-) -> Result<NestedFormatDescription<'a>, Error> {
-    validate_version!(VERSION);
-    let Some(opening_bracket) = tokens.next_if_opening_bracket() else {
-        return Err(Error {
-            _inner: unused(last_location.error("expected opening bracket")),
-            public: crate::error::InvalidFormatDescription::Expected {
-                what: "opening bracket",
-                index: last_location.byte as usize,
-            },
-        });
-    };
-    let items = parse_inner::<_, true, VERSION>(tokens).collect::<Result<_, _>>()?;
-    let Some(closing_bracket) = tokens.next_if_closing_bracket() else {
-        return Err(Error {
-            _inner: unused(opening_bracket.error("unclosed bracket")),
-            public: crate::error::InvalidFormatDescription::UnclosedOpeningBracket {
-                index: opening_bracket.byte as usize,
-            },
-        });
-    };
-    let trailing_whitespace = tokens.next_if_whitespace();
-
-    Ok(NestedFormatDescription {
-        _opening_bracket: unused(opening_bracket),
-        items,
-        _closing_bracket: unused(closing_bracket),
-        _trailing_whitespace: unused(trailing_whitespace),
-    })
-}
diff --git a/vendor/time/src/format_description/parse/format_item.rs b/vendor/time/src/format_description/parse/format_item.rs
deleted file mode 100644
index d401daa5..00000000
--- a/vendor/time/src/format_description/parse/format_item.rs
+++ /dev/null
@@ -1,549 +0,0 @@
-//! Typed, validated representation of a parsed format description.
-
-use alloc::boxed::Box;
-use alloc::string::String;
-use core::num::NonZeroU16;
-use core::str::{self, FromStr};
-
-use super::{ast, unused, Error, Span, Spanned};
-use crate::internal_macros::bug;
-
-/// Parse an AST iterator into a sequence of format items.
-pub(super) fn parse<'a>(
-    ast_items: impl Iterator<Item = Result<ast::Item<'a>, Error>>,
-) -> impl Iterator<Item = Result<Item<'a>, Error>> {
-    ast_items.map(|ast_item| ast_item.and_then(Item::from_ast))
-}
-
-/// A description of how to format and parse one part of a type.
-pub(super) enum Item<'a> {
-    /// A literal string.
-    Literal(&'a [u8]),
-    /// Part of a type, along with its modifiers.
-    Component(Component),
-    /// A sequence of optional items.
-    Optional {
-        /// The items themselves.
-        value: Box<[Self]>,
-        /// The span of the full sequence.
-        span: Span,
-    },
-    /// The first matching parse of a sequence of format descriptions.
-    First {
-        /// The sequence of format descriptions.
-        value: Box<[Box<[Self]>]>,
-        /// The span of the full sequence.
-        span: Span,
-    },
-}
-
-impl Item<'_> {
-    /// Parse an AST item into a format item.
-    pub(super) fn from_ast(ast_item: ast::Item<'_>) -> Result<Item<'_>, Error> {
-        Ok(match ast_item {
-            ast::Item::Component {
-                _opening_bracket: _,
-                _leading_whitespace: _,
-                name,
-                modifiers,
-                _trailing_whitespace: _,
-                _closing_bracket: _,
-            } => Item::Component(component_from_ast(&name, &modifiers)?),
-            ast::Item::Literal(Spanned { value, span: _ }) => Item::Literal(value),
-            ast::Item::EscapedBracket {
-                _first: _,
-                _second: _,
-            } => Item::Literal(b"["),
-            ast::Item::Optional {
-                opening_bracket,
-                _leading_whitespace: _,
-                _optional_kw: _,
-                _whitespace: _,
-                nested_format_description,
-                closing_bracket,
-            } => {
-                let items = nested_format_description
-                    .items
-                    .into_vec()
-                    .into_iter()
-                    .map(Item::from_ast)
-                    .collect::<Result<_, _>>()?;
-                Item::Optional {
-                    value: items,
-                    span: opening_bracket.to(closing_bracket),
-                }
-            }
-            ast::Item::First {
-                opening_bracket,
-                _leading_whitespace: _,
-                _first_kw: _,
-                _whitespace: _,
-                nested_format_descriptions,
-                closing_bracket,
-            } => {
-                let items = nested_format_descriptions
-                    .into_vec()
-                    .into_iter()
-                    .map(|nested_format_description| {
-                        nested_format_description
-                            .items
-                            .into_vec()
-                            .into_iter()
-                            .map(Item::from_ast)
-                            .collect()
-                    })
-                    .collect::<Result<_, _>>()?;
-                Item::First {
-                    value: items,
-                    span: opening_bracket.to(closing_bracket),
-                }
-            }
-        })
-    }
-}
-
-impl<'a> TryFrom<Item<'a>> for crate::format_description::BorrowedFormatItem<'a> {
-    type Error = Error;
-
-    fn try_from(item: Item<'a>) -> Result<Self, Self::Error> {
-        match item {
-            Item::Literal(literal) => Ok(Self::Literal(literal)),
-            Item::Component(component) => Ok(Self::Component(component.into())),
-            Item::Optional { value: _, span } => Err(Error {
-                _inner: unused(span.error(
-                    "optional items are not supported in runtime-parsed format descriptions",
-                )),
-                public: crate::error::InvalidFormatDescription::NotSupported {
-                    what: "optional item",
-                    context: "runtime-parsed format descriptions",
-                    index: span.start.byte as usize,
-                },
-            }),
-            Item::First { value: _, span } => Err(Error {
-                _inner: unused(span.error(
-                    "'first' items are not supported in runtime-parsed format descriptions",
-                )),
-                public: crate::error::InvalidFormatDescription::NotSupported {
-                    what: "'first' item",
-                    context: "runtime-parsed format descriptions",
-                    index: span.start.byte as usize,
-                },
-            }),
-        }
-    }
-}
-
-impl From<Item<'_>> for crate::format_description::OwnedFormatItem {
-    fn from(item: Item<'_>) -> Self {
-        match item {
-            Item::Literal(literal) => Self::Literal(literal.to_vec().into_boxed_slice()),
-            Item::Component(component) => Self::Component(component.into()),
-            Item::Optional { value, span: _ } => Self::Optional(Box::new(value.into())),
-            Item::First { value, span: _ } => {
-                Self::First(value.into_vec().into_iter().map(Into::into).collect())
-            }
-        }
-    }
-}
-
-impl<'a> From<Box<[Item<'a>]>> for crate::format_description::OwnedFormatItem {
-    fn from(items: Box<[Item<'a>]>) -> Self {
-        let items = items.into_vec();
-        match <[_; 1]>::try_from(items) {
-            Ok([item]) => item.into(),
-            Err(vec) => Self::Compound(vec.into_iter().map(Into::into).collect()),
-        }
-    }
-}
-
-/// Declare the `Component` struct.
-macro_rules! component_definition {
-    (@if_required required then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($then)* };
-    (@if_required then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($($else)*)? };
-    (@if_from_str from_str then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($then)* };
-    (@if_from_str then { $($then:tt)* } $(else { $($else:tt)* })?) => { $($($else)*)? };
-
-    ($vis:vis enum $name:ident {
-        $($variant:ident = $parse_variant:literal {$(
-            $(#[$required:tt])?
-            $field:ident = $parse_field:literal:
-            Option<$(#[$from_str:tt])? $field_type:ty>
-            => $target_field:ident
-        ),* $(,)?}),* $(,)?
-    }) => {
-        $vis enum $name {
-            $($variant($variant),)*
-        }
-
-        $($vis struct $variant {
-            $($field: Option<$field_type>),*
-        })*
-
-        $(impl $variant {
-            /// Parse the component from the AST, given its modifiers.
-            fn with_modifiers(
-                modifiers: &[ast::Modifier<'_>],
-                _component_span: Span,
-            ) -> Result<Self, Error>
-            {
-                // rustc will complain if the modifier is empty.
-                #[allow(unused_mut)]
-                let mut this = Self {
-                    $($field: None),*
-                };
-
-                for modifier in modifiers {
-                    $(#[allow(clippy::string_lit_as_bytes)]
-                    if modifier.key.eq_ignore_ascii_case($parse_field.as_bytes()) {
-                        this.$field = component_definition!(@if_from_str $($from_str)?
-                            then {
-                                parse_from_modifier_value::<$field_type>(&modifier.value)?
-                            } else {
-                                <$field_type>::from_modifier_value(&modifier.value)?
-                            });
-                        continue;
-                    })*
-                    return Err(Error {
-                        _inner: unused(modifier.key.span.error("invalid modifier key")),
-                        public: crate::error::InvalidFormatDescription::InvalidModifier {
-                            value: String::from_utf8_lossy(*modifier.key).into_owned(),
-                            index: modifier.key.span.start.byte as usize,
-                        }
-                    });
-                }
-
-                $(component_definition! { @if_required $($required)? then {
-                    if this.$field.is_none() {
-                        return Err(Error {
-                            _inner: unused(_component_span.error("missing required modifier")),
-                            public:
-                                crate::error::InvalidFormatDescription::MissingRequiredModifier {
-                                    name: $parse_field,
-                                    index: _component_span.start.byte as usize,
-                                }
-                        });
-                    }
-                }})*
-
-                Ok(this)
-            }
-        })*
-
-        impl From<$name> for crate::format_description::Component {
-            fn from(component: $name) -> Self {
-                match component {$(
-                    $name::$variant($variant { $($field),* }) => {
-                        $crate::format_description::component::Component::$variant(
-                            $crate::format_description::modifier::$variant {$(
-                                $target_field: component_definition! { @if_required $($required)?
-                                    then {
-                                        match $field {
-                                            Some(value) => value.into(),
-                                            None => bug!("required modifier was not set"),
-                                        }
-                                    } else {
-                                        $field.unwrap_or_default().into()
-                                    }
-                                }
-                            ),*}
-                        )
-                    }
-                )*}
-            }
-        }
-
-        /// Parse a component from the AST, given its name and modifiers.
-        fn component_from_ast(
-            name: &Spanned<&[u8]>,
-            modifiers: &[ast::Modifier<'_>],
-        ) -> Result<Component, Error> {
-            $(#[allow(clippy::string_lit_as_bytes)]
-            if name.eq_ignore_ascii_case($parse_variant.as_bytes()) {
-                return Ok(Component::$variant($variant::with_modifiers(&modifiers, name.span)?));
-            })*
-            Err(Error {
-                _inner: unused(name.span.error("invalid component")),
-                public: crate::error::InvalidFormatDescription::InvalidComponentName {
-                    name: String::from_utf8_lossy(name).into_owned(),
-                    index: name.span.start.byte as usize,
-                },
-            })
-        }
-    }
-}
-
-// Keep in alphabetical order.
-component_definition! {
-    pub(super) enum Component {
-        Day = "day" {
-            padding = "padding": Option<Padding> => padding,
-        },
-        End = "end" {},
-        Hour = "hour" {
-            padding = "padding": Option<Padding> => padding,
-            base = "repr": Option<HourBase> => is_12_hour_clock,
-        },
-        Ignore = "ignore" {
-            #[required]
-            count = "count": Option<#[from_str] NonZeroU16> => count,
-        },
-        Minute = "minute" {
-            padding = "padding": Option<Padding> => padding,
-        },
-        Month = "month" {
-            padding = "padding": Option<Padding> => padding,
-            repr = "repr": Option<MonthRepr> => repr,
-            case_sensitive = "case_sensitive": Option<MonthCaseSensitive> => case_sensitive,
-        },
-        OffsetHour = "offset_hour" {
-            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
-            padding = "padding": Option<Padding> => padding,
-        },
-        OffsetMinute = "offset_minute" {
-            padding = "padding": Option<Padding> => padding,
-        },
-        OffsetSecond = "offset_second" {
-            padding = "padding": Option<Padding> => padding,
-        },
-        Ordinal = "ordinal" {
-            padding = "padding": Option<Padding> => padding,
-        },
-        Period = "period" {
-            case = "case": Option<PeriodCase> => is_uppercase,
-            case_sensitive = "case_sensitive": Option<PeriodCaseSensitive> => case_sensitive,
-        },
-        Second = "second" {
-            padding = "padding": Option<Padding> => padding,
-        },
-        Subsecond = "subsecond" {
-            digits = "digits": Option<SubsecondDigits> => digits,
-        },
-        UnixTimestamp = "unix_timestamp" {
-            precision = "precision": Option<UnixTimestampPrecision> => precision,
-            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
-        },
-        Weekday = "weekday" {
-            repr = "repr": Option<WeekdayRepr> => repr,
-            one_indexed = "one_indexed": Option<WeekdayOneIndexed> => one_indexed,
-            case_sensitive = "case_sensitive": Option<WeekdayCaseSensitive> => case_sensitive,
-        },
-        WeekNumber = "week_number" {
-            padding = "padding": Option<Padding> => padding,
-            repr = "repr": Option<WeekNumberRepr> => repr,
-        },
-        Year = "year" {
-            padding = "padding": Option<Padding> => padding,
-            repr = "repr": Option<YearRepr> => repr,
-            range = "range": Option<YearRange> => range,
-            base = "base": Option<YearBase> => iso_week_based,
-            sign_behavior = "sign": Option<SignBehavior> => sign_is_mandatory,
-        },
-    }
-}
-
-/// Get the target type for a given enum.
-macro_rules! target_ty {
-    ($name:ident $type:ty) => {
-        $type
-    };
-    ($name:ident) => {
-        $crate::format_description::modifier::$name
-    };
-}
-
-/// Get the target value for a given enum.
-macro_rules! target_value {
-    ($name:ident $variant:ident $value:expr) => {
-        $value
-    };
-    ($name:ident $variant:ident) => {
-        $crate::format_description::modifier::$name::$variant
-    };
-}
-
-/// Declare the various modifiers.
-///
-/// For the general case, ordinary syntax can be used. Note that you _must_ declare a default
-/// variant. The only significant change is that the string representation of the variant must be
-/// provided after the variant name. For example, `Numerical = b"numerical"` declares a variant
-/// named `Numerical` with the string representation `b"numerical"`. This is the value that will be
-/// used when parsing the modifier. The value is not case sensitive.
-///
-/// If the type in the public API does not have the same name as the type in the internal
-/// representation, then the former must be specified in parenthesis after the internal name. For
-/// example, `HourBase(bool)` has an internal name "HourBase", but is represented as a boolean in
-/// the public API.
-///
-/// By default, the internal variant name is assumed to be the same as the public variant name. If
-/// this is not the case, the qualified path to the variant must be specified in parenthesis after
-/// the internal variant name. For example, `Twelve(true)` has an internal variant name "Twelve",
-/// but is represented as `true` in the public API.
-macro_rules! modifier {
-    ($(
-        enum $name:ident $(($target_ty:ty))? {
-            $(
-                $(#[$attr:meta])?
-                $variant:ident $(($target_value:expr))? = $parse_variant:literal
-            ),* $(,)?
-        }
-    )+) => {$(
-        #[derive(Default)]
-        enum $name {
-            $($(#[$attr])? $variant),*
-        }
-
-        impl $name {
-            /// Parse the modifier from its string representation.
-            fn from_modifier_value(value: &Spanned<&[u8]>) -> Result<Option<Self>, Error> {
-                $(if value.eq_ignore_ascii_case($parse_variant) {
-                    return Ok(Some(Self::$variant));
-                })*
-                Err(Error {
-                    _inner: unused(value.span.error("invalid modifier value")),
-                    public: crate::error::InvalidFormatDescription::InvalidModifier {
-                        value: String::from_utf8_lossy(value).into_owned(),
-                        index: value.span.start.byte as usize,
-                    },
-                })
-            }
-        }
-
-        impl From<$name> for target_ty!($name $($target_ty)?) {
-            fn from(modifier: $name) -> Self {
-                match modifier {
-                    $($name::$variant => target_value!($name $variant $($target_value)?)),*
-                }
-            }
-        }
-    )+};
-}
-
-// Keep in alphabetical order.
-modifier! {
-    enum HourBase(bool) {
-        Twelve(true) = b"12",
-        #[default]
-        TwentyFour(false) = b"24",
-    }
-
-    enum MonthCaseSensitive(bool) {
-        False(false) = b"false",
-        #[default]
-        True(true) = b"true",
-    }
-
-    enum MonthRepr {
-        #[default]
-        Numerical = b"numerical",
-        Long = b"long",
-        Short = b"short",
-    }
-
-    enum Padding {
-        Space = b"space",
-        #[default]
-        Zero = b"zero",
-        None = b"none",
-    }
-
-    enum PeriodCase(bool) {
-        Lower(false) = b"lower",
-        #[default]
-        Upper(true) = b"upper",
-    }
-
-    enum PeriodCaseSensitive(bool) {
-        False(false) = b"false",
-        #[default]
-        True(true) = b"true",
-    }
-
-    enum SignBehavior(bool) {
-        #[default]
-        Automatic(false) = b"automatic",
-        Mandatory(true) = b"mandatory",
-    }
-
-    enum SubsecondDigits {
-        One = b"1",
-        Two = b"2",
-        Three = b"3",
-        Four = b"4",
-        Five = b"5",
-        Six = b"6",
-        Seven = b"7",
-        Eight = b"8",
-        Nine = b"9",
-        #[default]
-        OneOrMore = b"1+",
-    }
-
-    enum UnixTimestampPrecision {
-        #[default]
-        Second = b"second",
-        Millisecond = b"millisecond",
-        Microsecond = b"microsecond",
-        Nanosecond = b"nanosecond",
-    }
-
-    enum WeekNumberRepr {
-        #[default]
-        Iso = b"iso",
-        Sunday = b"sunday",
-        Monday = b"monday",
-    }
-
-    enum WeekdayCaseSensitive(bool) {
-        False(false) = b"false",
-        #[default]
-        True(true) = b"true",
-    }
-
-    enum WeekdayOneIndexed(bool) {
-        False(false) = b"false",
-        #[default]
-        True(true) = b"true",
-    }
-
-    enum WeekdayRepr {
-        Short = b"short",
-        #[default]
-        Long = b"long",
-        Sunday = b"sunday",
-        Monday = b"monday",
-    }
-
-    enum YearBase(bool) {
-        #[default]
-        Calendar(false) = b"calendar",
-        IsoWeek(true) = b"iso_week",
-    }
-
-    enum YearRepr {
-        #[default]
-        Full = b"full",
-        Century = b"century",
-        LastTwo = b"last_two",
-    }
-
-    enum YearRange {
-        Standard = b"standard",
-        #[default]
-        Extended = b"extended",
-    }
-}
-
-/// Parse a modifier value using `FromStr`. Requires the modifier value to be valid UTF-8.
-fn parse_from_modifier_value<T: FromStr>(value: &Spanned<&[u8]>) -> Result<Option<T>, Error> {
-    str::from_utf8(value)
-        .ok()
-        .and_then(|val| val.parse::<T>().ok())
-        .map(|val| Some(val))
-        .ok_or_else(|| Error {
-            _inner: unused(value.span.error("invalid modifier value")),
-            public: crate::error::InvalidFormatDescription::InvalidModifier {
-                value: String::from_utf8_lossy(value).into_owned(),
-                index: value.span.start.byte as usize,
-            },
-        })
-}
diff --git a/vendor/time/src/format_description/parse/lexer.rs b/vendor/time/src/format_description/parse/lexer.rs
deleted file mode 100644
index a63722e1..00000000
--- a/vendor/time/src/format_description/parse/lexer.rs
+++ /dev/null
@@ -1,284 +0,0 @@
-//! Lexer for parsing format descriptions.
-
-use core::iter;
-
-use super::{attach_location, unused, Error, Location, Spanned, SpannedValue};
-
-/// An iterator over the lexed tokens.
-pub(super) struct Lexed<I: Iterator> {
-    /// The internal iterator.
-    iter: iter::Peekable<I>,
-}
-
-impl<I: Iterator> Iterator for Lexed<I> {
-    type Item = I::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
-    }
-}
-
-impl<'iter, 'token: 'iter, I: Iterator<Item = Result<Token<'token>, Error>> + 'iter> Lexed<I> {
-    /// Peek at the next item in the iterator.
-    pub(super) fn peek(&mut self) -> Option<&I::Item> {
-        self.iter.peek()
-    }
-
-    /// Consume the next token if it is whitespace.
-    pub(super) fn next_if_whitespace(&mut self) -> Option<Spanned<&'token [u8]>> {
-        if let Some(&Ok(Token::ComponentPart {
-            kind: ComponentKind::Whitespace,
-            value,
-        })) = self.peek()
-        {
-            self.next(); // consume
-            Some(value)
-        } else {
-            None
-        }
-    }
-
-    /// Consume the next token if it is a component item that is not whitespace.
-    pub(super) fn next_if_not_whitespace(&mut self) -> Option<Spanned<&'token [u8]>> {
-        if let Some(&Ok(Token::ComponentPart {
-            kind: ComponentKind::NotWhitespace,
-            value,
-        })) = self.peek()
-        {
-            self.next(); // consume
-            Some(value)
-        } else {
-            None
-        }
-    }
-
-    /// Consume the next token if it is an opening bracket.
-    pub(super) fn next_if_opening_bracket(&mut self) -> Option<Location> {
-        if let Some(&Ok(Token::Bracket {
-            kind: BracketKind::Opening,
-            location,
-        })) = self.peek()
-        {
-            self.next(); // consume
-            Some(location)
-        } else {
-            None
-        }
-    }
-
-    /// Peek at the next token if it is a closing bracket.
-    pub(super) fn peek_closing_bracket(&'iter mut self) -> Option<&'iter Location> {
-        if let Some(Ok(Token::Bracket {
-            kind: BracketKind::Closing,
-            location,
-        })) = self.peek()
-        {
-            Some(location)
-        } else {
-            None
-        }
-    }
-
-    /// Consume the next token if it is a closing bracket.
-    pub(super) fn next_if_closing_bracket(&mut self) -> Option<Location> {
-        if let Some(&Ok(Token::Bracket {
-            kind: BracketKind::Closing,
-            location,
-        })) = self.peek()
-        {
-            self.next(); // consume
-            Some(location)
-        } else {
-            None
-        }
-    }
-}
-
-/// A token emitted by the lexer. There is no semantic meaning at this stage.
-pub(super) enum Token<'a> {
-    /// A literal string, formatted and parsed as-is.
-    Literal(Spanned<&'a [u8]>),
-    /// An opening or closing bracket. May or may not be the start or end of a component.
-    Bracket {
-        /// Whether the bracket is opening or closing.
-        kind: BracketKind,
-        /// Where the bracket was in the format string.
-        location: Location,
-    },
-    /// One part of a component. This could be its name, a modifier, or whitespace.
-    ComponentPart {
-        /// Whether the part is whitespace or not.
-        kind: ComponentKind,
-        /// The part itself.
-        value: Spanned<&'a [u8]>,
-    },
-}
-
-/// What type of bracket is present.
-pub(super) enum BracketKind {
-    /// An opening bracket: `[`
-    Opening,
-    /// A closing bracket: `]`
-    Closing,
-}
-
-/// Indicates whether the component is whitespace or not.
-pub(super) enum ComponentKind {
-    Whitespace,
-    NotWhitespace,
-}
-
-/// Parse the string into a series of [`Token`]s.
-///
-/// `VERSION` controls the version of the format description that is being parsed. Currently, this
-/// must be 1 or 2.
-///
-/// - When `VERSION` is 1, `[[` is the only escape sequence, resulting in a literal `[`.
-/// - When `VERSION` is 2, all escape sequences begin with `\`. The only characters that may
-///   currently follow are `\`, `[`, and `]`, all of which result in the literal character. All
-///   other characters result in a lex error.
-pub(super) fn lex<const VERSION: usize>(
-    mut input: &[u8],
-) -> Lexed<impl Iterator<Item = Result<Token<'_>, Error>>> {
-    validate_version!(VERSION);
-
-    let mut depth: u8 = 0;
-    let mut iter = attach_location(input.iter()).peekable();
-    let mut second_bracket_location = None;
-
-    let iter = iter::from_fn(move || {
-        // The flag is only set when version is zero.
-        if version!(..=1) {
-            // There is a flag set to emit the second half of an escaped bracket pair.
-            if let Some(location) = second_bracket_location.take() {
-                return Some(Ok(Token::Bracket {
-                    kind: BracketKind::Opening,
-                    location,
-                }));
-            }
-        }
-
-        Some(Ok(match iter.next()? {
-            // possible escape sequence
-            (b'\\', backslash_loc) if version!(2..) => {
-                match iter.next() {
-                    Some((b'\\' | b'[' | b']', char_loc)) => {
-                        // The escaped character is emitted as-is.
-                        let char = &input[1..2];
-                        input = &input[2..];
-                        if depth == 0 {
-                            Token::Literal(char.spanned(backslash_loc.to(char_loc)))
-                        } else {
-                            Token::ComponentPart {
-                                kind: ComponentKind::NotWhitespace,
-                                value: char.spanned(backslash_loc.to(char_loc)),
-                            }
-                        }
-                    }
-                    Some((_, loc)) => {
-                        return Some(Err(Error {
-                            _inner: unused(loc.error("invalid escape sequence")),
-                            public: crate::error::InvalidFormatDescription::Expected {
-                                what: "valid escape sequence",
-                                index: loc.byte as usize,
-                            },
-                        }));
-                    }
-                    None => {
-                        return Some(Err(Error {
-                            _inner: unused(backslash_loc.error("unexpected end of input")),
-                            public: crate::error::InvalidFormatDescription::Expected {
-                                what: "valid escape sequence",
-                                index: backslash_loc.byte as usize,
-                            },
-                        }));
-                    }
-                }
-            }
-            // potentially escaped opening bracket
-            (b'[', location) if version!(..=1) => {
-                if let Some((_, second_location)) = iter.next_if(|&(&byte, _)| byte == b'[') {
-                    // Escaped bracket. Store the location of the second so we can emit it later.
-                    second_bracket_location = Some(second_location);
-                    input = &input[2..];
-                } else {
-                    // opening bracket
-                    depth += 1;
-                    input = &input[1..];
-                }
-
-                Token::Bracket {
-                    kind: BracketKind::Opening,
-                    location,
-                }
-            }
-            // opening bracket
-            (b'[', location) => {
-                depth += 1;
-                input = &input[1..];
-
-                Token::Bracket {
-                    kind: BracketKind::Opening,
-                    location,
-                }
-            }
-            // closing bracket
-            (b']', location) if depth > 0 => {
-                depth -= 1;
-                input = &input[1..];
-
-                Token::Bracket {
-                    kind: BracketKind::Closing,
-                    location,
-                }
-            }
-            // literal
-            (_, start_location) if depth == 0 => {
-                let mut bytes = 1;
-                let mut end_location = start_location;
-
-                while let Some((_, location)) =
-                    iter.next_if(|&(&byte, _)| !((version!(2..) && byte == b'\\') || byte == b'['))
-                {
-                    end_location = location;
-                    bytes += 1;
-                }
-
-                let value = &input[..bytes];
-                input = &input[bytes..];
-
-                Token::Literal(value.spanned(start_location.to(end_location)))
-            }
-            // component part
-            (byte, start_location) => {
-                let mut bytes = 1;
-                let mut end_location = start_location;
-                let is_whitespace = byte.is_ascii_whitespace();
-
-                while let Some((_, location)) = iter.next_if(|&(byte, _)| {
-                    !matches!(byte, b'\\' | b'[' | b']')
-                        && is_whitespace == byte.is_ascii_whitespace()
-                }) {
-                    end_location = location;
-                    bytes += 1;
-                }
-
-                let value = &input[..bytes];
-                input = &input[bytes..];
-
-                Token::ComponentPart {
-                    kind: if is_whitespace {
-                        ComponentKind::Whitespace
-                    } else {
-                        ComponentKind::NotWhitespace
-                    },
-                    value: value.spanned(start_location.to(end_location)),
-                }
-            }
-        }))
-    });
-
-    Lexed {
-        iter: iter.peekable(),
-    }
-}
diff --git a/vendor/time/src/format_description/parse/mod.rs b/vendor/time/src/format_description/parse/mod.rs
deleted file mode 100644
index d058594d..00000000
--- a/vendor/time/src/format_description/parse/mod.rs
+++ /dev/null
@@ -1,262 +0,0 @@
-//! Parser for format descriptions.
-
-use alloc::boxed::Box;
-use alloc::vec::Vec;
-
-pub use self::strftime::{parse_strftime_borrowed, parse_strftime_owned};
-use crate::{error, format_description};
-
-/// A helper macro to make version restrictions simpler to read and write.
-macro_rules! version {
-    ($range:expr) => {
-        $range.contains(&VERSION)
-    };
-}
-
-/// A helper macro to statically validate the version (when used as a const parameter).
-macro_rules! validate_version {
-    ($version:ident) => {
-        let _ = $crate::format_description::parse::Version::<$version>::IS_VALID;
-    };
-}
-
-mod ast;
-mod format_item;
-mod lexer;
-mod strftime;
-
-/// A struct that is used to ensure that the version is valid.
-struct Version<const N: usize>;
-impl<const N: usize> Version<N> {
-    /// A constant that panics if the version is not valid. This results in a post-monomorphization
-    /// error.
-    const IS_VALID: () = assert!(N >= 1 && N <= 2);
-}
-
-/// Parse a sequence of items from the format description.
-///
-/// The syntax for the format description can be found in [the
-/// book](https://time-rs.github.io/book/api/format-description.html).
-///
-/// This function exists for backward compatibility reasons. It is equivalent to calling
-/// `parse_borrowed::<1>(s)`. In the future, this function will be deprecated in favor of
-/// `parse_borrowed`.
-pub fn parse(
-    s: &str,
-) -> Result<Vec<format_description::BorrowedFormatItem<'_>>, error::InvalidFormatDescription> {
-    parse_borrowed::<1>(s)
-}
-
-/// Parse a sequence of items from the format description.
-///
-/// The syntax for the format description can be found in [the
-/// book](https://time-rs.github.io/book/api/format-description.html). The version of the format
-/// description is provided as the const parameter. **It is recommended to use version 2.**
-pub fn parse_borrowed<const VERSION: usize>(
-    s: &str,
-) -> Result<Vec<format_description::BorrowedFormatItem<'_>>, error::InvalidFormatDescription> {
-    validate_version!(VERSION);
-    let mut lexed = lexer::lex::<VERSION>(s.as_bytes());
-    let ast = ast::parse::<_, VERSION>(&mut lexed);
-    let format_items = format_item::parse(ast);
-    Ok(format_items
-        .map(|res| res.and_then(TryInto::try_into))
-        .collect::<Result<_, _>>()?)
-}
-
-/// Parse a sequence of items from the format description.
-///
-/// The syntax for the format description can be found in [the
-/// book](https://time-rs.github.io/book/api/format-description.html). The version of the format
-/// description is provided as the const parameter.
-///
-/// Unlike [`parse`], this function returns [`OwnedFormatItem`], which owns its contents. This means
-/// that there is no lifetime that needs to be handled. **It is recommended to use version 2.**
-///
-/// [`OwnedFormatItem`]: crate::format_description::OwnedFormatItem
-pub fn parse_owned<const VERSION: usize>(
-    s: &str,
-) -> Result<format_description::OwnedFormatItem, error::InvalidFormatDescription> {
-    validate_version!(VERSION);
-    let mut lexed = lexer::lex::<VERSION>(s.as_bytes());
-    let ast = ast::parse::<_, VERSION>(&mut lexed);
-    let format_items = format_item::parse(ast);
-    let items = format_items.collect::<Result<Box<_>, _>>()?;
-    Ok(items.into())
-}
-
-/// Attach [`Location`] information to each byte in the iterator.
-fn attach_location<'item>(
-    iter: impl Iterator<Item = &'item u8>,
-) -> impl Iterator<Item = (&'item u8, Location)> {
-    let mut byte_pos = 0;
-
-    iter.map(move |byte| {
-        let location = Location { byte: byte_pos };
-        byte_pos += 1;
-        (byte, location)
-    })
-}
-
-/// A location within a string.
-#[derive(Clone, Copy)]
-struct Location {
-    /// The zero-indexed byte of the string.
-    byte: u32,
-}
-
-impl Location {
-    /// Create a new [`Span`] from `self` to `other`.
-    const fn to(self, end: Self) -> Span {
-        Span { start: self, end }
-    }
-
-    /// Create a new [`Span`] consisting entirely of `self`.
-    const fn to_self(self) -> Span {
-        Span {
-            start: self,
-            end: self,
-        }
-    }
-
-    /// Offset the location by the provided amount.
-    ///
-    /// Note that this assumes the resulting location is on the same line as the original location.
-    #[must_use = "this does not modify the original value"]
-    const fn offset(&self, offset: u32) -> Self {
-        Self {
-            byte: self.byte + offset,
-        }
-    }
-
-    /// Create an error with the provided message at this location.
-    const fn error(self, message: &'static str) -> ErrorInner {
-        ErrorInner {
-            _message: message,
-            _span: Span {
-                start: self,
-                end: self,
-            },
-        }
-    }
-}
-
-/// A start and end point within a string.
-#[derive(Clone, Copy)]
-struct Span {
-    start: Location,
-    end: Location,
-}
-
-impl Span {
-    /// Obtain a `Span` pointing at the start of the pre-existing span.
-    #[must_use = "this does not modify the original value"]
-    const fn shrink_to_start(&self) -> Self {
-        Self {
-            start: self.start,
-            end: self.start,
-        }
-    }
-
-    /// Obtain a `Span` pointing at the end of the pre-existing span.
-    #[must_use = "this does not modify the original value"]
-    const fn shrink_to_end(&self) -> Self {
-        Self {
-            start: self.end,
-            end: self.end,
-        }
-    }
-
-    /// Obtain a `Span` that ends before the provided position of the pre-existing span.
-    #[must_use = "this does not modify the original value"]
-    const fn shrink_to_before(&self, pos: u32) -> Self {
-        Self {
-            start: self.start,
-            end: Location {
-                byte: self.start.byte + pos - 1,
-            },
-        }
-    }
-
-    /// Obtain a `Span` that starts after provided position to the end of the pre-existing span.
-    #[must_use = "this does not modify the original value"]
-    const fn shrink_to_after(&self, pos: u32) -> Self {
-        Self {
-            start: Location {
-                byte: self.start.byte + pos + 1,
-            },
-            end: self.end,
-        }
-    }
-
-    /// Create an error with the provided message at this span.
-    const fn error(self, message: &'static str) -> ErrorInner {
-        ErrorInner {
-            _message: message,
-            _span: self,
-        }
-    }
-}
-
-/// A value with an associated [`Span`].
-#[derive(Clone, Copy)]
-struct Spanned<T> {
-    /// The value.
-    value: T,
-    /// Where the value was in the format string.
-    span: Span,
-}
-
-impl<T> core::ops::Deref for Spanned<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.value
-    }
-}
-
-/// Helper trait to attach a [`Span`] to a value.
-trait SpannedValue: Sized {
-    /// Attach a [`Span`] to a value.
-    fn spanned(self, span: Span) -> Spanned<Self>;
-}
-
-impl<T> SpannedValue for T {
-    fn spanned(self, span: Span) -> Spanned<Self> {
-        Spanned { value: self, span }
-    }
-}
-
-/// The internal error type.
-struct ErrorInner {
-    /// The message displayed to the user.
-    _message: &'static str,
-    /// Where the error originated.
-    _span: Span,
-}
-
-/// A complete error description.
-struct Error {
-    /// The internal error.
-    _inner: Unused<ErrorInner>,
-    /// The error needed for interoperability with the rest of `time`.
-    public: error::InvalidFormatDescription,
-}
-
-impl From<Error> for error::InvalidFormatDescription {
-    fn from(error: Error) -> Self {
-        error.public
-    }
-}
-
-/// A value that may be used in the future, but currently is not.
-///
-/// This struct exists so that data can semantically be passed around without _actually_ passing it
-/// around. This way the data still exists if it is needed in the future.
-// `PhantomData` is not used directly because we don't want to introduce any trait implementations.
-struct Unused<T>(core::marker::PhantomData<T>);
-
-/// Indicate that a value is currently unused.
-fn unused<T>(_: T) -> Unused<T> {
-    Unused(core::marker::PhantomData)
-}
diff --git a/vendor/time/src/format_description/parse/strftime.rs b/vendor/time/src/format_description/parse/strftime.rs
deleted file mode 100644
index 5fcaf184..00000000
--- a/vendor/time/src/format_description/parse/strftime.rs
+++ /dev/null
@@ -1,487 +0,0 @@
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::iter;
-
-use crate::error::InvalidFormatDescription;
-use crate::format_description::parse::{
-    attach_location, unused, Error, ErrorInner, Location, Spanned, SpannedValue, Unused,
-};
-use crate::format_description::{self, modifier, BorrowedFormatItem, Component};
-
-/// Parse a sequence of items from the [`strftime` format description][strftime docs].
-///
-/// The only heap allocation required is for the `Vec` itself. All components are bound to the
-/// lifetime of the input.
-///
-/// [strftime docs]: https://man7.org/linux/man-pages/man3/strftime.3.html
-#[doc(alias = "parse_strptime_borrowed")]
-pub fn parse_strftime_borrowed(
-    s: &str,
-) -> Result<Vec<BorrowedFormatItem<'_>>, InvalidFormatDescription> {
-    let tokens = lex(s.as_bytes());
-    let items = into_items(tokens).collect::<Result<_, _>>()?;
-    Ok(items)
-}
-
-/// Parse a sequence of items from the [`strftime` format description][strftime docs].
-///
-/// This requires heap allocation for some owned items.
-///
-/// [strftime docs]: https://man7.org/linux/man-pages/man3/strftime.3.html
-#[doc(alias = "parse_strptime_owned")]
-pub fn parse_strftime_owned(
-    s: &str,
-) -> Result<format_description::OwnedFormatItem, InvalidFormatDescription> {
-    parse_strftime_borrowed(s).map(Into::into)
-}
-
-#[derive(Debug, Clone, Copy, PartialEq)]
-enum Padding {
-    /// The default padding for a numeric component. Indicated by no character.
-    Default,
-    /// Pad a numeric component with spaces. Indicated by an underscore.
-    Spaces,
-    /// Do not pad a numeric component. Indicated by a hyphen.
-    None,
-    /// Pad a numeric component with zeroes. Indicated by a zero.
-    Zeroes,
-}
-
-enum Token<'a> {
-    Literal(Spanned<&'a [u8]>),
-    Component {
-        _percent: Unused<Location>,
-        padding: Spanned<Padding>,
-        component: Spanned<u8>,
-    },
-}
-
-fn lex(mut input: &[u8]) -> iter::Peekable<impl Iterator<Item = Result<Token<'_>, Error>>> {
-    let mut iter = attach_location(input.iter()).peekable();
-
-    iter::from_fn(move || {
-        Some(Ok(match iter.next()? {
-            (b'%', percent_loc) => match iter.next() {
-                Some((padding @ (b'_' | b'-' | b'0'), padding_loc)) => {
-                    let padding = match padding {
-                        b'_' => Padding::Spaces,
-                        b'-' => Padding::None,
-                        b'0' => Padding::Zeroes,
-                        _ => unreachable!(),
-                    };
-                    let (&component, component_loc) = iter.next()?;
-                    input = &input[3..];
-                    Token::Component {
-                        _percent: unused(percent_loc),
-                        padding: padding.spanned(padding_loc.to_self()),
-                        component: component.spanned(component_loc.to_self()),
-                    }
-                }
-                Some((&component, component_loc)) => {
-                    input = &input[2..];
-                    let span = component_loc.to_self();
-                    Token::Component {
-                        _percent: unused(percent_loc),
-                        padding: Padding::Default.spanned(span),
-                        component: component.spanned(span),
-                    }
-                }
-                None => {
-                    return Some(Err(Error {
-                        _inner: unused(percent_loc.error("unexpected end of input")),
-                        public: InvalidFormatDescription::Expected {
-                            what: "valid escape sequence",
-                            index: percent_loc.byte as usize,
-                        },
-                    }));
-                }
-            },
-            (_, start_location) => {
-                let mut bytes = 1;
-                let mut end_location = start_location;
-
-                while let Some((_, location)) = iter.next_if(|&(&byte, _)| byte != b'%') {
-                    end_location = location;
-                    bytes += 1;
-                }
-
-                let value = &input[..bytes];
-                input = &input[bytes..];
-
-                Token::Literal(value.spanned(start_location.to(end_location)))
-            }
-        }))
-    })
-    .peekable()
-}
-
-fn into_items<'iter, 'token: 'iter>(
-    mut tokens: iter::Peekable<impl Iterator<Item = Result<Token<'token>, Error>> + 'iter>,
-) -> impl Iterator<Item = Result<BorrowedFormatItem<'token>, Error>> + 'iter {
-    iter::from_fn(move || {
-        let next = match tokens.next()? {
-            Ok(token) => token,
-            Err(err) => return Some(Err(err)),
-        };
-
-        Some(match next {
-            Token::Literal(spanned) => Ok(BorrowedFormatItem::Literal(*spanned)),
-            Token::Component {
-                _percent,
-                padding,
-                component,
-            } => parse_component(padding, component),
-        })
-    })
-}
-
-fn parse_component(
-    padding: Spanned<Padding>,
-    component: Spanned<u8>,
-) -> Result<BorrowedFormatItem<'static>, Error> {
-    let padding_or_default = |padding: Padding, default| match padding {
-        Padding::Default => default,
-        Padding::Spaces => modifier::Padding::Space,
-        Padding::None => modifier::Padding::None,
-        Padding::Zeroes => modifier::Padding::Zero,
-    };
-
-    /// Helper macro to create a component.
-    macro_rules! component {
-        ($name:ident { $($inner:tt)* }) => {
-            BorrowedFormatItem::Component(Component::$name(modifier::$name {
-                $($inner)*
-            }))
-        }
-    }
-
-    Ok(match *component {
-        b'%' => BorrowedFormatItem::Literal(b"%"),
-        b'a' => component!(Weekday {
-            repr: modifier::WeekdayRepr::Short,
-            one_indexed: true,
-            case_sensitive: true,
-        }),
-        b'A' => component!(Weekday {
-            repr: modifier::WeekdayRepr::Long,
-            one_indexed: true,
-            case_sensitive: true,
-        }),
-        b'b' | b'h' => component!(Month {
-            repr: modifier::MonthRepr::Short,
-            padding: modifier::Padding::Zero,
-            case_sensitive: true,
-        }),
-        b'B' => component!(Month {
-            repr: modifier::MonthRepr::Long,
-            padding: modifier::Padding::Zero,
-            case_sensitive: true,
-        }),
-        b'c' => BorrowedFormatItem::Compound(&[
-            component!(Weekday {
-                repr: modifier::WeekdayRepr::Short,
-                one_indexed: true,
-                case_sensitive: true,
-            }),
-            BorrowedFormatItem::Literal(b" "),
-            component!(Month {
-                repr: modifier::MonthRepr::Short,
-                padding: modifier::Padding::Zero,
-                case_sensitive: true,
-            }),
-            BorrowedFormatItem::Literal(b" "),
-            component!(Day {
-                padding: modifier::Padding::Space
-            }),
-            BorrowedFormatItem::Literal(b" "),
-            component!(Hour {
-                padding: modifier::Padding::Zero,
-                is_12_hour_clock: false,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Minute {
-                padding: modifier::Padding::Zero,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Second {
-                padding: modifier::Padding::Zero,
-            }),
-            BorrowedFormatItem::Literal(b" "),
-            component!(Year {
-                padding: modifier::Padding::Zero,
-                repr: modifier::YearRepr::Full,
-                range: modifier::YearRange::Extended,
-                iso_week_based: false,
-                sign_is_mandatory: false,
-            }),
-        ]),
-        b'C' => component!(Year {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            repr: modifier::YearRepr::Century,
-            range: modifier::YearRange::Extended,
-            iso_week_based: false,
-            sign_is_mandatory: false,
-        }),
-        b'd' => component!(Day {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-        }),
-        b'D' => BorrowedFormatItem::Compound(&[
-            component!(Month {
-                repr: modifier::MonthRepr::Numerical,
-                padding: modifier::Padding::Zero,
-                case_sensitive: true,
-            }),
-            BorrowedFormatItem::Literal(b"/"),
-            component!(Day {
-                padding: modifier::Padding::Zero,
-            }),
-            BorrowedFormatItem::Literal(b"/"),
-            component!(Year {
-                padding: modifier::Padding::Zero,
-                repr: modifier::YearRepr::LastTwo,
-                range: modifier::YearRange::Extended,
-                iso_week_based: false,
-                sign_is_mandatory: false,
-            }),
-        ]),
-        b'e' => component!(Day {
-            padding: padding_or_default(*padding, modifier::Padding::Space),
-        }),
-        b'F' => BorrowedFormatItem::Compound(&[
-            component!(Year {
-                padding: modifier::Padding::Zero,
-                repr: modifier::YearRepr::Full,
-                range: modifier::YearRange::Extended,
-                iso_week_based: false,
-                sign_is_mandatory: false,
-            }),
-            BorrowedFormatItem::Literal(b"-"),
-            component!(Month {
-                padding: modifier::Padding::Zero,
-                repr: modifier::MonthRepr::Numerical,
-                case_sensitive: true,
-            }),
-            BorrowedFormatItem::Literal(b"-"),
-            component!(Day {
-                padding: modifier::Padding::Zero,
-            }),
-        ]),
-        b'g' => component!(Year {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            repr: modifier::YearRepr::LastTwo,
-            range: modifier::YearRange::Extended,
-            iso_week_based: true,
-            sign_is_mandatory: false,
-        }),
-        b'G' => component!(Year {
-            padding: modifier::Padding::Zero,
-            repr: modifier::YearRepr::Full,
-            range: modifier::YearRange::Extended,
-            iso_week_based: true,
-            sign_is_mandatory: false,
-        }),
-        b'H' => component!(Hour {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            is_12_hour_clock: false,
-        }),
-        b'I' => component!(Hour {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            is_12_hour_clock: true,
-        }),
-        b'j' => component!(Ordinal {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-        }),
-        b'k' => component!(Hour {
-            padding: padding_or_default(*padding, modifier::Padding::Space),
-            is_12_hour_clock: false,
-        }),
-        b'l' => component!(Hour {
-            padding: padding_or_default(*padding, modifier::Padding::Space),
-            is_12_hour_clock: true,
-        }),
-        b'm' => component!(Month {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            repr: modifier::MonthRepr::Numerical,
-            case_sensitive: true,
-        }),
-        b'M' => component!(Minute {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-        }),
-        b'n' => BorrowedFormatItem::Literal(b"\n"),
-        b'O' => {
-            return Err(Error {
-                _inner: unused(ErrorInner {
-                    _message: "unsupported modifier",
-                    _span: component.span,
-                }),
-                public: InvalidFormatDescription::NotSupported {
-                    what: "modifier",
-                    context: "",
-                    index: component.span.start.byte as usize,
-                },
-            })
-        }
-        b'p' => component!(Period {
-            is_uppercase: true,
-            case_sensitive: true
-        }),
-        b'P' => component!(Period {
-            is_uppercase: false,
-            case_sensitive: true
-        }),
-        b'r' => BorrowedFormatItem::Compound(&[
-            component!(Hour {
-                padding: modifier::Padding::Zero,
-                is_12_hour_clock: true,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Minute {
-                padding: modifier::Padding::Zero,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Second {
-                padding: modifier::Padding::Zero,
-            }),
-            BorrowedFormatItem::Literal(b" "),
-            component!(Period {
-                is_uppercase: true,
-                case_sensitive: true,
-            }),
-        ]),
-        b'R' => BorrowedFormatItem::Compound(&[
-            component!(Hour {
-                padding: modifier::Padding::Zero,
-                is_12_hour_clock: false,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Minute {
-                padding: modifier::Padding::Zero,
-            }),
-        ]),
-        b's' => component!(UnixTimestamp {
-            precision: modifier::UnixTimestampPrecision::Second,
-            sign_is_mandatory: false,
-        }),
-        b'S' => component!(Second {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-        }),
-        b't' => BorrowedFormatItem::Literal(b"\t"),
-        b'T' => BorrowedFormatItem::Compound(&[
-            component!(Hour {
-                padding: modifier::Padding::Zero,
-                is_12_hour_clock: false,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Minute {
-                padding: modifier::Padding::Zero,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Second {
-                padding: modifier::Padding::Zero,
-            }),
-        ]),
-        b'u' => component!(Weekday {
-            repr: modifier::WeekdayRepr::Monday,
-            one_indexed: true,
-            case_sensitive: true,
-        }),
-        b'U' => component!(WeekNumber {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            repr: modifier::WeekNumberRepr::Sunday,
-        }),
-        b'V' => component!(WeekNumber {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            repr: modifier::WeekNumberRepr::Iso,
-        }),
-        b'w' => component!(Weekday {
-            repr: modifier::WeekdayRepr::Sunday,
-            one_indexed: true,
-            case_sensitive: true,
-        }),
-        b'W' => component!(WeekNumber {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            repr: modifier::WeekNumberRepr::Monday,
-        }),
-        b'x' => BorrowedFormatItem::Compound(&[
-            component!(Month {
-                repr: modifier::MonthRepr::Numerical,
-                padding: modifier::Padding::Zero,
-                case_sensitive: true,
-            }),
-            BorrowedFormatItem::Literal(b"/"),
-            component!(Day {
-                padding: modifier::Padding::Zero
-            }),
-            BorrowedFormatItem::Literal(b"/"),
-            component!(Year {
-                padding: modifier::Padding::Zero,
-                repr: modifier::YearRepr::LastTwo,
-                range: modifier::YearRange::Extended,
-                iso_week_based: false,
-                sign_is_mandatory: false,
-            }),
-        ]),
-        b'X' => BorrowedFormatItem::Compound(&[
-            component!(Hour {
-                padding: modifier::Padding::Zero,
-                is_12_hour_clock: false,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Minute {
-                padding: modifier::Padding::Zero,
-            }),
-            BorrowedFormatItem::Literal(b":"),
-            component!(Second {
-                padding: modifier::Padding::Zero,
-            }),
-        ]),
-        b'y' => component!(Year {
-            padding: padding_or_default(*padding, modifier::Padding::Zero),
-            repr: modifier::YearRepr::LastTwo,
-            range: modifier::YearRange::Extended,
-            iso_week_based: false,
-            sign_is_mandatory: false,
-        }),
-        b'Y' => component!(Year {
-            padding: modifier::Padding::Zero,
-            repr: modifier::YearRepr::Full,
-            range: modifier::YearRange::Extended,
-            iso_week_based: false,
-            sign_is_mandatory: false,
-        }),
-        b'z' => BorrowedFormatItem::Compound(&[
-            component!(OffsetHour {
-                sign_is_mandatory: true,
-                padding: modifier::Padding::Zero,
-            }),
-            component!(OffsetMinute {
-                padding: modifier::Padding::Zero,
-            }),
-        ]),
-        b'Z' => {
-            return Err(Error {
-                _inner: unused(ErrorInner {
-                    _message: "unsupported component",
-                    _span: component.span,
-                }),
-                public: InvalidFormatDescription::NotSupported {
-                    what: "component",
-                    context: "",
-                    index: component.span.start.byte as usize,
-                },
-            })
-        }
-        _ => {
-            return Err(Error {
-                _inner: unused(ErrorInner {
-                    _message: "invalid component",
-                    _span: component.span,
-                }),
-                public: InvalidFormatDescription::InvalidComponentName {
-                    name: String::from_utf8_lossy(&[*component]).into_owned(),
-                    index: component.span.start.byte as usize,
-                },
-            })
-        }
-    })
-}
diff --git a/vendor/time/src/format_description/well_known/iso8601.rs b/vendor/time/src/format_description/well_known/iso8601.rs
deleted file mode 100644
index 6b8ff2ab..00000000
--- a/vendor/time/src/format_description/well_known/iso8601.rs
+++ /dev/null
@@ -1,257 +0,0 @@
-//! The format described in ISO 8601.
-
-mod adt_hack;
-
-use core::num::NonZeroU8;
-
-#[doc(hidden, no_inline)]
-pub use self::adt_hack::DoNotRelyOnWhatThisIs;
-pub use self::adt_hack::EncodedConfig;
-
-/// The format described in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html).
-///
-/// This implementation is of ISO 8601-1:2019. It may not be compatible with other versions.
-///
-/// The const parameter `CONFIG` **must** be a value that was returned by [`Config::encode`].
-/// Passing any other value is **unspecified behavior**.
-///
-/// Example: 1997-11-21T09:55:06.000000000-06:00
-///
-/// # Examples
-#[cfg_attr(feature = "formatting", doc = "```rust")]
-#[cfg_attr(not(feature = "formatting"), doc = "```rust,ignore")]
-/// # use time::format_description::well_known::Iso8601;
-/// # use time_macros::datetime;
-/// assert_eq!(
-///     datetime!(1997-11-12 9:55:06 -6:00).format(&Iso8601::DEFAULT)?,
-///     "1997-11-12T09:55:06.000000000-06:00"
-/// );
-/// # Ok::<_, time::Error>(())
-/// ```
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub struct Iso8601<const CONFIG: EncodedConfig = { Config::DEFAULT.encode() }>;
-
-impl<const CONFIG: EncodedConfig> core::fmt::Debug for Iso8601<CONFIG> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.debug_struct("Iso8601")
-            .field("config", &Config::decode(CONFIG))
-            .finish()
-    }
-}
-
-/// Define associated constants for `Iso8601`.
-macro_rules! define_assoc_consts {
-    ($($(#[$doc:meta])* $vis:vis const $const_name:ident = $format:expr;)*) => {$(
-        const $const_name: EncodedConfig = $format.encode();
-        impl Iso8601<$const_name> {
-            $(#[$doc])*
-            $vis const $const_name: Self = Self;
-        }
-    )*};
-}
-
-define_assoc_consts! {
-    /// An [`Iso8601`] with the default configuration.
-    ///
-    /// The following is the default behavior:
-    ///
-    /// - The configuration can be used for both formatting and parsing.
-    /// - The date, time, and UTC offset are all formatted.
-    /// - Separators (such as `-` and `:`) are included.
-    /// - The year contains four digits, such that the year must be between 0 and 9999.
-    /// - The date uses the calendar format.
-    /// - The time has precision to the second and nine decimal digits.
-    /// - The UTC offset has precision to the minute.
-    ///
-    /// If you need different behavior, use another associated constant. For full customization, use
-    /// [`Config::DEFAULT`] and [`Config`]'s methods to create a custom configuration.
-    pub const DEFAULT = Config::DEFAULT;
-    /// An [`Iso8601`] that can only be used for parsing. Using this to format a value is
-    /// unspecified behavior.
-    pub const PARSING = Config::PARSING;
-    /// An [`Iso8601`] that handles only the date, but is otherwise the same as [`Config::DEFAULT`].
-    pub const DATE = Config::DEFAULT.set_formatted_components(FormattedComponents::Date);
-    /// An [`Iso8601`] that handles only the time, but is otherwise the same as [`Config::DEFAULT`].
-    pub const TIME = Config::DEFAULT.set_formatted_components(FormattedComponents::Time);
-    /// An [`Iso8601`] that handles only the UTC offset, but is otherwise the same as
-    /// [`Config::DEFAULT`].
-    pub const OFFSET = Config::DEFAULT.set_formatted_components(FormattedComponents::Offset);
-    /// An [`Iso8601`] that handles the date and time, but is otherwise the same as
-    /// [`Config::DEFAULT`].
-    pub const DATE_TIME = Config::DEFAULT.set_formatted_components(FormattedComponents::DateTime);
-    /// An [`Iso8601`] that handles the date, time, and UTC offset. This is the same as
-    /// [`Config::DEFAULT`].
-    pub const DATE_TIME_OFFSET = Config::DEFAULT;
-    /// An [`Iso8601`] that handles the time and UTC offset, but is otherwise the same as
-    /// [`Config::DEFAULT`].
-    pub const TIME_OFFSET = Config::DEFAULT
-        .set_formatted_components(FormattedComponents::TimeOffset);
-}
-
-/// Which components to format.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum FormattedComponents {
-    /// The configuration can only be used for parsing. Using this to format a value is
-    /// unspecified behavior.
-    None,
-    /// Format only the date.
-    Date,
-    /// Format only the time.
-    Time,
-    /// Format only the UTC offset.
-    Offset,
-    /// Format the date and time.
-    DateTime,
-    /// Format the date, time, and UTC offset.
-    DateTimeOffset,
-    /// Format the time and UTC offset.
-    TimeOffset,
-}
-
-/// Which format to use for the date.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum DateKind {
-    /// Use the year-month-day format.
-    Calendar,
-    /// Use the year-week-weekday format.
-    Week,
-    /// Use the week-ordinal format.
-    Ordinal,
-}
-
-/// The precision and number of decimal digits present for the time.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum TimePrecision {
-    /// Format the hour only. Minutes, seconds, and nanoseconds will be represented with the
-    /// specified number of decimal digits, if any.
-    Hour {
-        #[allow(missing_docs)]
-        decimal_digits: Option<NonZeroU8>,
-    },
-    /// Format the hour and minute. Seconds and nanoseconds will be represented with the specified
-    /// number of decimal digits, if any.
-    Minute {
-        #[allow(missing_docs)]
-        decimal_digits: Option<NonZeroU8>,
-    },
-    /// Format the hour, minute, and second. Nanoseconds will be represented with the specified
-    /// number of decimal digits, if any.
-    Second {
-        #[allow(missing_docs)]
-        decimal_digits: Option<NonZeroU8>,
-    },
-}
-
-/// The precision for the UTC offset.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum OffsetPrecision {
-    /// Format only the offset hour. Requires the offset minute to be zero.
-    Hour,
-    /// Format both the offset hour and minute.
-    Minute,
-}
-
-/// Configuration for [`Iso8601`].
-// This is only used as a const generic, so there's no need to have a number of implementations on
-// it.
-#[allow(missing_copy_implementations)]
-#[doc(alias = "EncodedConfig")] // People will likely search for `EncodedConfig`, so show them this.
-#[derive(Debug)]
-pub struct Config {
-    /// Which components, if any, will be formatted.
-    pub(crate) formatted_components: FormattedComponents,
-    /// Whether the format contains separators (such as `-` or `:`).
-    pub(crate) use_separators: bool,
-    /// Whether the year is six digits.
-    pub(crate) year_is_six_digits: bool,
-    /// The format used for the date.
-    pub(crate) date_kind: DateKind,
-    /// The precision and number of decimal digits present for the time.
-    pub(crate) time_precision: TimePrecision,
-    /// The precision for the UTC offset.
-    pub(crate) offset_precision: OffsetPrecision,
-}
-
-impl Config {
-    /// A configuration for the [`Iso8601`] format.
-    ///
-    /// The following is the default behavior:
-    ///
-    /// - The configuration can be used for both formatting and parsing.
-    /// - The date, time, and UTC offset are all formatted.
-    /// - Separators (such as `-` and `:`) are included.
-    /// - The year contains four digits, such that the year must be between 0 and 9999.
-    /// - The date uses the calendar format.
-    /// - The time has precision to the second and nine decimal digits.
-    /// - The UTC offset has precision to the minute.
-    ///
-    /// If you need different behavior, use the setter methods on this struct.
-    pub const DEFAULT: Self = Self {
-        formatted_components: FormattedComponents::DateTimeOffset,
-        use_separators: true,
-        year_is_six_digits: false,
-        date_kind: DateKind::Calendar,
-        time_precision: TimePrecision::Second {
-            decimal_digits: NonZeroU8::new(9),
-        },
-        offset_precision: OffsetPrecision::Minute,
-    };
-
-    /// A configuration that can only be used for parsing. Using this to format a value is
-    /// unspecified behavior.
-    const PARSING: Self = Self {
-        formatted_components: FormattedComponents::None,
-        use_separators: false,
-        year_is_six_digits: false,
-        date_kind: DateKind::Calendar,
-        time_precision: TimePrecision::Hour {
-            decimal_digits: None,
-        },
-        offset_precision: OffsetPrecision::Hour,
-    };
-
-    /// Set whether the format the date, time, and/or UTC offset.
-    pub const fn set_formatted_components(self, formatted_components: FormattedComponents) -> Self {
-        Self {
-            formatted_components,
-            ..self
-        }
-    }
-
-    /// Set whether the format contains separators (such as `-` or `:`).
-    pub const fn set_use_separators(self, use_separators: bool) -> Self {
-        Self {
-            use_separators,
-            ..self
-        }
-    }
-
-    /// Set whether the year is six digits.
-    pub const fn set_year_is_six_digits(self, year_is_six_digits: bool) -> Self {
-        Self {
-            year_is_six_digits,
-            ..self
-        }
-    }
-
-    /// Set the format used for the date.
-    pub const fn set_date_kind(self, date_kind: DateKind) -> Self {
-        Self { date_kind, ..self }
-    }
-
-    /// Set the precision and number of decimal digits present for the time.
-    pub const fn set_time_precision(self, time_precision: TimePrecision) -> Self {
-        Self {
-            time_precision,
-            ..self
-        }
-    }
-
-    /// Set the precision for the UTC offset.
-    pub const fn set_offset_precision(self, offset_precision: OffsetPrecision) -> Self {
-        Self {
-            offset_precision,
-            ..self
-        }
-    }
-}
diff --git a/vendor/time/src/format_description/well_known/iso8601/adt_hack.rs b/vendor/time/src/format_description/well_known/iso8601/adt_hack.rs
deleted file mode 100644
index 6d3daebb..00000000
--- a/vendor/time/src/format_description/well_known/iso8601/adt_hack.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-//! Hackery to work around not being able to use ADTs in const generics on stable.
-
-use core::num::NonZeroU8;
-
-#[cfg(feature = "formatting")]
-use super::Iso8601;
-use super::{Config, DateKind, FormattedComponents as FC, OffsetPrecision, TimePrecision};
-
-// This provides a way to include `EncodedConfig` in documentation without displaying the type it is
-// aliased to.
-#[doc(hidden)]
-pub type DoNotRelyOnWhatThisIs = u128;
-
-/// An encoded [`Config`] that can be used as a const parameter to [`Iso8601`](super::Iso8601).
-///
-/// The type this is aliased to must not be relied upon. It can change in any release without
-/// notice.
-pub type EncodedConfig = DoNotRelyOnWhatThisIs;
-
-#[cfg(feature = "formatting")]
-impl<const CONFIG: EncodedConfig> Iso8601<CONFIG> {
-    /// The user-provided configuration for the ISO 8601 format.
-    const CONFIG: Config = Config::decode(CONFIG);
-    /// Whether the date should be formatted.
-    pub(crate) const FORMAT_DATE: bool = matches!(
-        Self::CONFIG.formatted_components,
-        FC::Date | FC::DateTime | FC::DateTimeOffset
-    );
-    /// Whether the time should be formatted.
-    pub(crate) const FORMAT_TIME: bool = matches!(
-        Self::CONFIG.formatted_components,
-        FC::Time | FC::DateTime | FC::DateTimeOffset | FC::TimeOffset
-    );
-    /// Whether the UTC offset should be formatted.
-    pub(crate) const FORMAT_OFFSET: bool = matches!(
-        Self::CONFIG.formatted_components,
-        FC::Offset | FC::DateTimeOffset | FC::TimeOffset
-    );
-    /// Whether the year is six digits.
-    pub(crate) const YEAR_IS_SIX_DIGITS: bool = Self::CONFIG.year_is_six_digits;
-    /// Whether the format contains separators (such as `-` or `:`).
-    pub(crate) const USE_SEPARATORS: bool = Self::CONFIG.use_separators;
-    /// Which format to use for the date.
-    pub(crate) const DATE_KIND: DateKind = Self::CONFIG.date_kind;
-    /// The precision and number of decimal digits to use for the time.
-    pub(crate) const TIME_PRECISION: TimePrecision = Self::CONFIG.time_precision;
-    /// The precision for the UTC offset.
-    pub(crate) const OFFSET_PRECISION: OffsetPrecision = Self::CONFIG.offset_precision;
-}
-
-impl Config {
-    /// Encode the configuration, permitting it to be used as a const parameter of [`Iso8601`].
-    ///
-    /// The value returned by this method must only be used as a const parameter to [`Iso8601`]. Any
-    /// other usage is unspecified behavior.
-    pub const fn encode(&self) -> EncodedConfig {
-        let mut bytes = [0; EncodedConfig::BITS as usize / 8];
-
-        bytes[0] = match self.formatted_components {
-            FC::None => 0,
-            FC::Date => 1,
-            FC::Time => 2,
-            FC::Offset => 3,
-            FC::DateTime => 4,
-            FC::DateTimeOffset => 5,
-            FC::TimeOffset => 6,
-        };
-        bytes[1] = self.use_separators as u8;
-        bytes[2] = self.year_is_six_digits as u8;
-        bytes[3] = match self.date_kind {
-            DateKind::Calendar => 0,
-            DateKind::Week => 1,
-            DateKind::Ordinal => 2,
-        };
-        bytes[4] = match self.time_precision {
-            TimePrecision::Hour { .. } => 0,
-            TimePrecision::Minute { .. } => 1,
-            TimePrecision::Second { .. } => 2,
-        };
-        bytes[5] = match self.time_precision {
-            TimePrecision::Hour { decimal_digits }
-            | TimePrecision::Minute { decimal_digits }
-            | TimePrecision::Second { decimal_digits } => match decimal_digits {
-                None => 0,
-                Some(decimal_digits) => decimal_digits.get(),
-            },
-        };
-        bytes[6] = match self.offset_precision {
-            OffsetPrecision::Hour => 0,
-            OffsetPrecision::Minute => 1,
-        };
-
-        EncodedConfig::from_be_bytes(bytes)
-    }
-
-    /// Decode the configuration. The configuration must have been generated from
-    /// [`Config::encode`].
-    pub(super) const fn decode(encoded: EncodedConfig) -> Self {
-        let bytes = encoded.to_be_bytes();
-
-        let formatted_components = match bytes[0] {
-            0 => FC::None,
-            1 => FC::Date,
-            2 => FC::Time,
-            3 => FC::Offset,
-            4 => FC::DateTime,
-            5 => FC::DateTimeOffset,
-            6 => FC::TimeOffset,
-            _ => panic!("invalid configuration"),
-        };
-        let use_separators = match bytes[1] {
-            0 => false,
-            1 => true,
-            _ => panic!("invalid configuration"),
-        };
-        let year_is_six_digits = match bytes[2] {
-            0 => false,
-            1 => true,
-            _ => panic!("invalid configuration"),
-        };
-        let date_kind = match bytes[3] {
-            0 => DateKind::Calendar,
-            1 => DateKind::Week,
-            2 => DateKind::Ordinal,
-            _ => panic!("invalid configuration"),
-        };
-        let time_precision = match bytes[4] {
-            0 => TimePrecision::Hour {
-                decimal_digits: NonZeroU8::new(bytes[5]),
-            },
-            1 => TimePrecision::Minute {
-                decimal_digits: NonZeroU8::new(bytes[5]),
-            },
-            2 => TimePrecision::Second {
-                decimal_digits: NonZeroU8::new(bytes[5]),
-            },
-            _ => panic!("invalid configuration"),
-        };
-        let offset_precision = match bytes[6] {
-            0 => OffsetPrecision::Hour,
-            1 => OffsetPrecision::Minute,
-            _ => panic!("invalid configuration"),
-        };
-
-        // No `for` loops in `const fn`.
-        let mut idx = 7; // first unused byte
-        while idx < EncodedConfig::BITS as usize / 8 {
-            assert!(bytes[idx] == 0, "invalid configuration");
-            idx += 1;
-        }
-
-        Self {
-            formatted_components,
-            use_separators,
-            year_is_six_digits,
-            date_kind,
-            time_precision,
-            offset_precision,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    macro_rules! eq {
-        ($a:expr, $b:expr) => {{
-            let a = $a;
-            let b = $b;
-            a.formatted_components == b.formatted_components
-                && a.use_separators == b.use_separators
-                && a.year_is_six_digits == b.year_is_six_digits
-                && a.date_kind == b.date_kind
-                && a.time_precision == b.time_precision
-                && a.offset_precision == b.offset_precision
-        }};
-    }
-
-    #[test]
-    fn encoding_roundtrip() {
-        macro_rules! assert_roundtrip {
-            ($config:expr) => {
-                let config = $config;
-                let encoded = config.encode();
-                let decoded = Config::decode(encoded);
-                assert!(eq!(config, decoded));
-            };
-        }
-
-        assert_roundtrip!(Config::DEFAULT);
-        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::None));
-        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::Date));
-        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::Time));
-        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::Offset));
-        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::DateTime));
-        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::DateTimeOffset));
-        assert_roundtrip!(Config::DEFAULT.set_formatted_components(FC::TimeOffset));
-        assert_roundtrip!(Config::DEFAULT.set_use_separators(false));
-        assert_roundtrip!(Config::DEFAULT.set_use_separators(true));
-        assert_roundtrip!(Config::DEFAULT.set_year_is_six_digits(false));
-        assert_roundtrip!(Config::DEFAULT.set_year_is_six_digits(true));
-        assert_roundtrip!(Config::DEFAULT.set_date_kind(DateKind::Calendar));
-        assert_roundtrip!(Config::DEFAULT.set_date_kind(DateKind::Week));
-        assert_roundtrip!(Config::DEFAULT.set_date_kind(DateKind::Ordinal));
-        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Hour {
-            decimal_digits: None,
-        }));
-        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Minute {
-            decimal_digits: None,
-        }));
-        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Second {
-            decimal_digits: None,
-        }));
-        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Hour {
-            decimal_digits: NonZeroU8::new(1),
-        }));
-        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Minute {
-            decimal_digits: NonZeroU8::new(1),
-        }));
-        assert_roundtrip!(Config::DEFAULT.set_time_precision(TimePrecision::Second {
-            decimal_digits: NonZeroU8::new(1),
-        }));
-        assert_roundtrip!(Config::DEFAULT.set_offset_precision(OffsetPrecision::Hour));
-        assert_roundtrip!(Config::DEFAULT.set_offset_precision(OffsetPrecision::Minute));
-    }
-
-    macro_rules! assert_decode_fail {
-        ($encoding:expr) => {
-            assert!(std::panic::catch_unwind(|| {
-                Config::decode($encoding);
-            })
-            .is_err());
-        };
-    }
-
-    #[test]
-    fn decode_fail() {
-        assert_decode_fail!(0x07_00_00_00_00_00_00_00_00_00_00_00_00_00_00_00);
-        assert_decode_fail!(0x00_02_00_00_00_00_00_00_00_00_00_00_00_00_00_00);
-        assert_decode_fail!(0x00_00_02_00_00_00_00_00_00_00_00_00_00_00_00_00);
-        assert_decode_fail!(0x00_00_00_03_00_00_00_00_00_00_00_00_00_00_00_00);
-        assert_decode_fail!(0x00_00_00_00_03_00_00_00_00_00_00_00_00_00_00_00);
-        assert_decode_fail!(0x00_00_00_00_00_00_02_00_00_00_00_00_00_00_00_00);
-        assert_decode_fail!(0x00_00_00_00_00_00_00_01_00_00_00_00_00_00_00_00);
-    }
-}
diff --git a/vendor/time/src/format_description/well_known/rfc2822.rs b/vendor/time/src/format_description/well_known/rfc2822.rs
deleted file mode 100644
index 3c890ab1..00000000
--- a/vendor/time/src/format_description/well_known/rfc2822.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! The format described in RFC 2822.
-
-/// The format described in [RFC 2822](https://tools.ietf.org/html/rfc2822#section-3.3).
-///
-/// Example: Fri, 21 Nov 1997 09:55:06 -0600
-///
-/// # Examples
-#[cfg_attr(feature = "parsing", doc = "```rust")]
-#[cfg_attr(not(feature = "parsing"), doc = "```rust,ignore")]
-/// # use time::{format_description::well_known::Rfc2822, OffsetDateTime};
-/// use time_macros::datetime;
-/// assert_eq!(
-///     OffsetDateTime::parse("Sat, 12 Jun 1993 13:25:19 GMT", &Rfc2822)?,
-///     datetime!(1993-06-12 13:25:19 +00:00)
-/// );
-/// # Ok::<_, time::Error>(())
-/// ```
-///
-#[cfg_attr(feature = "formatting", doc = "```rust")]
-#[cfg_attr(not(feature = "formatting"), doc = "```rust,ignore")]
-/// # use time::format_description::well_known::Rfc2822;
-/// # use time_macros::datetime;
-/// assert_eq!(
-///     datetime!(1997-11-21 09:55:06 -06:00).format(&Rfc2822)?,
-///     "Fri, 21 Nov 1997 09:55:06 -0600"
-/// );
-/// # Ok::<_, time::Error>(())
-/// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Rfc2822;
diff --git a/vendor/time/src/format_description/well_known/rfc3339.rs b/vendor/time/src/format_description/well_known/rfc3339.rs
deleted file mode 100644
index f0873cba..00000000
--- a/vendor/time/src/format_description/well_known/rfc3339.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! The format described in RFC 3339.
-
-/// The format described in [RFC 3339](https://tools.ietf.org/html/rfc3339#section-5.6).
-///
-/// Format example: 1985-04-12T23:20:50.52Z
-///
-/// # Examples
-#[cfg_attr(feature = "parsing", doc = "```rust")]
-#[cfg_attr(not(feature = "parsing"), doc = "```rust,ignore")]
-/// # use time::{format_description::well_known::Rfc3339, OffsetDateTime};
-/// # use time_macros::datetime;
-/// assert_eq!(
-///     OffsetDateTime::parse("1985-04-12T23:20:50.52Z", &Rfc3339)?,
-///     datetime!(1985-04-12 23:20:50.52 +00:00)
-/// );
-/// # Ok::<_, time::Error>(())
-/// ```
-///
-#[cfg_attr(feature = "formatting", doc = "```rust")]
-#[cfg_attr(not(feature = "formatting"), doc = "```rust,ignore")]
-/// # use time::format_description::well_known::Rfc3339;
-/// # use time_macros::datetime;
-/// assert_eq!(
-///     datetime!(1985-04-12 23:20:50.52 +00:00).format(&Rfc3339)?,
-///     "1985-04-12T23:20:50.52Z"
-/// );
-/// # Ok::<_, time::Error>(())
-/// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Rfc3339;