tinycolor/
lib.rs

1use std::fmt;
2
3#[cfg(feature = "serde")]
4use serde::{Serialize, Deserialize};
5
6/// A effect/color parameter
7/// 
8/// Wraps a raw u32 value that represents the ANSI Select Graphic Rendition (SGR) parameter
9/// 
10/// # Examples
11/// ```
12/// use tinycolor::ColorParam;
13/// 
14/// let bold = ColorParam::BOLD;
15/// assert_eq!(bold.0, 1);
16/// ```
17/// 
18/// # Feature Flags
19/// - `color-ext`: Enables additional ANSI parameters (`RAPID_BLINK`, `CONCEAL`, `FRAKTUR`)
20/// - `serde`: Enables serialization/deserialization support
21/// 
22/// For more information on SGR parameters,
23/// look at <https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters>
24#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
25#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
26#[repr(transparent)]
27pub struct ColorParam(pub u32);
28
29impl ColorParam {
30    pub const BOLD: Self = Self(1);
31    pub const DIM: Self = Self(2);
32    pub const ITALIC: Self = Self(3);
33    pub const UNDERLINE: Self = Self(4);
34    pub const BLINK: Self = Self(5);
35    #[cfg(feature = "color-ext")] pub const RAPID_BLINK: Self = Self(6);
36    pub const INVERT: Self = Self(7);
37    #[cfg(feature = "color-ext")] pub const CONCEAL: Self = Self(8);
38    pub const STRIKETHROUGH: Self = Self(9);
39    #[cfg(feature = "color-ext")] pub const FRAKTUR: Self = Self(20);
40    pub const BLACK: Self = Self(30);
41    pub const RED: Self = Self(31);
42    pub const GREEN: Self = Self(32);
43    pub const YELLOW: Self = Self(33);
44    pub const BLUE: Self = Self(34);
45    pub const MAGENTA: Self = Self(35);
46    pub const CYAN: Self = Self(36);
47    pub const WHITE: Self = Self(37);
48    pub const RGB: Self = Self(38);
49    pub const ON_BLACK: Self = Self(40);
50    pub const ON_RED: Self = Self(41);
51    pub const ON_GREEN: Self = Self(42);
52    pub const ON_YELLOW: Self = Self(43);
53    pub const ON_BLUE: Self = Self(44);
54    pub const ON_MAGENTA: Self = Self(45);
55    pub const ON_CYAN: Self = Self(46);
56    pub const ON_WHITE: Self = Self(47);
57    pub const ON_RGB: Self = Self(48);
58    pub const BRIGHT_BLACK: Self = Self(90);
59    pub const BRIGHT_RED: Self = Self(91);
60    pub const BRIGHT_GREEN: Self = Self(39);
61    pub const BRIGHT_YELLOW: Self = Self(93);
62    pub const BRIGHT_BLUE: Self = Self(94);
63    pub const BRIGHT_MAGENTA: Self = Self(95);
64    pub const BRIGHT_CYAN: Self = Self(96);
65    pub const BRIGHT_WHITE: Self = Self(97);
66    pub const ON_BRIGHT_BLACK: Self = Self(100);
67    pub const ON_BRIGHT_RED: Self = Self(101);
68    pub const ON_BRIGHT_GREEN: Self = Self(102);
69    pub const ON_BRIGHT_YELLOW: Self = Self(103);
70    pub const ON_BRIGHT_BLUE: Self = Self(104);
71    pub const ON_BRIGHT_MAGENTA: Self = Self(105);
72    pub const ON_BRIGHT_CYAN: Self = Self(106);
73    pub const ON_BRIGHT_WHITE: Self = Self(107);
74}
75
76/// A string with ANSI styling effects applied
77/// 
78/// Created via the [`Colorize`] trait. When displayed, outputs the string wrapped in
79/// the appropriate ANSI escape sequences.
80/// 
81/// # Examples
82/// ```
83/// use tinycolor::Colorize;
84/// 
85/// let styled = "Hello".bold().italic();
86/// println!("{}", styled); // Prints with bold+italic styling
87/// ```
88/// 
89/// # Feature Flags
90/// - `serde`: Enables serialization/deserialization support
91#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
92#[derive(Debug, Clone, PartialEq, Eq, Hash)]
93pub struct ColoredString {
94    /// The actual string content
95    source: Box<str>,
96
97    /// The effects/colors applied to the string
98    colors: Vec<ColorParam>,
99}
100impl fmt::Display for ColoredString {
101    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
102        write!(f, "\x1B[")?;
103        for (idx, color) in self.colors.iter().enumerate() {
104            if idx > 0 {
105                write!(f, ";")?;
106            }
107            write!(f, "{}", color.0)?;
108        }
109        write!(f, "m{}", self.source)?;
110        write!(f, "\x1B[0m")
111    }
112}
113
114/// Extension trait for applying ANSI styling to strings
115/// 
116/// This trait is implemented for any type that implements `AsRef<str>`,
117/// including `&str` and `String`.
118/// 
119/// # Examples
120/// ```
121/// use tinycolor::Colorize;
122/// 
123/// // Works with string literals
124/// println!("{}", "Warning!".red().bold().invert());
125/// 
126/// // Works with owned strings
127/// println!("{}", String::from("Hello").blue().italic());
128/// 
129/// // Can chain multiple effects
130/// println!("{}", "text".green().bold().underline().strikethrough());
131/// ```
132/// 
133/// # Feature Flags
134/// - `color-ext`: Enables additional methods: `rapid_blink`, `conceal`, `fraktur`
135pub trait Colorize {
136    fn bold(&self) -> ColoredString;
137    fn dim(&self) -> ColoredString;
138    fn italic(&self) -> ColoredString;
139    fn underline(&self) -> ColoredString;
140    fn blink(&self) -> ColoredString;
141    #[cfg(feature = "color-ext")] fn rapid_blink(&self) -> ColoredString;
142    fn invert(&self) -> ColoredString;
143    #[cfg(feature = "color-ext")] fn conceal(&self) -> ColoredString;
144    fn strikethrough(&self) -> ColoredString;
145    #[cfg(feature = "color-ext")] fn fraktur(&self) -> ColoredString;
146    fn black(&self) -> ColoredString;
147    fn red(&self) -> ColoredString;
148    fn green(&self) -> ColoredString;
149    fn yellow(&self) -> ColoredString;
150    fn blue(&self) -> ColoredString;
151    fn magenta(&self) -> ColoredString;
152    fn cyan(&self) -> ColoredString;
153    fn white(&self) -> ColoredString;
154    fn rgb(&self, r: u8, g: u8, b: u8) -> ColoredString;
155    fn on_black(&self) -> ColoredString;
156    fn on_red(&self) -> ColoredString;
157    fn on_green(&self) -> ColoredString;
158    fn on_yellow(&self) -> ColoredString;
159    fn on_blue(&self) -> ColoredString;
160    fn on_magenta(&self) -> ColoredString;
161    fn on_cyan(&self) -> ColoredString;
162    fn on_white(&self) -> ColoredString;
163    fn on_rgb(&self, r: u8, g: u8, b: u8) -> ColoredString;
164    fn bright_black(&self) -> ColoredString;
165    fn bright_red(&self) -> ColoredString;
166    fn bright_green(&self) -> ColoredString;
167    fn bright_yellow(&self) -> ColoredString;
168    fn bright_blue(&self) -> ColoredString;
169    fn bright_magenta(&self) -> ColoredString;
170    fn bright_cyan(&self) -> ColoredString;
171    fn bright_white(&self) -> ColoredString;
172    fn on_bright_black(&self) -> ColoredString;
173    fn on_bright_red(&self) -> ColoredString;
174    fn on_bright_green(&self) -> ColoredString;
175    fn on_bright_yellow(&self) -> ColoredString;
176    fn on_bright_blue(&self) -> ColoredString;
177    fn on_bright_magenta(&self) -> ColoredString;
178    fn on_bright_cyan(&self) -> ColoredString;
179    fn on_bright_white(&self) -> ColoredString;
180}
181
182impl<S: AsRef<str>> Colorize for S {
183    fn bold(&self) -> ColoredString {
184        ColoredString {
185            source: Box::from(self.as_ref()),
186            colors: vec![ColorParam::BOLD],
187        }
188    }
189
190    fn dim(&self) -> ColoredString {
191        ColoredString {
192            source: Box::from(self.as_ref()),
193            colors: vec![ColorParam::DIM],
194        }
195    }
196
197    fn italic(&self) -> ColoredString {
198        ColoredString {
199            source: Box::from(self.as_ref()),
200            colors: vec![ColorParam::ITALIC],
201        }
202    }
203
204    fn underline(&self) -> ColoredString {
205        ColoredString {
206            source: Box::from(self.as_ref()),
207            colors: vec![ColorParam::UNDERLINE],
208        }
209    }
210
211    fn blink(&self) -> ColoredString {
212        ColoredString {
213            source: Box::from(self.as_ref()),
214            colors: vec![ColorParam::BLINK],
215        }
216    }
217
218    #[cfg(feature = "color-ext")] fn rapid_blink(&self) -> ColoredString {
219        ColoredString {
220            source: Box::from(self.as_ref()),
221            colors: vec![ColorParam::RAPID_BLINK],
222        }
223    }
224
225    fn invert(&self) -> ColoredString {
226        ColoredString {
227            source: Box::from(self.as_ref()),
228            colors: vec![ColorParam::INVERT],
229        }
230    }
231
232    #[cfg(feature = "color-ext")] fn conceal(&self) -> ColoredString {
233        ColoredString {
234            source: Box::from(self.as_ref()),
235            colors: vec![ColorParam::CONCEAL],
236        }
237    }
238
239    fn strikethrough(&self) -> ColoredString {
240        ColoredString {
241            source: Box::from(self.as_ref()),
242            colors: vec![ColorParam::STRIKETHROUGH],
243        }
244    }
245
246    #[cfg(feature = "color-ext")] fn fraktur(&self) -> ColoredString {
247        ColoredString {
248            source: Box::from(self.as_ref()),
249            colors: vec![ColorParam::FRAKTUR],
250        }
251    }
252    
253    fn black(&self) -> ColoredString {
254        ColoredString {
255            source: Box::from(self.as_ref()),
256            colors: vec![ColorParam::BLACK],
257        }
258    }
259
260    fn red(&self) -> ColoredString {
261        ColoredString {
262            source: Box::from(self.as_ref()),
263            colors: vec![ColorParam::RED],
264        }
265    }
266
267    fn green(&self) -> ColoredString {
268        ColoredString {
269            source: Box::from(self.as_ref()),
270            colors: vec![ColorParam::GREEN],
271        }
272    }
273
274    fn yellow(&self) -> ColoredString {
275        ColoredString {
276            source: Box::from(self.as_ref()),
277            colors: vec![ColorParam::YELLOW],
278        }
279    }
280
281    fn blue(&self) -> ColoredString {
282        ColoredString {
283            source: Box::from(self.as_ref()),
284            colors: vec![ColorParam::BLUE],
285        }
286    }
287    fn magenta(&self) -> ColoredString {
288        ColoredString {
289            source: Box::from(self.as_ref()),
290            colors: vec![ColorParam::MAGENTA],
291        }
292    }
293
294    fn cyan(&self) -> ColoredString {
295        ColoredString {
296            source: Box::from(self.as_ref()),
297            colors: vec![ColorParam::CYAN],
298        }
299    }
300
301    fn white(&self) -> ColoredString {
302        ColoredString {
303            source: Box::from(self.as_ref()),
304            colors: vec![ColorParam::WHITE],
305        }
306    }
307    
308    fn rgb(&self, r: u8, g: u8, b: u8) -> ColoredString {
309        ColoredString {
310            source: Box::from(self.as_ref()),
311            colors: vec![ColorParam::RGB, ColorParam(2), ColorParam(r as u32), ColorParam(g as u32), ColorParam(b as u32)],
312        }
313    }
314    
315    fn on_black(&self) -> ColoredString {
316        ColoredString {
317            source: Box::from(self.as_ref()),
318            colors: vec![ColorParam::ON_BLACK],
319        }
320    }
321
322    fn on_red(&self) -> ColoredString {
323        ColoredString {
324            source: Box::from(self.as_ref()),
325            colors: vec![ColorParam::ON_RED],
326        }
327    }
328
329    fn on_green(&self) -> ColoredString {
330        ColoredString {
331            source: Box::from(self.as_ref()),
332            colors: vec![ColorParam::ON_GREEN],
333        }
334    }
335
336    fn on_yellow(&self) -> ColoredString {
337        ColoredString {
338            source: Box::from(self.as_ref()),
339            colors: vec![ColorParam::ON_YELLOW],
340        }
341    }
342
343    fn on_blue(&self) -> ColoredString {
344        ColoredString {
345            source: Box::from(self.as_ref()),
346            colors: vec![ColorParam::ON_BLUE],
347        }
348    }
349    fn on_magenta(&self) -> ColoredString {
350        ColoredString {
351            source: Box::from(self.as_ref()),
352            colors: vec![ColorParam::ON_MAGENTA],
353        }
354    }
355
356    fn on_cyan(&self) -> ColoredString {
357        ColoredString {
358            source: Box::from(self.as_ref()),
359            colors: vec![ColorParam::ON_CYAN],
360        }
361    }
362
363    fn on_white(&self) -> ColoredString {
364        ColoredString {
365            source: Box::from(self.as_ref()),
366            colors: vec![ColorParam::ON_WHITE],
367        }
368    }
369    
370    fn on_rgb(&self, r: u8, g: u8, b: u8) -> ColoredString {
371        ColoredString {
372            source: Box::from(self.as_ref()),
373            colors: vec![ColorParam::ON_RGB, ColorParam(2), ColorParam(r as u32), ColorParam(g as u32), ColorParam(b as u32)],
374        }
375    }
376    
377    fn bright_black(&self) -> ColoredString {
378        ColoredString {
379            source: Box::from(self.as_ref()),
380            colors: vec![ColorParam::BRIGHT_BLACK],
381        }
382    }
383
384    fn bright_red(&self) -> ColoredString {
385        ColoredString {
386            source: Box::from(self.as_ref()),
387            colors: vec![ColorParam::BRIGHT_RED],
388        }
389    }
390
391    fn bright_green(&self) -> ColoredString {
392        ColoredString {
393            source: Box::from(self.as_ref()),
394            colors: vec![ColorParam::BRIGHT_GREEN],
395        }
396    }
397
398    fn bright_yellow(&self) -> ColoredString {
399        ColoredString {
400            source: Box::from(self.as_ref()),
401            colors: vec![ColorParam::BRIGHT_YELLOW],
402        }
403    }
404
405    fn bright_blue(&self) -> ColoredString {
406        ColoredString {
407            source: Box::from(self.as_ref()),
408            colors: vec![ColorParam::BRIGHT_BLUE],
409        }
410    }
411    fn bright_magenta(&self) -> ColoredString {
412        ColoredString {
413            source: Box::from(self.as_ref()),
414            colors: vec![ColorParam::BRIGHT_MAGENTA],
415        }
416    }
417
418    fn bright_cyan(&self) -> ColoredString {
419        ColoredString {
420            source: Box::from(self.as_ref()),
421            colors: vec![ColorParam::BRIGHT_CYAN],
422        }
423    }
424
425    fn bright_white(&self) -> ColoredString {
426        ColoredString {
427            source: Box::from(self.as_ref()),
428            colors: vec![ColorParam::BRIGHT_WHITE],
429        }
430    }
431    
432    fn on_bright_black(&self) -> ColoredString {
433        ColoredString {
434            source: Box::from(self.as_ref()),
435            colors: vec![ColorParam::ON_BRIGHT_BLACK],
436        }
437    }
438
439    fn on_bright_red(&self) -> ColoredString {
440        ColoredString {
441            source: Box::from(self.as_ref()),
442            colors: vec![ColorParam::ON_BRIGHT_RED],
443        }
444    }
445
446    fn on_bright_green(&self) -> ColoredString {
447        ColoredString {
448            source: Box::from(self.as_ref()),
449            colors: vec![ColorParam::ON_BRIGHT_GREEN],
450        }
451    }
452
453    fn on_bright_yellow(&self) -> ColoredString {
454        ColoredString {
455            source: Box::from(self.as_ref()),
456            colors: vec![ColorParam::ON_BRIGHT_YELLOW],
457        }
458    }
459
460    fn on_bright_blue(&self) -> ColoredString {
461        ColoredString {
462            source: Box::from(self.as_ref()),
463            colors: vec![ColorParam::ON_BRIGHT_BLUE],
464        }
465    }
466    fn on_bright_magenta(&self) -> ColoredString {
467        ColoredString {
468            source: Box::from(self.as_ref()),
469            colors: vec![ColorParam::ON_BRIGHT_MAGENTA],
470        }
471    }
472
473    fn on_bright_cyan(&self) -> ColoredString {
474        ColoredString {
475            source: Box::from(self.as_ref()),
476            colors: vec![ColorParam::ON_BRIGHT_CYAN],
477        }
478    }
479
480    fn on_bright_white(&self) -> ColoredString {
481        ColoredString {
482            source: Box::from(self.as_ref()),
483            colors: vec![ColorParam::ON_BRIGHT_WHITE],
484        }
485    }
486}
487
488impl Colorize for ColoredString {
489    fn bold(&self) -> ColoredString {
490        let mut colors = self.colors.clone();
491        colors.push(ColorParam::BOLD);
492        ColoredString {
493            source: self.source.clone(),
494            colors,
495        }
496    }
497
498    fn dim(&self) -> ColoredString {
499        let mut colors = self.colors.clone();
500        colors.push(ColorParam::DIM);
501        ColoredString {
502            source: self.source.clone(),
503            colors,
504        }
505    }
506
507    fn italic(&self) -> ColoredString {
508        let mut colors = self.colors.clone();
509        colors.push(ColorParam::ITALIC);
510        ColoredString {
511            source: self.source.clone(),
512            colors,
513        }
514    }
515
516    fn underline(&self) -> ColoredString {
517        let mut colors = self.colors.clone();
518        colors.push(ColorParam::UNDERLINE);
519        ColoredString {
520            source: self.source.clone(),
521            colors,
522        }
523    }
524
525    fn blink(&self) -> ColoredString {
526        let mut colors = self.colors.clone();
527        colors.push(ColorParam::BLINK);
528        ColoredString {
529            source: self.source.clone(),
530            colors,
531        }
532    }
533
534    #[cfg(feature = "color-ext")] fn rapid_blink(&self) -> ColoredString {
535        let mut colors = self.colors.clone();
536        colors.push(ColorParam::RAPID_BLINK);
537        ColoredString {
538            source: self.source.clone(),
539            colors,
540        }
541    }
542
543    fn invert(&self) -> ColoredString {
544        let mut colors = self.colors.clone();
545        colors.push(ColorParam::INVERT);
546        ColoredString {
547            source: self.source.clone(),
548            colors,
549        }
550    }
551
552    #[cfg(feature = "color-ext")] fn conceal(&self) -> ColoredString {
553        let mut colors = self.colors.clone();
554        colors.push(ColorParam::CONCEAL);
555        ColoredString {
556            source: self.source.clone(),
557            colors,
558        }
559    }
560
561    fn strikethrough(&self) -> ColoredString {
562        let mut colors = self.colors.clone();
563        colors.push(ColorParam::STRIKETHROUGH);
564        ColoredString {
565            source: self.source.clone(),
566            colors,
567        }
568    }
569
570    #[cfg(feature = "color-ext")] fn fraktur(&self) -> ColoredString {
571        let mut colors = self.colors.clone();
572        colors.push(ColorParam::FRAKTUR);
573        ColoredString {
574            source: self.source.clone(),
575            colors,
576        }
577    }
578    
579    fn black(&self) -> ColoredString {
580        let mut colors = self.colors.clone();
581        colors.push(ColorParam::BLACK);
582        ColoredString {
583            source: self.source.clone(),
584            colors,
585        }
586    }
587
588    fn red(&self) -> ColoredString {
589        let mut colors = self.colors.clone();
590        colors.push(ColorParam::RED);
591        ColoredString {
592            source: self.source.clone(),
593            colors,
594        }
595    }
596
597    fn green(&self) -> ColoredString {
598        let mut colors = self.colors.clone();
599        colors.push(ColorParam::GREEN);
600        ColoredString {
601            source: self.source.clone(),
602            colors,
603        }
604    }
605
606    fn yellow(&self) -> ColoredString {
607        let mut colors = self.colors.clone();
608        colors.push(ColorParam::YELLOW);
609        ColoredString {
610            source: self.source.clone(),
611            colors,
612        }
613    }
614
615    fn blue(&self) -> ColoredString {
616        let mut colors = self.colors.clone();
617        colors.push(ColorParam::BLUE);
618        ColoredString {
619            source: self.source.clone(),
620            colors,
621        }
622    }
623    fn magenta(&self) -> ColoredString {
624        let mut colors = self.colors.clone();
625        colors.push(ColorParam::MAGENTA);
626        ColoredString {
627            source: self.source.clone(),
628            colors,
629        }
630    }
631
632    fn cyan(&self) -> ColoredString {
633        let mut colors = self.colors.clone();
634        colors.push(ColorParam::CYAN);
635        ColoredString {
636            source: self.source.clone(),
637            colors,
638        }
639    }
640
641    fn white(&self) -> ColoredString {
642        let mut colors = self.colors.clone();
643        colors.push(ColorParam::WHITE);
644        ColoredString {
645            source: self.source.clone(),
646            colors,
647        }
648    }
649    
650    fn rgb(&self, r: u8, g: u8, b: u8) -> ColoredString {
651        let mut colors = self.colors.clone();
652        colors.extend([ColorParam::RGB, ColorParam(2), ColorParam(r as u32), ColorParam(g as u32), ColorParam(b as u32)]);
653        ColoredString {
654            source: self.source.clone(),
655            colors,
656        }
657    }
658    
659    fn on_black(&self) -> ColoredString {
660        let mut colors = self.colors.clone();
661        colors.push(ColorParam::ON_BLACK);
662        ColoredString {
663            source: self.source.clone(),
664            colors,
665        }
666    }
667
668    fn on_red(&self) -> ColoredString {
669        let mut colors = self.colors.clone();
670        colors.push(ColorParam::ON_RED);
671        ColoredString {
672            source: self.source.clone(),
673            colors,
674        }
675    }
676
677    fn on_green(&self) -> ColoredString {
678        let mut colors = self.colors.clone();
679        colors.push(ColorParam::ON_GREEN);
680        ColoredString {
681            source: self.source.clone(),
682            colors,
683        }
684    }
685
686    fn on_yellow(&self) -> ColoredString {
687        let mut colors = self.colors.clone();
688        colors.push(ColorParam::ON_YELLOW);
689        ColoredString {
690            source: self.source.clone(),
691            colors,
692        }
693    }
694
695    fn on_blue(&self) -> ColoredString {
696        let mut colors = self.colors.clone();
697        colors.push(ColorParam::ON_BLUE);
698        ColoredString {
699            source: self.source.clone(),
700            colors,
701        }
702    }
703    fn on_magenta(&self) -> ColoredString {
704        let mut colors = self.colors.clone();
705        colors.push(ColorParam::ON_MAGENTA);
706        ColoredString {
707            source: self.source.clone(),
708            colors,
709        }
710    }
711
712    fn on_cyan(&self) -> ColoredString {
713        let mut colors = self.colors.clone();
714        colors.push(ColorParam::ON_CYAN);
715        ColoredString {
716            source: self.source.clone(),
717            colors,
718        }
719    }
720
721    fn on_white(&self) -> ColoredString {
722        let mut colors = self.colors.clone();
723        colors.push(ColorParam::ON_WHITE);
724        ColoredString {
725            source: self.source.clone(),
726            colors,
727        }
728    }
729    
730    fn on_rgb(&self, r: u8, g: u8, b: u8) -> ColoredString {
731        let mut colors = self.colors.clone();
732        colors.extend([ColorParam::ON_RGB, ColorParam(2), ColorParam(r as u32), ColorParam(g as u32), ColorParam(b as u32)]);
733        ColoredString {
734            source: self.source.clone(),
735            colors,
736        }
737    }
738    
739    fn bright_black(&self) -> ColoredString {
740        let mut colors = self.colors.clone();
741        colors.push(ColorParam::BRIGHT_BLACK);
742        ColoredString {
743            source: self.source.clone(),
744            colors,
745        }
746    }
747
748    fn bright_red(&self) -> ColoredString {
749        let mut colors = self.colors.clone();
750        colors.push(ColorParam::BRIGHT_RED);
751        ColoredString {
752            source: self.source.clone(),
753            colors,
754        }
755    }
756
757    fn bright_green(&self) -> ColoredString {
758        let mut colors = self.colors.clone();
759        colors.push(ColorParam::BRIGHT_GREEN);
760        ColoredString {
761            source: self.source.clone(),
762            colors,
763        }
764    }
765
766    fn bright_yellow(&self) -> ColoredString {
767        let mut colors = self.colors.clone();
768        colors.push(ColorParam::BRIGHT_YELLOW);
769        ColoredString {
770            source: self.source.clone(),
771            colors,
772        }
773    }
774
775    fn bright_blue(&self) -> ColoredString {
776        let mut colors = self.colors.clone();
777        colors.push(ColorParam::BRIGHT_BLUE);
778        ColoredString {
779            source: self.source.clone(),
780            colors,
781        }
782    }
783    fn bright_magenta(&self) -> ColoredString {
784        let mut colors = self.colors.clone();
785        colors.push(ColorParam::BRIGHT_MAGENTA);
786        ColoredString {
787            source: self.source.clone(),
788            colors,
789        }
790    }
791
792    fn bright_cyan(&self) -> ColoredString {
793        let mut colors = self.colors.clone();
794        colors.push(ColorParam::BRIGHT_CYAN);
795        ColoredString {
796            source: self.source.clone(),
797            colors,
798        }
799    }
800
801    fn bright_white(&self) -> ColoredString {
802        let mut colors = self.colors.clone();
803        colors.push(ColorParam::BRIGHT_WHITE);
804        ColoredString {
805            source: self.source.clone(),
806            colors,
807        }
808    }
809    
810    fn on_bright_black(&self) -> ColoredString {
811        let mut colors = self.colors.clone();
812        colors.push(ColorParam::ON_BRIGHT_BLACK);
813        ColoredString {
814            source: self.source.clone(),
815            colors,
816        }
817    }
818
819    fn on_bright_red(&self) -> ColoredString {
820        let mut colors = self.colors.clone();
821        colors.push(ColorParam::ON_BRIGHT_RED);
822        ColoredString {
823            source: self.source.clone(),
824            colors,
825        }
826    }
827
828    fn on_bright_green(&self) -> ColoredString {
829        let mut colors = self.colors.clone();
830        colors.push(ColorParam::ON_BRIGHT_GREEN);
831        ColoredString {
832            source: self.source.clone(),
833            colors,
834        }
835    }
836
837    fn on_bright_yellow(&self) -> ColoredString {
838        let mut colors = self.colors.clone();
839        colors.push(ColorParam::ON_BRIGHT_YELLOW);
840        ColoredString {
841            source: self.source.clone(),
842            colors,
843        }
844    }
845
846    fn on_bright_blue(&self) -> ColoredString {
847        let mut colors = self.colors.clone();
848        colors.push(ColorParam::ON_BRIGHT_BLUE);
849        ColoredString {
850            source: self.source.clone(),
851            colors,
852        }
853    }
854    fn on_bright_magenta(&self) -> ColoredString {
855        let mut colors = self.colors.clone();
856        colors.push(ColorParam::ON_BRIGHT_MAGENTA);
857        ColoredString {
858            source: self.source.clone(),
859            colors,
860        }
861    }
862
863    fn on_bright_cyan(&self) -> ColoredString {
864        let mut colors = self.colors.clone();
865        colors.push(ColorParam::ON_BRIGHT_CYAN);
866        ColoredString {
867            source: self.source.clone(),
868            colors,
869        }
870    }
871
872    fn on_bright_white(&self) -> ColoredString {
873        let mut colors = self.colors.clone();
874        colors.push(ColorParam::ON_BRIGHT_WHITE);
875        ColoredString {
876            source: self.source.clone(),
877            colors,
878        }
879    }
880}
tinycolor/lib.rs

tinycolor/
lib.rs
