impl core::fmt::Debug for FontStyle {
    fn fmt(
        &self,
        f: &mut core::fmt::Formatter,
    ) -> core::fmt::Result {
        #[allow(non_snake_case)]
        trait __BitFlags {
            #[inline]
            fn BOLD(&self) -> bool {
                false
            }
            #[inline]
            fn UNDERLINE(&self) -> bool {
                false
            }
            #[inline]
            fn ITALIC(&self) -> bool {
                false
            }
        }
        #[allow(non_snake_case)]
        impl __BitFlags for FontStyle {
            #[allow(deprecated)]
            #[inline]
            fn BOLD(&self) -> bool {
                if Self::BOLD.bits == 0 && self.bits != 0 {
                    false
                } else {
                    self.bits & Self::BOLD.bits == Self::BOLD.bits
                }
            }
            #[allow(deprecated)]
            #[inline]
            fn UNDERLINE(&self) -> bool {
                if Self::UNDERLINE.bits == 0 && self.bits != 0 {
                    false
                } else {
                    self.bits & Self::UNDERLINE.bits == Self::UNDERLINE.bits
                }
            }
            #[allow(deprecated)]
            #[inline]
            fn ITALIC(&self) -> bool {
                if Self::ITALIC.bits == 0 && self.bits != 0 {
                    false
                } else {
                    self.bits & Self::ITALIC.bits == Self::ITALIC.bits
                }
            }
        }
        let mut first = true;
        if <Self as __BitFlags>::BOLD(self) {
            if !first {
                f.write_str(" | ")?;
            }
            first = false;
            f.write_str("BOLD")?;
        }
        if <Self as __BitFlags>::UNDERLINE(self) {
            if !first {
                f.write_str(" | ")?;
            }
            first = false;
            f.write_str("UNDERLINE")?;
        }
        if <Self as __BitFlags>::ITALIC(self) {
            if !first {
                f.write_str(" | ")?;
            }
            first = false;
            f.write_str("ITALIC")?;
        }
        let extra_bits = self.bits & !Self::all().bits();
        if extra_bits != 0 {
            if !first {
                f.write_str(" | ")?;
            }
            first = false;
            f.write_str("0x")?;
            core::fmt::LowerHex::fmt(&extra_bits, f)?;
        }
        if first {
            f.write_str("(empty)")?;
        }
        Ok(())
    }
}

impl fmt::Debug for FontStyle {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut empty = true;

        let pairs = [
            (Self::BOLD, "BOLD"),
            (Self::UNDERLINE, "UNDERLINE"),
            (Self::ITALIC, "ITALIC"),
        ];
        for (flag, flag_str) in pairs {
            if self.contains(flag) {
                if !std::mem::take(&mut empty) {
                    f.write_str(" | ")?;
                }
                f.write_str(flag_str)?;
            }
        }

        let extra_bits = self.bits & !Self::all().bits();
        if extra_bits != 0 {
            if !std::mem::take(&mut empty) {
                f.write_str(" | ")?;
            }
            f.write_str("0x")?;
            fmt::LowerHex::fmt(&extra_bits, f)?;
        }

        if empty {
            f.write_str("(empty)")?;
        }

        Ok(())
    }
}