html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/uuid/src/external/serde_support.rs

@@ -9,12 +9,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use core::marker::PhantomData;
+
 use crate::{
     error::*,
     fmt::{Braced, Hyphenated, Simple, Urn},
     non_nil::NonNilUuid,
     std::fmt,
-    Uuid,
+    Bytes, Uuid,
 };
 use serde_core::{
     de::{self, Error as _},
@@ -64,116 +66,217 @@ impl Serialize for Braced {
     }
 }
 
+struct UuidReadableVisitor<T> {
+    expecting: &'static str,
+    _marker: PhantomData<T>,
+}
+
+impl<'vi, T: UuidDeserialize> de::Visitor<'vi> for UuidReadableVisitor<T> {
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(self.expecting)
+    }
+
+    fn visit_str<E: de::Error>(self, value: &str) -> Result<T, E> {
+        T::from_str(value).map_err(de_error)
+    }
+
+    fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<T, E> {
+        T::from_slice(value).map_err(de_error)
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<T, A::Error>
+    where
+        A: de::SeqAccess<'vi>,
+    {
+        #[rustfmt::skip]
+        let bytes = [
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(0, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(1, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(2, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(3, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(4, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(5, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(6, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(7, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(8, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(9, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(10, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(11, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(12, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(13, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(14, &self)) },
+            match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(15, &self)) },
+        ];
+
+        T::from_bytes(bytes).map_err(de_error)
+    }
+}
+
+struct UuidBytesVisitor<T> {
+    _marker: PhantomData<T>,
+}
+
+impl<'vi, T: UuidDeserialize> de::Visitor<'vi> for UuidBytesVisitor<T> {
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(formatter, "a 16 byte array")
+    }
+
+    fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<T, E> {
+        T::from_slice(value).map_err(de_error)
+    }
+}
+
+fn de_error<E: de::Error>(e: Error) -> E {
+    E::custom(format_args!("UUID parsing failed: {}", e))
+}
+
+trait UuidDeserialize {
+    fn from_str(formatted: &str) -> Result<Self, Error>
+    where
+        Self: Sized;
+    fn from_slice(bytes: &[u8]) -> Result<Self, Error>
+    where
+        Self: Sized;
+    fn from_bytes(bytes: Bytes) -> Result<Self, Error>
+    where
+        Self: Sized;
+}
+
+impl UuidDeserialize for Uuid {
+    fn from_str(formatted: &str) -> Result<Self, Error> {
+        formatted.parse()
+    }
+
+    fn from_slice(bytes: &[u8]) -> Result<Self, Error> {
+        Uuid::from_slice(bytes)
+    }
+
+    fn from_bytes(bytes: Bytes) -> Result<Self, Error> {
+        Ok(Uuid::from_bytes(bytes))
+    }
+}
+
 impl<'de> Deserialize<'de> for Uuid {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        fn de_error<E: de::Error>(e: Error) -> E {
-            E::custom(format_args!("UUID parsing failed: {}", e))
+        if deserializer.is_human_readable() {
+            deserializer.deserialize_str(UuidReadableVisitor {
+                expecting: "a formatted UUID string",
+                _marker: PhantomData::<Uuid>,
+            })
+        } else {
+            deserializer.deserialize_bytes(UuidBytesVisitor {
+                _marker: PhantomData::<Uuid>,
+            })
         }
+    }
+}
 
-        if deserializer.is_human_readable() {
-            struct UuidVisitor;
-
-            impl<'vi> de::Visitor<'vi> for UuidVisitor {
-                type Value = Uuid;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    write!(formatter, "a UUID string")
-                }
-
-                fn visit_str<E: de::Error>(self, value: &str) -> Result<Uuid, E> {
-                    value.parse::<Uuid>().map_err(de_error)
-                }
-
-                fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<Uuid, E> {
-                    Uuid::from_slice(value).map_err(de_error)
-                }
-
-                fn visit_seq<A>(self, mut seq: A) -> Result<Uuid, A::Error>
-                where
-                    A: de::SeqAccess<'vi>,
-                {
-                    #[rustfmt::skip]
-                    let bytes = [
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(0, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(1, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(2, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(3, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(4, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(5, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(6, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(7, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(8, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(9, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(10, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(11, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(12, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(13, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(14, &self)) },
-                        match seq.next_element()? { Some(e) => e, None => return Err(A::Error::invalid_length(15, &self)) },
-                    ];
-
-                    Ok(Uuid::from_bytes(bytes))
-                }
-            }
+impl UuidDeserialize for Braced {
+    fn from_str(formatted: &str) -> Result<Self, Error> {
+        formatted.parse()
+    }
 
-            deserializer.deserialize_str(UuidVisitor)
-        } else {
-            struct UuidBytesVisitor;
+    fn from_slice(bytes: &[u8]) -> Result<Self, Error> {
+        Ok(Uuid::from_slice(bytes)?.into())
+    }
 
-            impl<'vi> de::Visitor<'vi> for UuidBytesVisitor {
-                type Value = Uuid;
+    fn from_bytes(bytes: Bytes) -> Result<Self, Error> {
+        Ok(Uuid::from_bytes(bytes).into())
+    }
+}
 
-                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    write!(formatter, "bytes")
-                }
+impl<'de> Deserialize<'de> for Braced {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        deserializer.deserialize_str(UuidReadableVisitor {
+            expecting: "a UUID string in the braced format",
+            _marker: PhantomData::<Braced>,
+        })
+    }
+}
 
-                fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<Uuid, E> {
-                    Uuid::from_slice(value).map_err(de_error)
-                }
-            }
+impl UuidDeserialize for Hyphenated {
+    fn from_str(formatted: &str) -> Result<Self, Error> {
+        formatted.parse()
+    }
 
-            deserializer.deserialize_bytes(UuidBytesVisitor)
-        }
+    fn from_slice(bytes: &[u8]) -> Result<Self, Error> {
+        Ok(Uuid::from_slice(bytes)?.into())
+    }
+
+    fn from_bytes(bytes: Bytes) -> Result<Self, Error> {
+        Ok(Uuid::from_bytes(bytes).into())
     }
 }
 
-impl<'de> Deserialize<'de> for NonNilUuid {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde_core::Deserializer<'de>,
-    {
-        let uuid = Uuid::deserialize(deserializer)?;
+impl<'de> Deserialize<'de> for Hyphenated {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        deserializer.deserialize_str(UuidReadableVisitor {
+            expecting: "a UUID string in the hyphenated format",
+            _marker: PhantomData::<Hyphenated>,
+        })
+    }
+}
 
-        NonNilUuid::try_from(uuid).map_err(|_| {
-            de::Error::invalid_value(de::Unexpected::Other("nil UUID"), &"a non-nil UUID")
+impl UuidDeserialize for Simple {
+    fn from_str(formatted: &str) -> Result<Self, Error> {
+        formatted.parse()
+    }
+
+    fn from_slice(bytes: &[u8]) -> Result<Self, Error> {
+        Ok(Uuid::from_slice(bytes)?.into())
+    }
+
+    fn from_bytes(bytes: Bytes) -> Result<Self, Error> {
+        Ok(Uuid::from_bytes(bytes).into())
+    }
+}
+
+impl<'de> Deserialize<'de> for Simple {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        deserializer.deserialize_str(UuidReadableVisitor {
+            expecting: "a UUID string in the simple format",
+            _marker: PhantomData::<Simple>,
         })
     }
 }
 
-enum ExpectedFormat {
-    Simple,
-    Braced,
-    Urn,
+impl UuidDeserialize for Urn {
+    fn from_str(formatted: &str) -> Result<Self, Error> {
+        formatted.parse()
+    }
+
+    fn from_slice(bytes: &[u8]) -> Result<Self, Error> {
+        Ok(Uuid::from_slice(bytes)?.into())
+    }
+
+    fn from_bytes(bytes: Bytes) -> Result<Self, Error> {
+        Ok(Uuid::from_bytes(bytes).into())
+    }
 }
 
-impl std::fmt::Display for ExpectedFormat {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let s = match self {
-            ExpectedFormat::Simple => "a simple Uuid string like 67e5504410b1426f9247bb680e5fe0c8",
-            ExpectedFormat::Braced => {
-                "a braced Uuid string like {67e55044-10b1-426f-9247-bb680e5fe0c8}"
-            }
-            ExpectedFormat::Urn => {
-                "a URN Uuid string like urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8"
-            }
-        };
-        f.write_str(s)
+impl<'de> Deserialize<'de> for Urn {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        deserializer.deserialize_str(UuidReadableVisitor {
+            expecting: "a UUID string in the URN format",
+            _marker: PhantomData::<Urn>,
+        })
     }
 }
 
-impl de::Expected for ExpectedFormat {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        <ExpectedFormat as std::fmt::Display>::fmt(self, formatter)
+impl<'de> Deserialize<'de> for NonNilUuid {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde_core::Deserializer<'de>,
+    {
+        let uuid = Uuid::deserialize(deserializer)?;
+
+        NonNilUuid::try_from(uuid).map_err(|_| {
+            de::Error::invalid_value(de::Unexpected::Other("nil UUID"), &"a non-nil UUID")
+        })
     }
 }
 
@@ -279,11 +382,7 @@ pub mod compact {
 /// }
 /// ```
 pub mod simple {
-    use serde_core::{de, Deserialize};
-
-    use crate::{parser::parse_simple, Uuid};
-
-    use super::ExpectedFormat;
+    use super::*;
 
     /// Serialize from a [`Uuid`] as a `uuid::fmt::Simple`
     ///
@@ -314,11 +413,7 @@ pub mod simple {
     where
         D: serde_core::Deserializer<'de>,
     {
-        let s = <&str as Deserialize>::deserialize(deserializer)?;
-        let bytes = parse_simple(s.as_bytes()).map_err(|_| {
-            de::Error::invalid_value(de::Unexpected::Str(s), &ExpectedFormat::Simple)
-        })?;
-        Ok(Uuid::from_bytes(bytes))
+        Ok(Simple::deserialize(deserializer)?.into())
     }
 
     #[cfg(test)]
@@ -326,7 +421,7 @@ pub mod simple {
         use serde::de::{self, Error};
         use serde_test::{Readable, Token};
 
-        use crate::{external::serde_support::ExpectedFormat, Uuid};
+        use super::*;
 
         const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
         const SIMPLE_UUID_STR: &str = "f9168c5eceb24faab6bf329bf39fa1e4";
@@ -377,13 +472,7 @@ pub mod simple {
                     Token::BorrowedStr(HYPHENATED_UUID_STR),
                     Token::TupleStructEnd,
                 ],
-                &format!(
-                    "{}",
-                    de::value::Error::invalid_value(
-                        de::Unexpected::Str(HYPHENATED_UUID_STR),
-                        &ExpectedFormat::Simple,
-                    )
-                ),
+                &format!("{}", de::value::Error::custom("UUID parsing failed: invalid group length in group 4: expected 12, found 12")),
             );
         }
     }
@@ -411,11 +500,7 @@ pub mod simple {
 /// }
 /// ```
 pub mod braced {
-    use serde_core::{de, Deserialize};
-
-    use crate::parser::parse_braced;
-
-    use super::ExpectedFormat;
+    use super::*;
 
     /// Serialize from a [`Uuid`] as a `uuid::fmt::Braced`
     ///
@@ -446,19 +531,16 @@ pub mod braced {
     where
         D: serde_core::Deserializer<'de>,
     {
-        let s = <&str as Deserialize>::deserialize(deserializer)?;
-        let bytes = parse_braced(s.as_bytes()).map_err(|_| {
-            de::Error::invalid_value(de::Unexpected::Str(s), &ExpectedFormat::Braced)
-        })?;
-        Ok(crate::Uuid::from_bytes(bytes))
+        Ok(Braced::deserialize(deserializer)?.into())
     }
 
     #[cfg(test)]
     mod tests {
+
         use serde::de::{self, Error};
         use serde_test::{Readable, Token};
 
-        use crate::{external::serde_support::ExpectedFormat, Uuid};
+        use super::*;
 
         const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
         const BRACED_UUID_STR: &str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
@@ -509,13 +591,7 @@ pub mod braced {
                     Token::BorrowedStr(HYPHENATED_UUID_STR),
                     Token::TupleStructEnd,
                 ],
-                &format!(
-                    "{}",
-                    de::value::Error::invalid_value(
-                        de::Unexpected::Str(HYPHENATED_UUID_STR),
-                        &ExpectedFormat::Braced,
-                    )
-                ),
+                &format!("{}", de::value::Error::custom("UUID parsing failed: invalid group length in group 4: expected 12, found 12")),
             );
         }
     }
@@ -543,11 +619,7 @@ pub mod braced {
 /// }
 /// ```
 pub mod urn {
-    use serde_core::{de, Deserialize};
-
-    use crate::parser::parse_urn;
-
-    use super::ExpectedFormat;
+    use super::*;
 
     /// Serialize from a [`Uuid`] as a `uuid::fmt::Urn`
     ///
@@ -578,10 +650,7 @@ pub mod urn {
     where
         D: serde_core::Deserializer<'de>,
     {
-        let s = <&str as Deserialize>::deserialize(deserializer)?;
-        let bytes = parse_urn(s.as_bytes())
-            .map_err(|_| de::Error::invalid_value(de::Unexpected::Str(s), &ExpectedFormat::Urn))?;
-        Ok(crate::Uuid::from_bytes(bytes))
+        Ok(Urn::deserialize(deserializer)?.into())
     }
 
     #[cfg(test)]
@@ -589,7 +658,7 @@ pub mod urn {
         use serde::de::{self, Error};
         use serde_test::{Readable, Token};
 
-        use crate::{external::serde_support::ExpectedFormat, Uuid};
+        use super::*;
 
         const HYPHENATED_UUID_STR: &str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
         const URN_UUID_STR: &str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
@@ -640,13 +709,7 @@ pub mod urn {
                     Token::BorrowedStr(HYPHENATED_UUID_STR),
                     Token::TupleStructEnd,
                 ],
-                &format!(
-                    "{}",
-                    de::value::Error::invalid_value(
-                        de::Unexpected::Str(HYPHENATED_UUID_STR),
-                        &ExpectedFormat::Urn,
-                    )
-                ),
+                &format!("{}", de::value::Error::custom("UUID parsing failed: invalid group length in group 4: expected 12, found 12")),
             );
         }
     }
@@ -708,6 +771,7 @@ mod serde_tests {
         let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
         let u = Uuid::parse_str(uuid_str).unwrap();
         serde_test::assert_ser_tokens(&u.hyphenated(), &[Token::Str(uuid_str)]);
+        serde_test::assert_de_tokens(&u.hyphenated(), &[Token::Str(uuid_str)]);
     }
 
     #[test]
@@ -715,6 +779,7 @@ mod serde_tests {
         let uuid_str = "f9168c5eceb24faab6bf329bf39fa1e4";
         let u = Uuid::parse_str(uuid_str).unwrap();
         serde_test::assert_ser_tokens(&u.simple(), &[Token::Str(uuid_str)]);
+        serde_test::assert_de_tokens(&u.simple(), &[Token::Str(uuid_str)]);
     }
 
     #[test]
@@ -722,6 +787,7 @@ mod serde_tests {
         let uuid_str = "urn:uuid:f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
         let u = Uuid::parse_str(uuid_str).unwrap();
         serde_test::assert_ser_tokens(&u.urn(), &[Token::Str(uuid_str)]);
+        serde_test::assert_de_tokens(&u.urn(), &[Token::Str(uuid_str)]);
     }
 
     #[test]
@@ -729,6 +795,7 @@ mod serde_tests {
         let uuid_str = "{f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4}";
         let u = Uuid::parse_str(uuid_str).unwrap();
         serde_test::assert_ser_tokens(&u.braced(), &[Token::Str(uuid_str)]);
+        serde_test::assert_de_tokens(&u.braced(), &[Token::Str(uuid_str)]);
     }
 
     #[test]

data/rust-vendor/uuid/src/lib.rs

@@ -38,7 +38,7 @@
 //!
 //! ```toml
 //! [dependencies.uuid]
-//! version = "1.19.0"
+//! version = "1.20.0"
 //! # Lets you generate random UUIDs
 //! features = [
 //!     "v4",
@@ -99,7 +99,6 @@
 //!
 //! Other crate features can also be useful beyond the version support:
 //!
-//! * `macro-diagnostics` - enhances the diagnostics of `uuid!` macro.
 //! * `serde` - adds the ability to serialize and deserialize a UUID using
 //!   `serde`.
 //! * `borsh` - adds the ability to serialize and deserialize a UUID using
@@ -139,7 +138,7 @@
 //!
 //! ```toml
 //! [dependencies.uuid]
-//! version = "1.19.0"
+//! version = "1.20.0"
 //! features = [
 //!     "v4",
 //!     "v7",
@@ -154,7 +153,7 @@
 //!
 //! ```toml
 //! [dependencies.uuid]
-//! version = "1.19.0"
+//! version = "1.20.0"
 //! default-features = false
 //! ```
 //!
@@ -212,7 +211,7 @@
 #![doc(
     html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
     html_favicon_url = "https://www.rust-lang.org/favicon.ico",
-    html_root_url = "https://docs.rs/uuid/1.19.0"
+    html_root_url = "https://docs.rs/uuid/1.20.0"
 )]
 
 #[cfg(any(feature = "std", test))]
@@ -270,10 +269,6 @@ mod sha1;
 
 mod external;
 
-#[doc(hidden)]
-#[cfg(feature = "macro-diagnostics")]
-pub extern crate uuid_macro_internal;
-
 #[doc(hidden)]
 pub mod __macro_support {
     pub use crate::std::result::Result::{Err, Ok};
@@ -813,10 +808,13 @@ impl Uuid {
 
     /// Returns the bytes of the UUID in little-endian order.
     ///
-    /// The bytes will be flipped to convert into little-endian order. This is
-    /// based on the endianness of the UUID, rather than the target environment
+    /// The bytes for each field will be flipped to convert into little-endian order.
+    /// This is based on the endianness of the UUID, rather than the target environment
     /// so bytes will be flipped on both big and little endian machines.
     ///
+    /// Note that ordering is applied to each _field_, rather than to the bytes as a whole.
+    /// This ordering is compatible with Microsoft's mixed endian GUID format.
+    ///
     /// # Examples
     ///
     /// ```

data/rust-vendor/uuid/src/macros.rs

@@ -1,37 +1,3 @@
-macro_rules! define_uuid_macro {
-    {$(#[$doc:meta])*} => {
-        $(#[$doc])*
-        #[cfg(feature = "macro-diagnostics")]
-        #[macro_export]
-        macro_rules! uuid {
-            ($uuid:expr) => {{
-                const OUTPUT: $crate::Uuid = match $crate::Uuid::try_parse($uuid) {
-                    $crate::__macro_support::Ok(u) => u,
-                    $crate::__macro_support::Err(_) => panic!("invalid UUID"),
-                };
-                OUTPUT
-            }};
-            ($uuid:literal) => {{
-                $crate::Uuid::from_bytes($crate::uuid_macro_internal::parse_lit!($uuid))
-            }};
-        }
-
-        $(#[$doc])*
-        #[cfg(not(feature = "macro-diagnostics"))]
-        #[macro_export]
-        macro_rules! uuid {
-            ($uuid:expr) => {{
-                const OUTPUT: $crate::Uuid = match $crate::Uuid::try_parse($uuid) {
-                    $crate::__macro_support::Ok(u) => u,
-                    $crate::__macro_support::Err(_) => panic!("invalid UUID"),
-                };
-                OUTPUT
-            }};
-        }
-    }
-}
-
-define_uuid_macro! {
 /// Parse [`Uuid`][uuid::Uuid]s from string literals at compile time.
 ///
 /// ## Usage
@@ -64,27 +30,16 @@ define_uuid_macro! {
 /// let UUID = uuid!(UUID_STR);
 /// ```
 ///
-/// ## Compilation Failures
-///
-/// Invalid UUIDs are rejected:
-///
-/// ```compile_fail
-/// # use uuid::uuid;
-/// let uuid = uuid!("F9168C5E-ZEB2-4FAA-B6BF-329BF39FA1E4");
-/// ```
-///
-/// Enable the feature `macro-diagnostics` to see the error messages below.
-///
-/// Provides the following compilation error:
-///
-/// ```txt
-/// error: invalid character: expected an optional prefix of `urn:uuid:` followed by [0-9a-fA-F-], found Z at 9
-///     |
-///     |     let id = uuid!("F9168C5E-ZEB2-4FAA-B6BF-329BF39FA1E4");
-///     |                              ^
-/// ```
-///
 /// [uuid::Uuid]: https://docs.rs/uuid/*/uuid/struct.Uuid.html
+#[macro_export]
+macro_rules! uuid {
+    ($uuid:expr) => {{
+        const OUTPUT: $crate::Uuid = match $crate::Uuid::try_parse($uuid) {
+            $crate::__macro_support::Ok(u) => u,
+            $crate::__macro_support::Err(_) => panic!("invalid UUID"),
+        };
+        OUTPUT
+    }};
 }
 
 // Internal macros