.github/workflows/ci.yml

@@ -4,36 +4,23 @@ name: Continuous integration
 
 jobs:
   ci:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         rust:
           - stable
+        os: [ubuntu-latest, windows-latest]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - uses: actions-rs/toolchain@v1
+      - uses: dtolnay/rust-toolchain@master
         with:
-          profile: minimal
           toolchain: ${{ matrix.rust }}
-          override: true
           components: rustfmt, clippy
 
-      - uses: actions-rs/cargo@v1
-        with:
-          command: build
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: -- -D warnings
+      - run: cargo build --all-features
+      - run: cargo test --all-features
+      - run: cargo fmt --check --all
+      - run: cargo clippy -- -D warnings
+      - run: cargo run --example 256_colors

.gitignore

@@ -1,2 +1,18 @@
 target
-Cargo.lock
+Cargo.lock
+
+# JetBrains' IDE items
+.idea/*
+
+# VSCode's IDE items
+.vscode/*
+
+# Helix configuration folder
+.helix/*
+.helix
+
+# Visual Studio
+.vs/*
+*.rsproj
+*.rsproj.user
+*.sln

CHANGELOG.md

@@ -0,0 +1,82 @@
+# Changelog
+
+## v0.47.0 (Unreleased)
+
+### Breaking changes
+
+- Bumped minimum supported Rust version (MSRV) to 1.62.1
+- Change of `Color::default()` value to the ANSI default color `Color::Default` (code `39` and `49` for foreground and background respectively). This replaces `Color::White` as the default value.
+
+### Other changes
+
+- `const`ification of several functions and methods.
+- Improved CI workflow.
+- Updated to Rust edition 2021.
+- Replaced `winapi` dependency with `windows-sys`.
+- Removed `overload` dependency.
+- Added `AnsiGenericString::as_str()` to allow access to the underlying string.
+- Fixed typos in README.
+- Added `CHANGELOG.md` for changes since forking `ansi_term`.
+
+## v0.46.0 (2022-06-03)
+
+- Removed `impl Deref` for `AnsiGenericString`.
+- Improved README headings.
+
+## v0.45.1 (2022-03-27)
+
+- Added `Color::Default` enum variant with ansi codes `39` and `49` for foreground & background.
+
+## v0.45.0 (2022-03-16)
+
+- Fixed examples in README.
+- Fixed typos in documentation.
+- Renamed `ANSIByteStrings` to `AnsiByteStrings`.
+- Added GitHub Actions workflow.
+- Changed authors metadata.
+- Updated license
+
+## v0.43.0 (2022-01-18)
+
+- Fixed clippy warning.
+
+## v0.40.0 (2021-11-16)
+
+- Fixed clippy warning.
+
+## v0.38.0 (2021-10-05)
+
+- Removed `itertools` dependency.
+
+## v0.37.0 (2021-09-14)
+
+- Fixed clippy warnings.
+
+## v0.31.0 (2021-05-11)
+
+- Implemented `Default` trait for `Color` returning `Color::White`.
+- Added helpers for gradients.
+- Fixed clippy warning.
+
+## v0.30.0 (2021-04-21)
+
+- Export `ansi` module to expose `ansi::RESET`.
+
+## v0.29.0 (2021-03-30)
+
+- Renamed `Color::RGB` enum variant to `Color::Rgb`.
+- Renamed `ANSIByteString` to `AnsiByteString`.
+- Renamed `ANSIGenericString` to `AnsiGenericString`.
+- Renamed `ANSIGenericStrings` to `AnsiGenericStrings`.
+- Renamed `ANSIString` to `AnsiString`.
+- Renamed `ANSIStrings` to `AnsiStrings`.
+
+## v0.28.0 (2021-03-09)
+
+- Forked `ansi_term` as `nu-ansi-term`.
+- Added Nushell project contributors to the authors.
+- Updated README.md.
+- Renamed `Colour` to `Color`.
+- Renamed some files ending in `colour` to `color`.
+- Added "bright" colors ansi 90-97 (foreground) and 100-107 (background).
+- Ran cargo fmt

Cargo.toml

@@ -6,10 +6,11 @@ authors = [
     "The Nushell Project Developers",
 ]
 description = "Library for ANSI terminal colors and styles (bold, underline)"
-edition = "2018"
+edition = "2021"
+rust-version = "1.62.1"
 license = "MIT"
 name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.47.0"
 repository = "https://github.com/nushell/nu-ansi-term"
 
 [lib]
@@ -19,16 +20,21 @@ doctest = true
 derive_serde_style = ["serde"]
 
 [dependencies]
-overload = "0.1.1"
-serde = { version="1.0.90", features=["derive"], optional=true }
+serde = { version="1.0.152", features=["derive"], optional=true }
 
-[target.'cfg(target_os="windows")'.dependencies.winapi]
-version = "0.3.4"
-features = ["consoleapi", "errhandlingapi", "fileapi", "handleapi", "processenv"]
+[target.'cfg(windows)'.dependencies.windows]
+version = "0.45.0"
+package = "windows-sys"
+features = [
+    "Win32_Foundation",
+    "Win32_System_Console",
+    "Win32_Storage_FileSystem",
+    "Win32_Security"
+]
 
 [dev-dependencies]
-doc-comment = "0.3"
-regex = "1.1.9"
+doc-comment = "0.3.3"
+regex = "1.7.1"
 
 [dev-dependencies.serde_json]
-version = "1.0.39"
+version = "1.0.94"

README.md

@@ -1,6 +1,6 @@
 # nu-ansi-term
 
-> This is a copy of rust-ansi-term but with Color change to Color and light foreground colors added (90-97) as well as light background colors added (100-107).
+> This is a copy of rust-ansi-term but with Colour change to Color and light foreground colors added (90-97) as well as light background colors added (100-107).
 
 This is a library for controlling colors and formatting, such as red bold text or blue underlined text, on ANSI terminals.
 
@@ -12,7 +12,7 @@ This crate works with [Cargo](http://crates.io). Add the following to your `Carg
 
 ```toml
 [dependencies]
-nu_ansi_term = "0.46"
+nu-ansi-term = "0.47"
 ```
 
 ## Basic usage
@@ -23,8 +23,6 @@ A `Style` holds stylistic information: foreground and background colors, whether
 The `Color` enum represents the available colors.
 And an `AnsiString` is a string paired with a `Style`.
 
-`Color` is also available as an alias to `Color`.
-
 To format a string, call the `paint` method on a `Style` or a `Color`, passing in the string you want to format as the argument.
 For example, here’s how to get some red text:
 
@@ -127,9 +125,9 @@ use nu_ansi_term::Color::RGB;
 RGB(70, 130, 180).paint("Steel blue");
 ```
 
-## Combining successive coloured strings
+## Combining successive colored strings
 
-The benefit of writing ANSI escape codes to the terminal is that they _stack_: you do not need to end every coloured string with a reset code if the text that follows it is of a similar style.
+The benefit of writing ANSI escape codes to the terminal is that they _stack_: you do not need to end every colored string with a reset code if the text that follows it is of a similar style.
 For example, if you want to have some blue text followed by some blue bold text, it’s possible to send the ANSI code for blue, followed by the ANSI code for bold, and finishing with a reset code without having to have an extra one between the two strings.
 
 This crate can optimise the ANSI codes that get printed in situations like this, making life easier for your terminal renderer.

examples/256_colors.rs

@@ -1,4 +1,3 @@
-extern crate nu_ansi_term;
 use nu_ansi_term::Color;
 
 // This example prints out the 256 colors.
@@ -10,6 +9,9 @@ use nu_ansi_term::Color;
 // - 232 to 255 are shades of grey.
 
 fn main() {
+    #[cfg(windows)]
+    nu_ansi_term::enable_ansi_support().unwrap();
+
     // First two lines
     for c in 0..8 {
         glow(c, c != 0);

examples/basic_colors.rs

@@ -1,9 +1,11 @@
-extern crate nu_ansi_term;
 use nu_ansi_term::{Color::*, Style};
 
 // This example prints out the 16 basic colors.
 
 fn main() {
+    #[cfg(windows)]
+    nu_ansi_term::enable_ansi_support().unwrap();
+
     let normal = Style::default();
 
     println!("{} {}", normal.paint("Normal"), normal.bold().paint("bold"));

examples/gradient_colors.rs

@@ -1,6 +1,9 @@
 use nu_ansi_term::{build_all_gradient_text, Color, Gradient, Rgb, TargetGround};
 
 fn main() {
+    #[cfg(windows)]
+    nu_ansi_term::enable_ansi_support().unwrap();
+
     let text = "lorem ipsum quia dolor sit amet, consectetur, adipisci velit";
 
     // a gradient from hex colors

examples/rgb_colors.rs

@@ -1,4 +1,3 @@
-extern crate nu_ansi_term;
 use nu_ansi_term::{Color, Style};
 
 // This example prints out a color gradient in a grid by calculating each
@@ -9,6 +8,9 @@ const WIDTH: i32 = 80;
 const HEIGHT: i32 = 24;
 
 fn main() {
+    #[cfg(windows)]
+    nu_ansi_term::enable_ansi_support().unwrap();
+
     for row in 0..HEIGHT {
         for col in 0..WIDTH {
             let r = (row * 255 / HEIGHT) as u8;

src/ansi.rs

@@ -194,7 +194,7 @@ impl Style {
     /// assert_eq!("",
     ///            style.prefix().to_string());
     /// ```
-    pub fn prefix(self) -> Prefix {
+    pub const fn prefix(self) -> Prefix {
         Prefix(self)
     }
 
@@ -219,7 +219,7 @@ impl Style {
     /// assert_eq!("",
     ///            style.infix(style).to_string());
     /// ```
-    pub fn infix(self, next: Style) -> Infix {
+    pub const fn infix(self, next: Style) -> Infix {
         Infix(self, next)
     }
 
@@ -243,7 +243,7 @@ impl Style {
     /// assert_eq!("",
     ///            style.suffix().to_string());
     /// ```
-    pub fn suffix(self) -> Suffix {
+    pub const fn suffix(self) -> Suffix {
         Suffix(self)
     }
 }

src/debug.rs

@@ -120,7 +120,6 @@ mod test {
 
     #[test]
     fn long_and_detailed() {
-        extern crate regex;
         let expected_debug = "Style { fg(Blue), bold }";
         let expected_pretty_repat = r##"(?x)
         Style\s+\{\s+

src/difference.rs

@@ -2,7 +2,7 @@ use super::Style;
 
 /// When printing out one colored string followed by another, use one of
 /// these rules to figure out which *extra* control codes need to be sent.
-#[derive(PartialEq, Clone, Copy, Debug)]
+#[derive(Eq, PartialEq, Clone, Copy, Debug)]
 pub enum Difference {
     /// Print out the control codes specified by this style to end up looking
     /// like the second string's styles.

src/display.rs

@@ -9,7 +9,7 @@ use std::io;
 /// An `AnsiGenericString` includes a generic string type and a `Style` to
 /// display that string.  `AnsiString` and `AnsiByteString` are aliases for
 /// this type on `str` and `\[u8]`, respectively.
-#[derive(PartialEq, Debug)]
+#[derive(Eq, PartialEq, Debug)]
 pub struct AnsiGenericString<'a, S: 'a + ToOwned + ?Sized>
 where
     <S as ToOwned>::Owned: fmt::Debug,
@@ -107,19 +107,24 @@ where
     <S as ToOwned>::Owned: fmt::Debug,
 {
     /// Directly access the style
-    pub fn style_ref(&self) -> &Style {
+    pub const fn style_ref(&self) -> &Style {
         &self.style
     }
 
     /// Directly access the style mutably
     pub fn style_ref_mut(&mut self) -> &mut Style {
         &mut self.style
     }
+
+    // Directly access the underlying string
+    pub fn as_str(&self) -> &S {
+        self.string.as_ref()
+    }
 }
 
 /// A set of `AnsiGenericStrings`s collected together, in order to be
 /// written with a minimum of control characters.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Eq, PartialEq)]
 pub struct AnsiGenericStrings<'a, S: 'a + ToOwned + ?Sized>(pub &'a [AnsiGenericString<'a, S>])
 where
     <S as ToOwned>::Owned: fmt::Debug,
@@ -131,7 +136,7 @@ pub type AnsiStrings<'a> = AnsiGenericStrings<'a, str>;
 
 /// A function to construct an `AnsiStrings` instance.
 #[allow(non_snake_case)]
-pub fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> {
+pub const fn AnsiStrings<'a>(arg: &'a [AnsiString<'a>]) -> AnsiStrings<'a> {
     AnsiGenericStrings(arg)
 }
 
@@ -141,7 +146,7 @@ pub type AnsiByteStrings<'a> = AnsiGenericStrings<'a, [u8]>;
 
 /// A function to construct an `AnsiByteStrings` instance.
 #[allow(non_snake_case)]
-pub fn AnsiByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> {
+pub const fn AnsiByteStrings<'a>(arg: &'a [AnsiByteString<'a>]) -> AnsiByteStrings<'a> {
     AnsiGenericStrings(arg)
 }
 

src/gradient.rs

@@ -16,6 +16,7 @@ impl Gradient {
     pub const fn new(start: Rgb, end: Rgb) -> Self {
         Self { start, end }
     }
+
     pub const fn from_color_rgb(start: Color, end: Color) -> Self {
         let start_grad = match start {
             Color::Rgb(r, g, b) => Rgb { r, g, b },

src/lib.rs

@@ -236,14 +236,8 @@
 #![warn(trivial_casts, trivial_numeric_casts)]
 // #![warn(unused_extern_crates, unused_qualifications)]
 
-#[cfg(target_os = "windows")]
-extern crate winapi;
 #[cfg(test)]
-#[macro_use]
-extern crate doc_comment;
-
-#[cfg(test)]
-doctest!("../README.md");
+doc_comment::doctest!("../README.md");
 
 pub mod ansi;
 pub use ansi::{Infix, Prefix, Suffix};
@@ -258,7 +252,7 @@ pub use display::*;
 mod write;
 
 mod windows;
-pub use windows::*;
+pub use crate::windows::*;
 
 mod util;
 pub use util::*;

src/rgb.rs

@@ -1,6 +1,5 @@
 // Code liberally borrowed from here
 // https://github.com/navierr/coloriz
-use std::ops;
 use std::u32;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Rgb {
@@ -123,51 +122,174 @@ impl ANSIColorCode for Rgb {
     }
 }
 
-overload::overload!(
-    (lhs: ?Rgb) + (rhs: ?Rgb) -> Rgb {
-        Rgb::new(
-            lhs.r.saturating_add(rhs.r),
-            lhs.g.saturating_add(rhs.g),
-            lhs.b.saturating_add(rhs.b)
-        )
+const fn rgb_add(lhs: &Rgb, rhs: &Rgb) -> Rgb {
+    Rgb::new(
+        lhs.r.saturating_add(rhs.r),
+        lhs.g.saturating_add(rhs.g),
+        lhs.b.saturating_add(rhs.b),
+    )
+}
+
+const fn rgb_sub(lhs: &Rgb, rhs: &Rgb) -> Rgb {
+    Rgb::new(
+        lhs.r.saturating_sub(rhs.r),
+        lhs.g.saturating_sub(rhs.g),
+        lhs.b.saturating_sub(rhs.b),
+    )
+}
+
+fn rgb_mul_f32(lhs: &Rgb, rhs: &f32) -> Rgb {
+    Rgb::new(
+        (lhs.r as f32 * rhs.clamp(0.0, 1.0)) as u8,
+        (lhs.g as f32 * rhs.clamp(0.0, 1.0)) as u8,
+        (lhs.b as f32 * rhs.clamp(0.0, 1.0)) as u8,
+    )
+}
+
+const fn rgb_negate(rgb: &Rgb) -> Rgb {
+    Rgb::new(255 - rgb.r, 255 - rgb.g, 255 - rgb.b)
+}
+
+impl std::ops::Add<Rgb> for Rgb {
+    type Output = Rgb;
+
+    fn add(self, rhs: Rgb) -> Self::Output {
+        rgb_add(&self, &rhs)
     }
-);
+}
 
-overload::overload!(
-    (lhs: ?Rgb) - (rhs: ?Rgb) -> Rgb {
-        Rgb::new(
-            lhs.r.saturating_sub(rhs.r),
-            lhs.g.saturating_sub(rhs.g),
-            lhs.b.saturating_sub(rhs.b)
-        )
+impl std::ops::Add<&Rgb> for Rgb {
+    type Output = Rgb;
+
+    fn add(self, rhs: &Rgb) -> Self::Output {
+        rgb_add(&self, rhs)
     }
-);
+}
 
-overload::overload!(
-    (lhs: ?Rgb) * (rhs: ?f32) -> Rgb {
-        Rgb::new(
-            (lhs.r as f32 * rhs.clamp(0.0, 1.0)) as u8,
-            (lhs.g as f32 * rhs.clamp(0.0, 1.0)) as u8,
-            (lhs.b as f32 * rhs.clamp(0.0, 1.0)) as u8
-        )
+impl std::ops::Add<Rgb> for &Rgb {
+    type Output = Rgb;
+
+    fn add(self, rhs: Rgb) -> Self::Output {
+        rgb_add(self, &rhs)
     }
-);
+}
 
-overload::overload!(
-    (lhs: ?f32) * (rhs: ?Rgb) -> Rgb {
-        Rgb::new(
-            (rhs.r as f32 * lhs.clamp(0.0, 1.0)) as u8,
-            (rhs.g as f32 * lhs.clamp(0.0, 1.0)) as u8,
-            (rhs.b as f32 * lhs.clamp(0.0, 1.0)) as u8
-        )
+impl std::ops::Add<&Rgb> for &Rgb {
+    type Output = Rgb;
+
+    fn add(self, rhs: &Rgb) -> Self::Output {
+        rgb_add(self, rhs)
+    }
+}
+
+impl std::ops::Sub<Rgb> for Rgb {
+    type Output = Rgb;
+
+    fn sub(self, rhs: Rgb) -> Self::Output {
+        rgb_sub(&self, &rhs)
+    }
+}
+
+impl std::ops::Sub<&Rgb> for Rgb {
+    type Output = Rgb;
+
+    fn sub(self, rhs: &Rgb) -> Self::Output {
+        rgb_sub(&self, rhs)
+    }
+}
+
+impl std::ops::Sub<Rgb> for &Rgb {
+    type Output = Rgb;
+
+    fn sub(self, rhs: Rgb) -> Self::Output {
+        rgb_sub(self, &rhs)
+    }
+}
+
+impl std::ops::Sub<&Rgb> for &Rgb {
+    type Output = Rgb;
+
+    fn sub(self, rhs: &Rgb) -> Self::Output {
+        rgb_sub(self, rhs)
+    }
+}
+
+impl std::ops::Mul<f32> for Rgb {
+    type Output = Rgb;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        rgb_mul_f32(&self, &rhs)
+    }
+}
+
+impl std::ops::Mul<&f32> for Rgb {
+    type Output = Rgb;
+
+    fn mul(self, rhs: &f32) -> Self::Output {
+        rgb_mul_f32(&self, rhs)
     }
-);
+}
+
+impl std::ops::Mul<f32> for &Rgb {
+    type Output = Rgb;
 
-overload::overload!(
-    -(rgb: ?Rgb) -> Rgb {
-        Rgb::new(
-            255 - rgb.r,
-            255 - rgb.g,
-            255 - rgb.b)
+    fn mul(self, rhs: f32) -> Self::Output {
+        rgb_mul_f32(self, &rhs)
     }
-);
+}
+
+impl std::ops::Mul<&f32> for &Rgb {
+    type Output = Rgb;
+
+    fn mul(self, rhs: &f32) -> Self::Output {
+        rgb_mul_f32(self, rhs)
+    }
+}
+
+impl std::ops::Mul<Rgb> for f32 {
+    type Output = Rgb;
+
+    fn mul(self, rhs: Rgb) -> Self::Output {
+        rgb_mul_f32(&rhs, &self)
+    }
+}
+
+impl std::ops::Mul<&Rgb> for f32 {
+    type Output = Rgb;
+
+    fn mul(self, rhs: &Rgb) -> Self::Output {
+        rgb_mul_f32(rhs, &self)
+    }
+}
+
+impl std::ops::Mul<Rgb> for &f32 {
+    type Output = Rgb;
+
+    fn mul(self, rhs: Rgb) -> Self::Output {
+        rgb_mul_f32(&rhs, self)
+    }
+}
+
+impl std::ops::Mul<&Rgb> for &f32 {
+    type Output = Rgb;
+
+    fn mul(self, rhs: &Rgb) -> Self::Output {
+        rgb_mul_f32(rhs, self)
+    }
+}
+
+impl std::ops::Neg for Rgb {
+    type Output = Rgb;
+
+    fn neg(self) -> Self::Output {
+        rgb_negate(&self)
+    }
+}
+
+impl std::ops::Neg for &Rgb {
+    type Output = Rgb;
+
+    fn neg(self) -> Self::Output {
+        rgb_negate(self)
+    }
+}

src/style.rs

@@ -9,7 +9,7 @@
 /// let style = Style::new().bold().on(Color::Black);
 /// println!("{}", style.paint("Bold on black"));
 /// ```
-#[derive(PartialEq, Clone, Copy)]
+#[derive(Eq, PartialEq, Clone, Copy)]
 #[cfg_attr(
     feature = "derive_serde_style",
     derive(serde::Deserialize, serde::Serialize)
@@ -71,7 +71,7 @@ impl Style {
     /// let style = Style::new().bold();
     /// println!("{}", style.paint("hey"));
     /// ```
-    pub fn bold(&self) -> Style {
+    pub const fn bold(&self) -> Style {
         Style {
             is_bold: true,
             ..*self
@@ -88,7 +88,7 @@ impl Style {
     /// let style = Style::new().dimmed();
     /// println!("{}", style.paint("sup"));
     /// ```
-    pub fn dimmed(&self) -> Style {
+    pub const fn dimmed(&self) -> Style {
         Style {
             is_dimmed: true,
             ..*self
@@ -105,7 +105,7 @@ impl Style {
     /// let style = Style::new().italic();
     /// println!("{}", style.paint("greetings"));
     /// ```
-    pub fn italic(&self) -> Style {
+    pub const fn italic(&self) -> Style {
         Style {
             is_italic: true,
             ..*self
@@ -122,7 +122,7 @@ impl Style {
     /// let style = Style::new().underline();
     /// println!("{}", style.paint("salutations"));
     /// ```
-    pub fn underline(&self) -> Style {
+    pub const fn underline(&self) -> Style {
         Style {
             is_underline: true,
             ..*self
@@ -138,7 +138,7 @@ impl Style {
     /// let style = Style::new().blink();
     /// println!("{}", style.paint("wazzup"));
     /// ```
-    pub fn blink(&self) -> Style {
+    pub const fn blink(&self) -> Style {
         Style {
             is_blink: true,
             ..*self
@@ -155,7 +155,7 @@ impl Style {
     /// let style = Style::new().reverse();
     /// println!("{}", style.paint("aloha"));
     /// ```
-    pub fn reverse(&self) -> Style {
+    pub const fn reverse(&self) -> Style {
         Style {
             is_reverse: true,
             ..*self
@@ -172,7 +172,7 @@ impl Style {
     /// let style = Style::new().hidden();
     /// println!("{}", style.paint("ahoy"));
     /// ```
-    pub fn hidden(&self) -> Style {
+    pub const fn hidden(&self) -> Style {
         Style {
             is_hidden: true,
             ..*self
@@ -189,7 +189,7 @@ impl Style {
     /// let style = Style::new().strikethrough();
     /// println!("{}", style.paint("yo"));
     /// ```
-    pub fn strikethrough(&self) -> Style {
+    pub const fn strikethrough(&self) -> Style {
         Style {
             is_strikethrough: true,
             ..*self
@@ -206,7 +206,7 @@ impl Style {
     /// let style = Style::new().fg(Color::Yellow);
     /// println!("{}", style.paint("hi"));
     /// ```
-    pub fn fg(&self, foreground: Color) -> Style {
+    pub const fn fg(&self, foreground: Color) -> Style {
         Style {
             foreground: Some(foreground),
             ..*self
@@ -223,7 +223,7 @@ impl Style {
     /// let style = Style::new().on(Color::Blue);
     /// println!("{}", style.paint("eyyyy"));
     /// ```
-    pub fn on(&self, background: Color) -> Style {
+    pub const fn on(&self, background: Color) -> Style {
         Style {
             background: Some(background),
             ..*self
@@ -280,7 +280,7 @@ impl Default for Style {
 ///
 /// These use the standard numeric sequences.
 /// See <http://invisible-island.net/xterm/ctlseqs/ctlseqs.html>
-#[derive(PartialEq, Clone, Copy, Debug)]
+#[derive(Eq, PartialEq, Clone, Copy, Debug, Default)]
 #[cfg_attr(
     feature = "derive_serde_style",
     derive(serde::Deserialize, serde::Serialize)
@@ -368,15 +368,10 @@ pub enum Color {
     Rgb(u8, u8, u8),
 
     /// The default color (foreground code `39`, background codr `49`).
+    #[default]
     Default,
 }
 
-impl Default for Color {
-    fn default() -> Self {
-        Color::White
-    }
-}
-
 impl Color {
     /// Returns a `Style` with the foreground color set to this color.
     ///

src/util.rs

@@ -2,11 +2,7 @@ use crate::display::{AnsiString, AnsiStrings};
 use std::ops::Deref;
 
 /// Return a substring of the given AnsiStrings sequence, while keeping the formatting.
-pub fn sub_string<'a>(
-    start: usize,
-    len: usize,
-    strs: &AnsiStrings<'a>,
-) -> Vec<AnsiString<'static>> {
+pub fn sub_string(start: usize, len: usize, strs: &AnsiStrings) -> Vec<AnsiString<'static>> {
     let mut vec = Vec::new();
     let mut pos = start;
     let mut len_rem = len;

src/windows.rs

@@ -9,39 +9,34 @@
 #[cfg(windows)]
 pub fn enable_ansi_support() -> Result<(), u32> {
     // ref: https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences#EXAMPLE_OF_ENABLING_VIRTUAL_TERMINAL_PROCESSING @@ https://archive.is/L7wRJ#76%
-
-    use std::ffi::OsStr;
-    use std::iter::once;
-    use std::os::windows::ffi::OsStrExt;
-    use std::ptr::null_mut;
-    use winapi::um::consoleapi::{GetConsoleMode, SetConsoleMode};
-    use winapi::um::errhandlingapi::GetLastError;
-    use winapi::um::fileapi::{CreateFileW, OPEN_EXISTING};
-    use winapi::um::handleapi::INVALID_HANDLE_VALUE;
-    use winapi::um::winnt::{FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE};
-
-    const ENABLE_VIRTUAL_TERMINAL_PROCESSING: u32 = 0x0004;
+    use windows::w;
+    use windows::Win32::Foundation::GetLastError;
+    use windows::Win32::Foundation::INVALID_HANDLE_VALUE;
+    use windows::Win32::Storage::FileSystem::{CreateFileW, OPEN_EXISTING};
+    use windows::Win32::Storage::FileSystem::{
+        FILE_GENERIC_READ, FILE_GENERIC_WRITE, FILE_SHARE_WRITE,
+    };
+    use windows::Win32::System::Console::ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    use windows::Win32::System::Console::{GetConsoleMode, SetConsoleMode};
 
     unsafe {
         // ref: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
         // Using `CreateFileW("CONOUT$", ...)` to retrieve the console handle works correctly even if STDOUT and/or STDERR are redirected
-        let console_out_name: Vec<u16> =
-            OsStr::new("CONOUT$").encode_wide().chain(once(0)).collect();
         let console_handle = CreateFileW(
-            console_out_name.as_ptr(),
-            GENERIC_READ | GENERIC_WRITE,
+            w!("CONOUT$"),
+            FILE_GENERIC_READ | FILE_GENERIC_WRITE,
             FILE_SHARE_WRITE,
-            null_mut(),
+            std::ptr::null_mut(), // SECURITY_ATTRIBUTES
             OPEN_EXISTING,
-            0,
-            null_mut(),
+            0, // FILE_FLAGS_AND_ATTRIBUTES
+            0, // hTemplateFile: HANDLE
         );
         if console_handle == INVALID_HANDLE_VALUE {
             return Err(GetLastError());
         }
 
         // ref: https://docs.microsoft.com/en-us/windows/console/getconsolemode
-        let mut console_mode: u32 = 0;
+        let mut console_mode = 0;
         if 0 == GetConsoleMode(console_handle, &mut console_mode) {
             return Err(GetLastError());
         }
@@ -56,7 +51,7 @@ pub fn enable_ansi_support() -> Result<(), u32> {
                 return Err(GetLastError());
             }
         }
-    }
 
-    Ok(())
+        Ok(())
+    }
 }