rainbow 0.14.0.2 → 0.34.2.2
raw patch · 18 files changed
Files
- LICENSE +1/−1
- README.md +6/−31
- changelog +0/−8
- current-versions.txt +0/−40
- lib/Rainbow.hs +354/−0
- lib/Rainbow/Translate.hs +355/−0
- lib/Rainbow/Types.hs +239/−0
- lib/System/Console/Rainbow.hs +0/−145
- lib/System/Console/Rainbow/ColorChunks.hs +0/−1880
- lib/System/Console/Rainbow/Colors.hs +0/−1240
- lib/System/Console/Rainbow/Types.hs +0/−483
- minimum-versions.txt +0/−40
- rainbow.cabal +83/−48
- stack.yaml +32/−0
- sunlight-test.hs +0/−15
- tests/Rainbow/QuickCheck.hs +106/−0
- tests/rainbow-instances.hs +10/−0
- tests/rainbow-visual.hs +18/−0
LICENSE view
@@ -1,4 +1,4 @@-Copyright (c) 2013-2014, Omari Norman+Copyright (c) 2013-2019 Omari Norman All rights reserved.
README.md view
@@ -1,7 +1,9 @@ # rainbow rainbow helps you build colorful output for both 8- and 256-color-terminals. It works only on Unix-like operating systems.+terminals. It works only on Unix-like operating systems. For more+information, please see the documentation in the main Rainbow+module. rainbow is on Github: @@ -11,35 +13,8 @@ http://hackage.haskell.org/package/rainbow -rainbow is licensed under the BSD license; see the LICENSE file.--## Versioning--rainbow releases are numbered in accordance with the Haskell-Package Versioning Policy.--rainbow does not set its dependencies in accordance with the-Package Versioning Policy, as I do not set upper bounds. rainbow-is guaranteed to build with the *minimum* versions specified in the-cabal file. I also include a dependencies.txt file that-documents more recent dependencies that are also known to work.--If you find that rainbow does not build due to dependency problems:-1) please let me know at omari@smileystation.com; 2) feel free to-add appropriate upper bounds or patches to the package as-appropriate; and 3) feel free to add command-line contraints to your-cabal command to get it to build.--## Building--If you get the package from Hackage, it is ready to build with-`cabal install` like any other Haskell package.--If you get it from Github, first you will need to create the cabal-file. It's built using m4 to avoid redundancies in the file. To-build the cabal file, simply invoke `make`.+and Stackage: -## Generators package+https://www.stackage.org/package/rainbow -The source tree also includes a package `rainbow-tests` which-includes several generators that other packages might find useful.+rainbow is licensed under the BSD license; see the LICENSE file.
− changelog
@@ -1,8 +0,0 @@-0.14.0.2- * Change dependency bounds- * Change cabal generator to cartel--0.14.0.0-- * Change Chunk to hold a list of strict Text rather- than just a single Text.
− current-versions.txt
@@ -1,40 +0,0 @@-This package was tested to work with these dependency-versions and compiler version.-These are the default versions fetched by cabal install.-Tested as of: 2014-06-14 00:45:34.239001 UTC-Path to compiler: ghc-7.8.2-Compiler description: 7.8.2--/opt/ghc/7.8.2/lib/ghc-7.8.2/package.conf.d:- Cabal-1.18.1.3- array-0.5.0.0- base-4.7.0.0- bin-package-db-0.0.0.0- binary-0.7.1.0- rts-1.0- bytestring-0.10.4.0- containers-0.5.5.1- deepseq-1.3.0.2- directory-1.2.1.0- filepath-1.3.0.2- (ghc-7.8.2)- ghc-prim-0.3.1.0- (haskell2010-1.1.2.0)- (haskell98-2.0.0.3)- hoopl-3.10.0.1- hpc-0.6.0.1- integer-gmp-0.5.1.0- old-locale-1.0.0.6- old-time-1.1.0.2- pretty-1.1.1.1- process-1.2.0.0- template-haskell-2.9.0.0- time-1.4.2- transformers-0.3.0.0- unix-2.7.0.1--/home/massysett/rainbow/sunlight-9457/db:- rainbow-0.14.0.2- terminfo-0.4.0.0- text-1.1.1.3-
+ lib/Rainbow.hs view
@@ -0,0 +1,354 @@+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE DeriveFoldable #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RankNTypes #-}++-- | Rainbow handles colors and special effects for text. The basic+-- building block of Rainbow is the 'Y.Chunk'. The 'Y.Chunk' contains+-- both text and formatting information such as colors, bold,+-- underlining, etc. 'Y.Chunk' is an instance of+-- 'Data.String.IsString' so you can create a 'Y.Chunk' using the+-- @OverloadedStrings@ extension. Such a chunk has the given text+-- and has no formatting.+--+-- When printed, each 'Y.Chunk' starts off with a clean slate, so if+-- you want special formatting such as any color, bold, etc, then you+-- must specify it for every 'Y.Chunk'. The appearance of one+-- 'Y.Chunk' does not affect the appearance of the next 'Y.Chunk'.+-- This makes it easy to reason about how a particular 'Y.Chunk' will+-- look.+--+-- Rainbow supports 256-color terminals. You have full freedom to+-- specify different attributes and colors for 8 and 256 color+-- terminals; for instance, you can have text appear red on an 8-color+-- terminal but blue on a 256-color terminal.+--+-- Here are some basic examples:+--+-- @+-- ghci> import Rainbow+-- ghci> import Data.Function ((&))+-- ghci> :set -XOverloadedStrings+-- ghci> 'T.putChunkLn' $ \"Some blue text\" '&' 'fore' 'blue'+-- ghci> 'T.putChunkLn' $ \"Blue on red background\"+-- '&' 'fore' 'blue' '&' 'back' 'red'+-- ghci> 'T.putChunkLn' $ \"Blue on red, foreground bold\"+-- '&' 'fore' 'blue' '&' 'back' 'red' '&' 'bold'+-- @+--+-- You can also specify output for 256-color terminals. To use these+-- examples, be sure your TERM environment variable is set to+-- something that supports 256 colors (like @xterm-256color@) before+-- you start GHCi.+--+-- @+-- ghci> 'T.putChunkLn' $ \"Blue on 8, bright green on 256\" '&'+-- 'fore' ('blue' '<>' 'brightGreen')+--+-- ghci> 'T.putChunkLn' $ \"Blue on 8, red on 256" '&'+-- 'fore' ('blue' '<>' 'only256' 'red')+-- @+--+-- Each 'Y.Chunk' affects the formatting only of that 'Y.Chunk'. So+-- to print things in different colors, make more than one 'Y.Chunk':+--+-- @+-- ghci> 'T.putChunksLn'+-- [ \"Roses\" '&' 'fore' 'red'+-- , \"Violets\" '&' 'fore' 'blue' ]+-- @+--+-- Most of the above examples use 'T.putChunkLn', but that function+-- may be inefficient if you are printing many 'Y.Chunk's. For+-- greater efficiency use functions under the heading \"Converting+-- multiple Chunk to ByteString\", including 'T.putChunksLn' and+-- 'T.putChunks'.+--+-- The functions in this module, "Rainbow", will likely be enough for+-- most uses, but for more flexibility you can use "Rainbow.Types".+-- Use of "Rainbow.Types" will require some familiarity with the+-- @lens@ library.+++module Rainbow+ (+ -- * Chunk+ Y.Chunk+ , Y.chunk++ -- * Formatting, all terminals++ -- | These combinators affect the way a 'Y.Chunk' is displayed on+ -- both 8- and 256-color terminals.+ , bold+ , faint+ , italic+ , underline+ , blink+ , inverse+ , invisible+ , strikeout++ -- * Colors+ , Y.Radiant+ , fore+ , back++ -- * Colors, all terminals++ -- | These 'Y.Radiant' affect the way a 'Y.Chunk' is displayed on+ -- both 8- and 256-color terminals.+ , black+ , red+ , green+ , yellow+ , blue+ , magenta+ , cyan+ , white++ -- * Colors, 256-color terminals only++ -- | These 'Y.Radiant' affect 256-color terminals only.+ , grey+ , brightRed+ , brightGreen+ , brightYellow+ , brightBlue+ , brightMagenta+ , brightCyan+ , brightWhite+ , color256+ , only256++ -- * Converting multiple 'Y.Chunk' to 'Data.ByteString.ByteString'++ -- | To print a 'Y.Chunk', you need to convert it to some+ -- 'Data.ByteString.ByteString's.+ --+ -- All these functions convert the 'Data.Text' to UTF-8+ -- 'Data.ByteString.ByteString's. Many of these functions return a+ -- difference list. Learn You a Haskell for Great Good has a great+ -- explanation of difference lists:+ --+ -- http://learnyouahaskell.com/for-a-few-monads-more+ --+ -- If you don't want to learn about difference lists, just stick+ -- with using 'T.chunksToByteStrings' and use+ -- 'T.byteStringMakerFromEnvironment' if you want to use the highest+ -- number of colors possible, or, to manually specify the number of+ -- colors, use 'T.chunksToByteStrings' with 'T.toByteStringsColors0',+ -- 'T.toByteStringsColors8', or 'T.toByteStringsColors256' as the first+ -- argument. 'T.chunksToByteStrings' has an example.+ --+ -- For output to handles or to standard output, just use+ -- 'T.hPutChunks' or 'T.putChunks'.+ , T.toByteStringsColors0+ , T.toByteStringsColors8+ , T.toByteStringsColors256+ , T.byteStringMakerFromEnvironment+ , T.byteStringMakerFromHandle+ , T.chunksToByteStrings++ -- * Writing multiple 'Y.Chunk' to a handle or to standard output+ , T.putChunks+ , T.hPutChunks+ , T.putChunksLn+ , T.hPutChunksLn++ -- * Quick and dirty functions for IO++ -- | For efficiency reasons you probably don't want to use these+ -- when printing large numbers of 'Y.Chunk', but they are handy for+ -- throwaway uses like experimenting in GHCi.+ , T.putChunk+ , T.putChunkLn++ -- * Notes on terminals+ -- $termNotes++ ) where++import qualified Rainbow.Translate as T+import qualified Rainbow.Types as Y+import Data.Word (Word8)+import Data.Function ((&))+import qualified Control.Lens as Lens+import Control.Lens ((.~))+import Data.Monoid (Monoid(mempty))++formatBoth :: Lens.Setter' Y.Format Bool -> Y.Chunk -> Y.Chunk+formatBoth get c = c & Y.scheme . Y.style8 . Y.format . get .~ True+ & Y.scheme . Y.style256 . Y.format . get .~ True++-- | Bold. What actually happens when you use Bold is going to depend+-- on your terminal. For example, xterm allows you actually use a bold+-- font for bold, if you have one. Otherwise, it might simulate bold+-- by using overstriking. Another possibility is that your terminal+-- might use a different color to indicate bold. For more details (at+-- least for xterm), look at xterm (1) and search for @boldColors@.+--+-- If your terminal uses a different color for bold, this allows an+-- 8-color terminal to really have 16 colors.+bold :: Y.Chunk -> Y.Chunk+bold = formatBoth Y.bold++faint :: Y.Chunk -> Y.Chunk+faint = formatBoth Y.faint++italic :: Y.Chunk -> Y.Chunk+italic = formatBoth Y.italic++underline :: Y.Chunk -> Y.Chunk+underline = formatBoth Y.underline++blink :: Y.Chunk -> Y.Chunk+blink = formatBoth Y.blink++inverse :: Y.Chunk -> Y.Chunk+inverse = formatBoth Y.inverse++invisible :: Y.Chunk -> Y.Chunk+invisible = formatBoth Y.invisible++strikeout :: Y.Chunk -> Y.Chunk+strikeout = formatBoth Y.strikeout++-- | Change the foreground color. Whether this affects 8-color+-- terminals, 256-color terminals, or both depends on the 'Y.Radiant'.+fore :: Y.Radiant -> Y.Chunk -> Y.Chunk+fore (Y.Radiant c8 c256) c = c & Y.scheme . Y.style8 . Y.fore .~ c8+ & Y.scheme . Y.style256 . Y.fore .~ c256++-- | Change the background color. Whether this affects 8-color+-- terminals, 256-color terminals, or both depends on the 'Y.Radiant'.+back :: Y.Radiant -> Y.Chunk -> Y.Chunk+back (Y.Radiant c8 c256) c = c & Y.scheme . Y.style8 . Y.back .~ c8+ & Y.scheme . Y.style256 . Y.back .~ c256++-- | Ensures that a 'Y.Radiant' affects only a 256-color terminal.+-- For instance, to make text that is blue on an 8-color terminal but+-- red on a 256-color terminal:+--+-- @+-- 'T.putChunkLn' $ \"Blue on 8, red on 256\" &+-- 'fore' ('blue' <> 'only256' 'red')+-- @+only256 :: Y.Radiant -> Y.Radiant+only256 (Y.Radiant _ c256) = Y.Radiant mempty c256++black :: Y.Radiant+black = Y.Radiant (Y.Color (Just Y.E0)) (Y.Color (Just 0))++red :: Y.Radiant+red = Y.Radiant (Y.Color (Just Y.E1)) (Y.Color (Just 1))++green :: Y.Radiant+green = Y.Radiant (Y.Color (Just Y.E2)) (Y.Color (Just 2))++yellow :: Y.Radiant+yellow = Y.Radiant (Y.Color (Just Y.E3)) (Y.Color (Just 3))++blue :: Y.Radiant+blue = Y.Radiant (Y.Color (Just Y.E4)) (Y.Color (Just 4))++magenta :: Y.Radiant+magenta = Y.Radiant (Y.Color (Just Y.E5)) (Y.Color (Just 5))++cyan :: Y.Radiant+cyan = Y.Radiant (Y.Color (Just Y.E6)) (Y.Color (Just 6))++white :: Y.Radiant+white = Y.Radiant (Y.Color (Just Y.E7)) (Y.Color (Just 7))++grey :: Y.Radiant+grey = color256 8++brightRed :: Y.Radiant+brightRed = color256 9++brightGreen :: Y.Radiant+brightGreen = color256 10++brightYellow :: Y.Radiant+brightYellow = color256 11++brightBlue :: Y.Radiant+brightBlue = color256 12++brightMagenta :: Y.Radiant+brightMagenta = color256 13++brightCyan :: Y.Radiant+brightCyan = color256 14++brightWhite :: Y.Radiant+brightWhite = color256 15++-- | A 'Y.Radiant' for any of the 256 colors available. Supply the+-- color number. Exactly which color you'll get for a given number+-- is dependent on the terminal; though there seem to be common+-- defaults, often the user can configure this however she likes.+-- The resulting 'Y.Radiant' will affect 256-color terminals only.+color256 :: Word8 -> Y.Radiant+color256 x = Y.Radiant (Y.Color Nothing) (Y.Color (Just x))+++{- $termNotes++Earlier versions of Rainbow used the Haskell terminfo library for+dealing with the terminal. Terminfo is available at++<https://hackage.haskell.org/package/terminfo>++Terminfo, in turn, uses the UNIX terminfo library. The biggest+advantage of using Terminfo is that it is compatible with a huge+variety of terminals. Many of these terminals are hardware models+that are gathering dust in an IBM warehouse somewhere, but even modern+software terminals might have quirks. Terminfo covers all those.++The disadvantage is that using Terminfo requires you to perform IO+whenever you need to format output for the terminal. Your only choice+when using Terminfo is to send output directly to the terminal, or to+a handle. This goes against typical Haskell practice, where we try to+write pure code whenever possible.++Perhaps surprisingly, there are times where you may want to format+output, but not immediately send it to the terminal. Maybe you want+to send it to a file instead, or maybe you want to use a Haskell+library like Pipes and stream it somewhere. Terminfo is a binding to+a Unix library that is not designed for this sort of thing. The+closest you could get using Terminfo would be to make a Handle that is+backed by a in-memory buffer. There is a package for that sort of+thing:++<http://hackage.haskell.org/package/knob>++but it seems like a nasty workaround. Or you can hijack stdout and+send that somewhere--again, nasty workaround.++So I decided to stop using Terminfo. That means Rainbow no longer+supports a menagerie of bizarre terminals. It instead just uses the+standard ISO 6429 / ECMA 48 terminal codes. These are the same codes+that are used by xterm, the OS X Terminal, the Linux console, or any+other reasonably modern software terminal. Realistically they are the+only terminals Rainbow would be used for.++The 256 color capability is not in ISO 6429, but it is widely supported.++Probably the most common so-called terminals in use today that do NOT+support the ISO 6429 codes are those that are not really terminals.+For instance, you might use an Emacs shell buffer. For those+situations just use 'T.toByteStringsColors0'.++I also decided to standardize on UTF-8 for the 'Data.Text.Text'+output. These days that seems reasonable.++Apparently it's difficult to get ISO 6429 support on Microsoft+Windows. Oh well.++-}
+ lib/Rainbow/Translate.hs view
@@ -0,0 +1,355 @@+{-# LANGUAGE FlexibleInstances #-}++-- | This module contains functions that convert a 'T.Chunk' into+-- 'ByteString's. Ordinarily everything you need from this module is+-- exported from "Rainbow".+module Rainbow.Translate where++import Control.Exception (try)+import Data.ByteString (ByteString)+import Data.List (intersperse)+import Data.Text (Text)+import Data.Word (Word8)+import qualified Data.ByteString as BS+import qualified Data.ByteString.Char8 as BS8+import qualified Data.Text.Encoding as X+import qualified Rainbow.Types as T+import qualified System.Console.Terminfo as Terminfo+import qualified System.IO as IO+++single :: Char -> [ByteString] -> [ByteString]+single c = ((BS8.singleton c):)++escape :: [ByteString] -> [ByteString]+escape = single '\x1B'++csi :: [ByteString] -> [ByteString]+csi = escape . single '['++sgr :: ([ByteString] -> [ByteString]) -> [ByteString] -> [ByteString]+sgr sq = csi . sq . single 'm'++params :: Show a => [a] -> [ByteString] -> [ByteString]+params cs = ((intersperse semi . map (BS8.pack . show) $ cs) ++)+ where+ semi = BS8.singleton ';'++sgrSingle :: Word -> [ByteString] -> [ByteString]+sgrSingle w = sgr $ params [w]++sgrDouble :: Word -> Word -> [ByteString] -> [ByteString]+sgrDouble x y = sgr $ params [x, y]++normalDefault :: [ByteString] -> [ByteString]+normalDefault = sgrSingle 0++bold :: [ByteString] -> [ByteString]+bold = sgrSingle 1++faint :: [ByteString] -> [ByteString]+faint = sgrSingle 2++italic :: [ByteString] -> [ByteString]+italic = sgrSingle 3++underline :: [ByteString] -> [ByteString]+underline = sgrSingle 4++blink :: [ByteString] -> [ByteString]+blink = sgrSingle 5++-- Yes, blink is 5, inverse is 7; 6 is skipped. In ISO 6429 6 blinks+-- at a different rate.++inverse :: [ByteString] -> [ByteString]+inverse = sgrSingle 7++invisible :: [ByteString] -> [ByteString]+invisible = sgrSingle 8++strikeout :: [ByteString] -> [ByteString]+strikeout = sgrSingle 9++foreBlack :: [ByteString] -> [ByteString]+foreBlack = sgrSingle 30++foreRed :: [ByteString] -> [ByteString]+foreRed = sgrSingle 31++foreGreen :: [ByteString] -> [ByteString]+foreGreen = sgrSingle 32++foreYellow :: [ByteString] -> [ByteString]+foreYellow = sgrSingle 33++foreBlue :: [ByteString] -> [ByteString]+foreBlue = sgrSingle 34++foreMagenta :: [ByteString] -> [ByteString]+foreMagenta = sgrSingle 35++foreCyan :: [ByteString] -> [ByteString]+foreCyan = sgrSingle 36++foreWhite :: [ByteString] -> [ByteString]+foreWhite = sgrSingle 37++-- code 3 8 is skipped++foreDefault :: [ByteString] -> [ByteString]+foreDefault = sgrSingle 39++backBlack :: [ByteString] -> [ByteString]+backBlack = sgrSingle 40++backRed :: [ByteString] -> [ByteString]+backRed = sgrSingle 41++backGreen :: [ByteString] -> [ByteString]+backGreen = sgrSingle 42++backYellow :: [ByteString] -> [ByteString]+backYellow = sgrSingle 43++backBlue :: [ByteString] -> [ByteString]+backBlue = sgrSingle 44++backMagenta :: [ByteString] -> [ByteString]+backMagenta = sgrSingle 45++backCyan :: [ByteString] -> [ByteString]+backCyan = sgrSingle 46++backWhite :: [ByteString] -> [ByteString]+backWhite = sgrSingle 47++-- code 4 8 is skipped++backDefault :: [ByteString] -> [ByteString]+backDefault = sgrSingle 49++fore256 :: Word8 -> [ByteString] -> [ByteString]+fore256 c = sgr $ params [38,5,c]++back256 :: Word8 -> [ByteString] -> [ByteString]+back256 c = sgr $ params [48,5,c]++foreColor8 :: T.Enum8 -> [ByteString] -> [ByteString]+foreColor8 e8 = case e8 of+ T.E0 -> foreBlack+ T.E1 -> foreRed+ T.E2 -> foreGreen+ T.E3 -> foreYellow+ T.E4 -> foreBlue+ T.E5 -> foreMagenta+ T.E6 -> foreCyan+ T.E7 -> foreWhite++backColor8 :: T.Enum8 -> [ByteString] -> [ByteString]+backColor8 e8 = case e8 of+ T.E0 -> backBlack+ T.E1 -> backRed+ T.E2 -> backGreen+ T.E3 -> backYellow+ T.E4 -> backBlue+ T.E5 -> backMagenta+ T.E6 -> backCyan+ T.E7 -> backWhite++renderFormat :: T.Format -> [ByteString] -> [ByteString]+renderFormat (T.Format bld fnt ita und bli ivr isb stk)+ = effect bold bld+ . effect faint fnt+ . effect italic ita+ . effect underline und+ . effect blink bli+ . effect inverse ivr+ . effect invisible isb+ . effect strikeout stk+ where+ effect on x = if x then on else id++renderStyle8 :: T.Style T.Enum8 -> [ByteString] -> [ByteString]+renderStyle8 (T.Style fore back format)+ = effect foreColor8 fore+ . effect backColor8 back+ . renderFormat format+ where+ effect on (T.Color may) = maybe id on may++renderStyle256 :: T.Style Word8 -> [ByteString] -> [ByteString]+renderStyle256 (T.Style fore back format)+ = effect fore256 fore+ . effect back256 back+ . renderFormat format+ where+ effect on (T.Color may) = maybe id on may++render :: Text -> [ByteString] -> [ByteString]+render x = (X.encodeUtf8 x :)++toByteStringsColors0+ :: T.Chunk+ -> [ByteString]+ -> [ByteString]+toByteStringsColors0 (T.Chunk _ yn) = render yn++toByteStringsColors8+ :: T.Chunk+ -> [ByteString]+ -> [ByteString]+toByteStringsColors8 (T.Chunk (T.Scheme s8 _) yn)+ = normalDefault+ . renderStyle8 s8+ . render yn+ . normalDefault++toByteStringsColors256+ :: T.Chunk+ -> [ByteString]+ -> [ByteString]+toByteStringsColors256 (T.Chunk (T.Scheme _ s256) yn)+ = normalDefault+ . renderStyle256 s256+ . render yn+ . normalDefault+++-- | Uses 'Terminfo.setupTermFromEnv' to obtain the terminal's color+-- capability. If this says there are at least 256 colors are+-- available, returns 'toByteStringsColors256'. Otherwise, if there+-- are at least 8 colors available, returns 'toByteStringsColors8'.+-- Otherwise, returns 'toByteStringsColors0'.+--+-- If the terminfo database could not be read (that is, if+-- 'System.Console.Terminfo.Base.SetupTermError' is returned), then return+-- 'toByteStringsColors0'.+byteStringMakerFromEnvironment+ :: IO (T.Chunk -> [ByteString] -> [ByteString])+byteStringMakerFromEnvironment = fmap g (try Terminfo.setupTermFromEnv)+ where+ g (Left e) = toByteStringsColors0+ where+ -- Previously this caught all IOException. Now it catches only SetupTermError.+ -- See+ -- https://github.com/commercialhaskell/stackage/issues/4994+ -- Hopefully this will fix this Stackage bug.+ _types = e :: Terminfo.SetupTermError+ g (Right terminal) =+ case Terminfo.getCapability terminal (Terminfo.tiGetNum "colors") of+ Nothing -> toByteStringsColors0+ Just c+ | c >= 256 -> toByteStringsColors256+ | c >= 8 -> toByteStringsColors8+ | otherwise -> toByteStringsColors0++-- | Like 'byteStringMakerFromEnvironment' but also consults a+-- provided 'IO.Handle'. If the 'IO.Handle' is not a terminal,+-- 'toByteStringsColors0' is returned. Otherwise, the value of+-- 'byteStringMakerFromEnvironment' is returned.+byteStringMakerFromHandle+ :: IO.Handle+ -> IO (T.Chunk -> [ByteString] -> [ByteString])+byteStringMakerFromHandle h = IO.hIsTerminalDevice h >>= f+ where+ f isTerm | isTerm = byteStringMakerFromEnvironment+ | otherwise = return toByteStringsColors0+ ++-- | Convert a list of 'T.Chunk' to a list of 'ByteString'. The+-- length of the returned list may be longer than the length of the+-- input list.+--+-- So, for example, to print a bunch of chunks to standard output+-- using 256 colors:+--+-- > module PrintMyChunks where+-- >+-- > import qualified Data.ByteString as BS+-- > import Rainbow+-- >+-- > myChunks :: [Chunk String]+-- > myChunks = [ chunk "Roses" & fore red, chunk "\n",+-- > chunk "Violets" & fore blue, chunk "\n" ]+-- >+-- > myPrintedChunks :: IO ()+-- > myPrintedChunks = mapM_ BS.putStr+-- > . chunksToByteStrings toByteStringsColors256+-- > $ myChunks+--+-- To use the highest number of colors that this terminal supports:+--+-- > myPrintedChunks' :: IO ()+-- > myPrintedChunks' = do+-- > printer <- byteStringMakerFromEnvironment+-- > mapM_ BS.putStr+-- > . chunksToByteStrings printer+-- > $ myChunks++chunksToByteStrings+ :: (T.Chunk -> [ByteString] -> [ByteString])+ -- ^ Function that converts 'T.Chunk' to 'ByteString'. This+ -- function, when applied to a 'T.Chunk', returns a difference list.+ -> [T.Chunk]+ -> [ByteString]+chunksToByteStrings mk = ($ []) . foldr (.) id . map mk++-- | Writes a list of chunks to the given 'IO.Handle'.+--+-- First uses 'byteStringMakerFromEnvironment' to determine how many+-- colors to use. Then creates a list of 'ByteString' using+-- 'chunksToByteStrings' and then writes them to the given 'IO.Handle'.+hPutChunks :: IO.Handle -> [T.Chunk] -> IO ()+hPutChunks h cks = do+ maker <- byteStringMakerFromEnvironment+ let bsList = chunksToByteStrings maker cks+ mapM_ (BS.hPut h) bsList++-- | Writes a list of chunks to the given 'IO.Handle', followed by a+-- newline character.+--+-- First uses 'byteStringMakerFromEnvironment' to determine how many+-- colors to use. Then creates a list of 'ByteString' using+-- 'chunksToByteStrings' and then writes them to the given 'IO.Handle'.+hPutChunksLn :: IO.Handle -> [T.Chunk] -> IO ()+hPutChunksLn h cks = do+ hPutChunks h cks+ IO.hPutStr h "\n"++-- | Writes a list of chunks to standard output.+--+-- First uses 'byteStringMakerFromEnvironment' to determine how many+-- colors to use. Then creates a list of 'ByteString' using+-- 'chunksToByteStrings' and then writes them to standard output.+putChunks :: [T.Chunk] -> IO ()+putChunks = hPutChunks IO.stdout++-- | Writes a list of chunks to standard output, followed by a+-- newline.+--+-- First uses 'byteStringMakerFromEnvironment' to determine how many+-- colors to use. Then creates a list of 'ByteString' using+-- 'chunksToByteStrings' and then writes them to standard output.+putChunksLn :: [T.Chunk] -> IO ()+putChunksLn cks = do+ putChunks cks+ IO.putStr "\n"++-- | Writes a 'T.Chunk' to standard output. Uses+-- 'byteStringMakerFromEnvironment' each time you apply it, so this+-- might be inefficient. You are better off using+-- 'chunksToByteStrings' and the functions in "Data.ByteString" to+-- print your 'T.Chunk's if you are printing a lot of them.+putChunk :: T.Chunk -> IO ()+putChunk ck = do+ mkr <- byteStringMakerFromEnvironment+ mapM_ BS.putStr . chunksToByteStrings mkr $ [ck]++-- | Writes a 'T.Chunk' to standard output, and appends a newline.+-- Uses 'byteStringMakerFromEnvironment' each time you apply it, so+-- this might be inefficient. You are better off using+-- 'chunksToByteStrings' and the functions in "Data.ByteString" to+-- print your 'T.Chunk's if you are printing a lot of them.+putChunkLn :: T.Chunk -> IO ()+putChunkLn ck = putChunk ck >> putStrLn ""
+ lib/Rainbow/Types.hs view
@@ -0,0 +1,239 @@+{-# LANGUAGE DeriveGeneric, DeriveDataTypeable, DeriveFunctor,+ DeriveTraversable, DeriveFoldable, TemplateHaskell #-}++-- | All the main types in Rainbow. Using this module you can specify+-- that you want different formatting for 8- and 256-color terminals.+-- Many of the names in this module conflict with the names in+-- "Rainbow", so it's probably best to @import@ this module+-- @qualified@.+module Rainbow.Types where++-- # Imports++import Control.Lens (makeLenses)+import Data.String (IsString(..))+import Data.Text (Text)+import qualified Data.Text as X+import Data.Traversable ()+import Data.Typeable (Typeable)+import Data.Word (Word8)+import GHC.Generics (Generic)++--+-- Colors+--++-- | A color; a 'Nothing' value means that the terminal's default+-- color is used. The type of the 'Maybe' generally will be an+-- 'Enum8' to represent one of 8 colors, or a 'Word8' to represent one+-- of 256 colors.+newtype Color a = Color (Maybe a)+ deriving (Eq, Show, Ord, Generic, Typeable, Functor, Foldable,+ Traversable)++instance Semigroup (Color a) where+ Color x <> Color y = case y of+ Just a -> Color (Just a)+ _ -> Color x++-- | Takes the last non-Nothing Color. 'mempty' is no color.+instance Monoid (Color a) where+ mempty = Color Nothing++-- | A simple enumeration for eight values. Represents eight colors.+data Enum8+ = E0+ | E1+ | E2+ | E3+ | E4+ | E5+ | E6+ | E7+ deriving (Eq, Ord, Show, Bounded, Enum, Generic, Typeable)++enum8toWord8 :: Enum8 -> Word8+enum8toWord8 e = case e of+ E0 -> 0+ E1 -> 1+ E2 -> 2+ E3 -> 3+ E4 -> 4+ E5 -> 5+ E6 -> 6+ E7 -> 7++black :: Enum8+black = E0++red :: Enum8+red = E1++green :: Enum8+green = E2++yellow :: Enum8+yellow = E3++blue :: Enum8+blue = E4++magenta :: Enum8+magenta = E5++cyan :: Enum8+cyan = E6++white :: Enum8+white = E7++grey :: Word8+grey = 8++brightRed :: Word8+brightRed = 9++brightGreen :: Word8+brightGreen = 10++brightYellow :: Word8+brightYellow = 11++brightBlue :: Word8+brightBlue = 12++brightMagenta :: Word8+brightMagenta = 13++brightCyan :: Word8+brightCyan = 14++brightWhite :: Word8+brightWhite = 15++--+-- Styles+--++-- | Text formatting such as bold, italic, etc.+data Format = Format+ { _bold :: Bool+ , _faint :: Bool+ , _italic :: Bool+ , _underline :: Bool+ , _blink :: Bool+ , _inverse :: Bool+ , _invisible :: Bool+ , _strikeout :: Bool+ } deriving (Show, Eq, Ord, Generic, Typeable)++makeLenses ''Format++instance Semigroup Format where+ (Format x0 x1 x2 x3 x4 x5 x6 x7) <> (Format y0 y1 y2 y3 y4 y5 y6 y7)+ = Format (x0 || y0) (x1 || y1) (x2 || y2) (x3 || y3) (x4 || y4)+ (x5 || y5) (x6 || y6) (x7 || y7)++-- | For each field, the resulting field is True if either field is+-- True. For 'mempty', every field is False.+instance Monoid Format where+ mempty = Format False False False False False False False False++-- | The foreground and background color, and the 'Format'. This+-- represents all colors and formatting attributes for either an 8- or+-- 256-color terminal.+data Style a = Style+ { _fore :: Color a+ , _back :: Color a+ , _format :: Format+ } deriving (Show, Eq, Ord, Generic, Typeable, Functor, Foldable,+ Traversable)++makeLenses ''Style++instance Semigroup (Style a) where+ (Style x0 x1 x2) <> (Style y0 y1 y2)+ = Style (x0 <> y0) (x1 <> y1) (x2 <> y2)++-- | Uses the underlying 'Monoid' instances for 'Color' and 'Format'.+instance Monoid (Style a) where+ mempty = Style mempty mempty mempty++--+-- Scheme+--++-- | Holds the 'Style' for both 8- and 256-color terminals.+data Scheme = Scheme+ { _style8 :: Style Enum8+ , _style256 :: Style Word8+ } deriving (Eq, Ord, Show, Generic, Typeable)++makeLenses ''Scheme++instance Semigroup Scheme where+ (Scheme x0 x1) <> (Scheme y0 y1) = Scheme (x0 <> y0) (x1 <> y1)++instance Monoid Scheme where+ mempty = Scheme mempty mempty++--+-- Chunks+--++-- | A chunk is some textual data coupled with a description of what+-- color the text is, attributes like whether it is bold or+-- underlined, etc. The chunk knows what foreground and background+-- colors and what attributes to use for both an 8 color terminal and+-- a 256 color terminal.++data Chunk = Chunk+ { _scheme :: Scheme+ , _yarn :: Text+ } deriving (Eq, Show, Ord, Generic, Typeable)++-- | Uses the underlying 'Semigroup' instances for both the+-- underlying 'Scheme' and the underlying 'Text'.+instance Semigroup Chunk where+ (Chunk x0 x1) <> (Chunk y0 y1)+ = Chunk (x0 <> y0) (x1 <> y1)++-- | Creates a 'Chunk' with no formatting and with the given text.+instance IsString Chunk where+ fromString = chunk . X.pack++-- | Uses the underlying 'Monoid' instances for the 'Scheme' and for+-- the underlying 'Text'. Therefore 'mempty' will have no+-- formatting, no colors, and no text.+instance Monoid Chunk where+ mempty = Chunk mempty mempty++-- | Creates a 'Chunk' with no formatting and with the given text.+-- A 'Chunk' is also an instance of 'Data.String.IsString' so you+-- can create them with the @OverloadedStrings@ extension. Such a+-- 'Chunk' has the text of the string and no formatting.+chunk :: Text -> Chunk+chunk = Chunk mempty++makeLenses ''Chunk+++-- | Stores colors that may affect 8-color terminals, 256-color+-- terminals, both, or neither.+data Radiant = Radiant+ { _color8 :: Color Enum8+ , _color256 :: Color Word8+ } deriving (Eq, Ord, Show, Typeable, Generic)++instance Semigroup Radiant where+ (Radiant x0 x1) <> (Radiant y0 y1) = Radiant (x0 <> y0) (x1 <> y1)++-- | Uses the underlying 'Monoid' instance for the 'Color's. Thus the+-- last non-'Nothing' 'Color' is used. This can be useful to specify+-- one color for 8-color terminals and a different color for 256-color+-- terminals.+instance Monoid Radiant where+ mempty = Radiant mempty mempty++makeLenses ''Radiant+
− lib/System/Console/Rainbow.hs
@@ -1,145 +0,0 @@--- | Handles colors and special effects for text. Internally this--- module uses the Haskell terminfo library, which links against the--- UNIX library of the same name, so it should work with a wide--- variety of UNIX terminals.------ The building block of Rainbow is the 'Chunk'. Each 'Chunk' comes with--- a 'TextSpec', which specifies how the text should look on 8-color--- and on 256-color terminals. The 'Chunk' is a full specification; that--- is, although 'Chunk's are typically printed one after the other, the--- appearance of one 'Chunk' does not affect the appearance of the next--- 'Chunk'.------ You have full freedom to specify different attributes and colors--- for 8 and 256 color terminals; for instance, you can have text--- appear red on an 8-color terminal but blue on a 256-color terminal.------ A 'Chunk' is a 'Monoid', so you can combine them using the usual--- monoid functions, including '<>'. You can create a 'Chunk' with--- text using 'fromString', but this library is much more usable if--- you enable the OverloadedStrings GHC extension:------ > {-# LANGUAGE OverloadedStrings #-}------ and all future examples assume you have enabled OverloadedStrings.------ Here are some basic examples:------ > putChunkLn $ "Some blue text" <> f_blue--- > putChunkLn $ "Blue on red background" <> f_blue <> b_red--- > putChunkLn $ "Blue on red, foreground bold" <> f_blue <> b_red <> bold------ But what makes Rainbow a little more interesting is that you can--- also specify output for 256-color terminals. To use these examples,--- be sure your TERM environment variable is set to something that--- supports 256 colors (like @xterm-256color@) before you start GHCi:------ > putChunkLn $ "Blue on 8-color terminal, red on 256-color terminal"--- > <> c8_f_blue <> c256_f_red------ If 'mappend' multiple chunks that change the same property, the--- rightmost one \"wins\":------ > putChunkLn $ "This will be blue" <> f_red <> f_blue------ This property comes in handy if you want to specify a default color--- for 8- and 256-color terminals, then a more specific shade for a--- 256-color terminal:------ > putChunkLn $ "Pink" <> f_red <> c256_f_201------ However, if you use 'mappend' to add additional 'Chunk's that have--- text, the text will be appended:------ > putChunkLn $ f_green <> "You will see this text "--- > <> "and this text too, but it will all be blue"--- > <> f_blue------ Although one chunk can have different colors on 8- and 256-color--- terminals, it cannot have different colors on the same--- terminal. That is, if you want to print some text in one color and--- some text in another color, make two chunks.--module System.Console.Rainbow- (-- -- * Terminal definitions- Term(..)- , termFromEnv- , smartTermFromEnv-- -- * Chunks- , Chunk(..)- , fromText- , fromLazyText-- -- * Printing chunks- , putChunks- , hPutChunks-- -- ** Printing one chunk at a time-- -- | These functions make it easy to print one chunk at a time. Each- -- function initializes the terminal once for each chunk, unlike the- -- list-oriented functions, which only initialize the terminal- -- once. (Initialization does not clear the screen; rather, it is a- -- process that the terminfo library requires.) Thus there might be- -- a performance penalty for using these functions to print large- -- numbers of chunks. Or, there might not be--I have not benchmarked- -- them.- --- -- These functions use the default terminal, obtained using- -- 'termFromEnv'.- , putChunk- , putChunkLn- , hPutChunk- , hPutChunkLn-- -- * Effects for both 8 and 256 color terminals-- -- | These 'Chunk's affect both 8 and 256 color terminals:- --- -- > putChunkLn $ "bold on 8 and 256 color terminals" <> bold- --- -- There are also 'Chunk's to turn an effect off, such as- -- 'boldOff'. Ordinarily you will not need these because each chunk- -- starts with no effects, so you only need to turn on the effects- -- you want. However the @off@ 'Chunk's are here if you need them.-- , bold, boldOff- , underline, underlineOff- , flash, flashOff- , inverse, inverseOff-- -- * Effects for 8-color terminals only-- -- | These 'Chunk's affect 8-color terminals only.- --- -- > putChunkLn $ "Bold on 8 color terminal only" <> bold8-- , bold8, bold8off- , underline8, underline8off- , flash8, flash8off- , inverse8, inverse8off-- -- * Effects for 256-color terminals only-- -- | These 'Chunk's affect 256-color terminals only.- --- -- > putChunkLn $ "Underlined on 256-color terminal, "- -- > <> "bold on 8-color terminal"- -- > <> underlined256 <> bold8-- , bold256, bold256off- , underline256, underline256off- , flash256, flash256off- , inverse256, inverse256off-- -- * Color chunks- -- | All colors are within this module.- , module System.Console.Rainbow.ColorChunks-- ) where--import System.Console.Rainbow.Types-import System.Console.Rainbow.ColorChunks
− lib/System/Console/Rainbow/ColorChunks.hs
@@ -1,1880 +0,0 @@--- | Color chunks.------ Names in this module follow these connventions:------ * The prefix @f_@ indicates that a Chunk affects foreground--- colors. The prefix @b_@ indicates background colors.------ * The prefix @c8_@ indicates that a Chunk affects 8-color--- terminals only; @c256_@ indicates 256-color terminals only. If a--- Chunk has neither prefix, it affects both 8- and 256-color--- terminals.------ * Some colors have names. The color names assume a palette--- similar to the default one that xterm uses. Other colors simply--- have numbers. Ultimately the interpretation of either named or--- numbered colors is up to the user's terminal.-module System.Console.Rainbow.ColorChunks where--import System.Console.Rainbow.Types-import System.Console.Rainbow.Colors-import Data.Monoid---- * Colors for both 8 and 256 color terminals---- ** Foreground colors--f_default :: Chunk-f_default = c8_f_default <> c256_f_default--f_black :: Chunk-f_black = c8_f_black <> c256_f_black--f_red :: Chunk-f_red = c8_f_red <> c256_f_red--f_green :: Chunk-f_green = c8_f_green <> c256_f_green--f_yellow :: Chunk-f_yellow = c8_f_yellow <> c256_f_yellow--f_blue :: Chunk-f_blue = c8_f_blue <> c256_f_blue--f_magenta :: Chunk-f_magenta = c8_f_magenta <> c256_f_magenta--f_cyan :: Chunk-f_cyan = c8_f_cyan <> c256_f_cyan--f_white :: Chunk-f_white = c8_f_white <> c256_f_white---- ** Background colors--b_default :: Chunk-b_default = c8_b_default <> c256_b_default--b_black :: Chunk-b_black = c8_b_black <> c256_b_black--b_red :: Chunk-b_red = c8_b_red <> c256_b_red--b_green :: Chunk-b_green = c8_b_green <> c256_b_green--b_yellow :: Chunk-b_yellow = c8_b_yellow <> c256_b_yellow--b_blue :: Chunk-b_blue = c8_b_blue <> c256_b_blue--b_magenta :: Chunk-b_magenta = c8_b_magenta <> c256_b_magenta--b_cyan :: Chunk-b_cyan = c8_b_cyan <> c256_b_cyan--b_white :: Chunk-b_white = c8_b_white <> c256_b_white----- * Specific colors---- * 8 colors, foreground, named--c8_f_default :: Chunk-c8_f_default = fc8 c8_default--c8_f_black :: Chunk-c8_f_black = fc8 c8_black--c8_f_red :: Chunk-c8_f_red = fc8 c8_red--c8_f_green :: Chunk-c8_f_green = fc8 c8_green--c8_f_yellow :: Chunk-c8_f_yellow = fc8 c8_yellow--c8_f_blue :: Chunk-c8_f_blue = fc8 c8_blue--c8_f_magenta :: Chunk-c8_f_magenta = fc8 c8_magenta--c8_f_cyan :: Chunk-c8_f_cyan = fc8 c8_cyan--c8_f_white :: Chunk-c8_f_white = fc8 c8_white---- * 8 colors, background, named--c8_b_default :: Chunk-c8_b_default = bc8 c8_default--c8_b_black :: Chunk-c8_b_black = bc8 c8_black--c8_b_red :: Chunk-c8_b_red = bc8 c8_red--c8_b_green :: Chunk-c8_b_green = bc8 c8_green--c8_b_yellow :: Chunk-c8_b_yellow = bc8 c8_yellow--c8_b_blue :: Chunk-c8_b_blue = bc8 c8_blue--c8_b_magenta :: Chunk-c8_b_magenta = bc8 c8_magenta--c8_b_cyan :: Chunk-c8_b_cyan = bc8 c8_cyan--c8_b_white :: Chunk-c8_b_white = bc8 c8_white---- * 8 colors, foreground, numbered--c8_f_0 :: Chunk-c8_f_0 = fc8 c8_0--c8_f_1 :: Chunk-c8_f_1 = fc8 c8_1--c8_f_2 :: Chunk-c8_f_2 = fc8 c8_2--c8_f_3 :: Chunk-c8_f_3 = fc8 c8_3--c8_f_4 :: Chunk-c8_f_4 = fc8 c8_4--c8_f_5 :: Chunk-c8_f_5 = fc8 c8_5--c8_f_6 :: Chunk-c8_f_6 = fc8 c8_6--c8_f_7 :: Chunk-c8_f_7 = fc8 c8_7---- * 8 colors, background, numbered--c8_b_0 :: Chunk-c8_b_0 = bc8 c8_0--c8_b_1 :: Chunk-c8_b_1 = bc8 c8_1--c8_b_2 :: Chunk-c8_b_2 = bc8 c8_2--c8_b_3 :: Chunk-c8_b_3 = bc8 c8_3--c8_b_4 :: Chunk-c8_b_4 = bc8 c8_4--c8_b_5 :: Chunk-c8_b_5 = bc8 c8_5--c8_b_6 :: Chunk-c8_b_6 = bc8 c8_6--c8_b_7 :: Chunk-c8_b_7 = bc8 c8_7---- * 256 colors, foreground, named--c256_f_default :: Chunk-c256_f_default = fc256 c256_default--c256_f_black :: Chunk-c256_f_black = fc256 c256_black--c256_f_red :: Chunk-c256_f_red = fc256 c256_red--c256_f_green :: Chunk-c256_f_green = fc256 c256_green--c256_f_yellow :: Chunk-c256_f_yellow = fc256 c256_yellow--c256_f_blue :: Chunk-c256_f_blue = fc256 c256_blue--c256_f_magenta :: Chunk-c256_f_magenta = fc256 c256_magenta--c256_f_cyan :: Chunk-c256_f_cyan = fc256 c256_cyan--c256_f_white :: Chunk-c256_f_white = fc256 c256_white--c256_f_grey :: Chunk-c256_f_grey = fc256 c256_grey---- * 256 colors, background, named--c256_b_default :: Chunk-c256_b_default = bc256 c256_default--c256_b_black :: Chunk-c256_b_black = bc256 c256_black--c256_b_red :: Chunk-c256_b_red = bc256 c256_red--c256_b_green :: Chunk-c256_b_green = bc256 c256_green--c256_b_yellow :: Chunk-c256_b_yellow = bc256 c256_yellow--c256_b_blue :: Chunk-c256_b_blue = bc256 c256_blue--c256_b_magenta :: Chunk-c256_b_magenta = bc256 c256_magenta--c256_b_cyan :: Chunk-c256_b_cyan = bc256 c256_cyan--c256_b_white :: Chunk-c256_b_white = bc256 c256_white--c256_b_grey :: Chunk-c256_b_grey = bc256 c256_grey---- * 256 colors, foreground, bright, named--c256_f_red_bright :: Chunk-c256_f_red_bright = fc256 c256_red_bright--c256_f_green_bright :: Chunk-c256_f_green_bright = fc256 c256_green_bright--c256_f_yellow_bright :: Chunk-c256_f_yellow_bright = fc256 c256_yellow_bright--c256_f_blue_bright :: Chunk-c256_f_blue_bright = fc256 c256_blue_bright--c256_f_magenta_bright :: Chunk-c256_f_magenta_bright = fc256 c256_magenta_bright--c256_f_cyan_bright :: Chunk-c256_f_cyan_bright = fc256 c256_cyan_bright--c256_f_white_bright :: Chunk-c256_f_white_bright = fc256 c256_white_bright---- * 256 colors, background, bright, named--c256_b_red_bright :: Chunk-c256_b_red_bright = bc256 c256_red_bright--c256_b_green_bright :: Chunk-c256_b_green_bright = bc256 c256_green_bright--c256_b_yellow_bright :: Chunk-c256_b_yellow_bright = bc256 c256_yellow_bright--c256_b_blue_bright :: Chunk-c256_b_blue_bright = bc256 c256_blue_bright--c256_b_magenta_bright :: Chunk-c256_b_magenta_bright = bc256 c256_magenta_bright--c256_b_cyan_bright :: Chunk-c256_b_cyan_bright = bc256 c256_cyan_bright--c256_b_white_bright :: Chunk-c256_b_white_bright = bc256 c256_white_bright---- * 256 colors, foreground, numbered--c256_f_0 :: Chunk-c256_f_0 = fc256 c256_0--c256_f_1 :: Chunk-c256_f_1 = fc256 c256_1--c256_f_2 :: Chunk-c256_f_2 = fc256 c256_2--c256_f_3 :: Chunk-c256_f_3 = fc256 c256_3--c256_f_4 :: Chunk-c256_f_4 = fc256 c256_4--c256_f_5 :: Chunk-c256_f_5 = fc256 c256_5--c256_f_6 :: Chunk-c256_f_6 = fc256 c256_6--c256_f_7 :: Chunk-c256_f_7 = fc256 c256_7--c256_f_8 :: Chunk-c256_f_8 = fc256 c256_8--c256_f_9 :: Chunk-c256_f_9 = fc256 c256_9--c256_f_10 :: Chunk-c256_f_10 = fc256 c256_10--c256_f_11 :: Chunk-c256_f_11 = fc256 c256_11--c256_f_12 :: Chunk-c256_f_12 = fc256 c256_12--c256_f_13 :: Chunk-c256_f_13 = fc256 c256_13--c256_f_14 :: Chunk-c256_f_14 = fc256 c256_14--c256_f_15 :: Chunk-c256_f_15 = fc256 c256_15--c256_f_16 :: Chunk-c256_f_16 = fc256 c256_16--c256_f_17 :: Chunk-c256_f_17 = fc256 c256_17--c256_f_18 :: Chunk-c256_f_18 = fc256 c256_18--c256_f_19 :: Chunk-c256_f_19 = fc256 c256_19--c256_f_20 :: Chunk-c256_f_20 = fc256 c256_20--c256_f_21 :: Chunk-c256_f_21 = fc256 c256_21--c256_f_22 :: Chunk-c256_f_22 = fc256 c256_22--c256_f_23 :: Chunk-c256_f_23 = fc256 c256_23--c256_f_24 :: Chunk-c256_f_24 = fc256 c256_24--c256_f_25 :: Chunk-c256_f_25 = fc256 c256_25--c256_f_26 :: Chunk-c256_f_26 = fc256 c256_26--c256_f_27 :: Chunk-c256_f_27 = fc256 c256_27--c256_f_28 :: Chunk-c256_f_28 = fc256 c256_28--c256_f_29 :: Chunk-c256_f_29 = fc256 c256_29--c256_f_30 :: Chunk-c256_f_30 = fc256 c256_30--c256_f_31 :: Chunk-c256_f_31 = fc256 c256_31--c256_f_32 :: Chunk-c256_f_32 = fc256 c256_32--c256_f_33 :: Chunk-c256_f_33 = fc256 c256_33--c256_f_34 :: Chunk-c256_f_34 = fc256 c256_34--c256_f_35 :: Chunk-c256_f_35 = fc256 c256_35--c256_f_36 :: Chunk-c256_f_36 = fc256 c256_36--c256_f_37 :: Chunk-c256_f_37 = fc256 c256_37--c256_f_38 :: Chunk-c256_f_38 = fc256 c256_38--c256_f_39 :: Chunk-c256_f_39 = fc256 c256_39--c256_f_40 :: Chunk-c256_f_40 = fc256 c256_40--c256_f_41 :: Chunk-c256_f_41 = fc256 c256_41--c256_f_42 :: Chunk-c256_f_42 = fc256 c256_42--c256_f_43 :: Chunk-c256_f_43 = fc256 c256_43--c256_f_44 :: Chunk-c256_f_44 = fc256 c256_44--c256_f_45 :: Chunk-c256_f_45 = fc256 c256_45--c256_f_46 :: Chunk-c256_f_46 = fc256 c256_46--c256_f_47 :: Chunk-c256_f_47 = fc256 c256_47--c256_f_48 :: Chunk-c256_f_48 = fc256 c256_48--c256_f_49 :: Chunk-c256_f_49 = fc256 c256_49--c256_f_50 :: Chunk-c256_f_50 = fc256 c256_50--c256_f_51 :: Chunk-c256_f_51 = fc256 c256_51--c256_f_52 :: Chunk-c256_f_52 = fc256 c256_52--c256_f_53 :: Chunk-c256_f_53 = fc256 c256_53--c256_f_54 :: Chunk-c256_f_54 = fc256 c256_54--c256_f_55 :: Chunk-c256_f_55 = fc256 c256_55--c256_f_56 :: Chunk-c256_f_56 = fc256 c256_56--c256_f_57 :: Chunk-c256_f_57 = fc256 c256_57--c256_f_58 :: Chunk-c256_f_58 = fc256 c256_58--c256_f_59 :: Chunk-c256_f_59 = fc256 c256_59--c256_f_60 :: Chunk-c256_f_60 = fc256 c256_60--c256_f_61 :: Chunk-c256_f_61 = fc256 c256_61--c256_f_62 :: Chunk-c256_f_62 = fc256 c256_62--c256_f_63 :: Chunk-c256_f_63 = fc256 c256_63--c256_f_64 :: Chunk-c256_f_64 = fc256 c256_64--c256_f_65 :: Chunk-c256_f_65 = fc256 c256_65--c256_f_66 :: Chunk-c256_f_66 = fc256 c256_66--c256_f_67 :: Chunk-c256_f_67 = fc256 c256_67--c256_f_68 :: Chunk-c256_f_68 = fc256 c256_68--c256_f_69 :: Chunk-c256_f_69 = fc256 c256_69--c256_f_70 :: Chunk-c256_f_70 = fc256 c256_70--c256_f_71 :: Chunk-c256_f_71 = fc256 c256_71--c256_f_72 :: Chunk-c256_f_72 = fc256 c256_72--c256_f_73 :: Chunk-c256_f_73 = fc256 c256_73--c256_f_74 :: Chunk-c256_f_74 = fc256 c256_74--c256_f_75 :: Chunk-c256_f_75 = fc256 c256_75--c256_f_76 :: Chunk-c256_f_76 = fc256 c256_76--c256_f_77 :: Chunk-c256_f_77 = fc256 c256_77--c256_f_78 :: Chunk-c256_f_78 = fc256 c256_78--c256_f_79 :: Chunk-c256_f_79 = fc256 c256_79--c256_f_80 :: Chunk-c256_f_80 = fc256 c256_80--c256_f_81 :: Chunk-c256_f_81 = fc256 c256_81--c256_f_82 :: Chunk-c256_f_82 = fc256 c256_82--c256_f_83 :: Chunk-c256_f_83 = fc256 c256_83--c256_f_84 :: Chunk-c256_f_84 = fc256 c256_84--c256_f_85 :: Chunk-c256_f_85 = fc256 c256_85--c256_f_86 :: Chunk-c256_f_86 = fc256 c256_86--c256_f_87 :: Chunk-c256_f_87 = fc256 c256_87--c256_f_88 :: Chunk-c256_f_88 = fc256 c256_88--c256_f_89 :: Chunk-c256_f_89 = fc256 c256_89--c256_f_90 :: Chunk-c256_f_90 = fc256 c256_90--c256_f_91 :: Chunk-c256_f_91 = fc256 c256_91--c256_f_92 :: Chunk-c256_f_92 = fc256 c256_92--c256_f_93 :: Chunk-c256_f_93 = fc256 c256_93--c256_f_94 :: Chunk-c256_f_94 = fc256 c256_94--c256_f_95 :: Chunk-c256_f_95 = fc256 c256_95--c256_f_96 :: Chunk-c256_f_96 = fc256 c256_96--c256_f_97 :: Chunk-c256_f_97 = fc256 c256_97--c256_f_98 :: Chunk-c256_f_98 = fc256 c256_98--c256_f_99 :: Chunk-c256_f_99 = fc256 c256_99--c256_f_100 :: Chunk-c256_f_100 = fc256 c256_100--c256_f_101 :: Chunk-c256_f_101 = fc256 c256_101--c256_f_102 :: Chunk-c256_f_102 = fc256 c256_102--c256_f_103 :: Chunk-c256_f_103 = fc256 c256_103--c256_f_104 :: Chunk-c256_f_104 = fc256 c256_104--c256_f_105 :: Chunk-c256_f_105 = fc256 c256_105--c256_f_106 :: Chunk-c256_f_106 = fc256 c256_106--c256_f_107 :: Chunk-c256_f_107 = fc256 c256_107--c256_f_108 :: Chunk-c256_f_108 = fc256 c256_108--c256_f_109 :: Chunk-c256_f_109 = fc256 c256_109--c256_f_110 :: Chunk-c256_f_110 = fc256 c256_110--c256_f_111 :: Chunk-c256_f_111 = fc256 c256_111--c256_f_112 :: Chunk-c256_f_112 = fc256 c256_112--c256_f_113 :: Chunk-c256_f_113 = fc256 c256_113--c256_f_114 :: Chunk-c256_f_114 = fc256 c256_114--c256_f_115 :: Chunk-c256_f_115 = fc256 c256_115--c256_f_116 :: Chunk-c256_f_116 = fc256 c256_116--c256_f_117 :: Chunk-c256_f_117 = fc256 c256_117--c256_f_118 :: Chunk-c256_f_118 = fc256 c256_118--c256_f_119 :: Chunk-c256_f_119 = fc256 c256_119--c256_f_120 :: Chunk-c256_f_120 = fc256 c256_120--c256_f_121 :: Chunk-c256_f_121 = fc256 c256_121--c256_f_122 :: Chunk-c256_f_122 = fc256 c256_122--c256_f_123 :: Chunk-c256_f_123 = fc256 c256_123--c256_f_124 :: Chunk-c256_f_124 = fc256 c256_124--c256_f_125 :: Chunk-c256_f_125 = fc256 c256_125--c256_f_126 :: Chunk-c256_f_126 = fc256 c256_126--c256_f_127 :: Chunk-c256_f_127 = fc256 c256_127--c256_f_128 :: Chunk-c256_f_128 = fc256 c256_128--c256_f_129 :: Chunk-c256_f_129 = fc256 c256_129--c256_f_130 :: Chunk-c256_f_130 = fc256 c256_130--c256_f_131 :: Chunk-c256_f_131 = fc256 c256_131--c256_f_132 :: Chunk-c256_f_132 = fc256 c256_132--c256_f_133 :: Chunk-c256_f_133 = fc256 c256_133--c256_f_134 :: Chunk-c256_f_134 = fc256 c256_134--c256_f_135 :: Chunk-c256_f_135 = fc256 c256_135--c256_f_136 :: Chunk-c256_f_136 = fc256 c256_136--c256_f_137 :: Chunk-c256_f_137 = fc256 c256_137--c256_f_138 :: Chunk-c256_f_138 = fc256 c256_138--c256_f_139 :: Chunk-c256_f_139 = fc256 c256_139--c256_f_140 :: Chunk-c256_f_140 = fc256 c256_140--c256_f_141 :: Chunk-c256_f_141 = fc256 c256_141--c256_f_142 :: Chunk-c256_f_142 = fc256 c256_142--c256_f_143 :: Chunk-c256_f_143 = fc256 c256_143--c256_f_144 :: Chunk-c256_f_144 = fc256 c256_144--c256_f_145 :: Chunk-c256_f_145 = fc256 c256_145--c256_f_146 :: Chunk-c256_f_146 = fc256 c256_146--c256_f_147 :: Chunk-c256_f_147 = fc256 c256_147--c256_f_148 :: Chunk-c256_f_148 = fc256 c256_148--c256_f_149 :: Chunk-c256_f_149 = fc256 c256_149--c256_f_150 :: Chunk-c256_f_150 = fc256 c256_150--c256_f_151 :: Chunk-c256_f_151 = fc256 c256_151--c256_f_152 :: Chunk-c256_f_152 = fc256 c256_152--c256_f_153 :: Chunk-c256_f_153 = fc256 c256_153--c256_f_154 :: Chunk-c256_f_154 = fc256 c256_154--c256_f_155 :: Chunk-c256_f_155 = fc256 c256_155--c256_f_156 :: Chunk-c256_f_156 = fc256 c256_156--c256_f_157 :: Chunk-c256_f_157 = fc256 c256_157--c256_f_158 :: Chunk-c256_f_158 = fc256 c256_158--c256_f_159 :: Chunk-c256_f_159 = fc256 c256_159--c256_f_160 :: Chunk-c256_f_160 = fc256 c256_160--c256_f_161 :: Chunk-c256_f_161 = fc256 c256_161--c256_f_162 :: Chunk-c256_f_162 = fc256 c256_162--c256_f_163 :: Chunk-c256_f_163 = fc256 c256_163--c256_f_164 :: Chunk-c256_f_164 = fc256 c256_164--c256_f_165 :: Chunk-c256_f_165 = fc256 c256_165--c256_f_166 :: Chunk-c256_f_166 = fc256 c256_166--c256_f_167 :: Chunk-c256_f_167 = fc256 c256_167--c256_f_168 :: Chunk-c256_f_168 = fc256 c256_168--c256_f_169 :: Chunk-c256_f_169 = fc256 c256_169--c256_f_170 :: Chunk-c256_f_170 = fc256 c256_170--c256_f_171 :: Chunk-c256_f_171 = fc256 c256_171--c256_f_172 :: Chunk-c256_f_172 = fc256 c256_172--c256_f_173 :: Chunk-c256_f_173 = fc256 c256_173--c256_f_174 :: Chunk-c256_f_174 = fc256 c256_174--c256_f_175 :: Chunk-c256_f_175 = fc256 c256_175--c256_f_176 :: Chunk-c256_f_176 = fc256 c256_176--c256_f_177 :: Chunk-c256_f_177 = fc256 c256_177--c256_f_178 :: Chunk-c256_f_178 = fc256 c256_178--c256_f_179 :: Chunk-c256_f_179 = fc256 c256_179--c256_f_180 :: Chunk-c256_f_180 = fc256 c256_180--c256_f_181 :: Chunk-c256_f_181 = fc256 c256_181--c256_f_182 :: Chunk-c256_f_182 = fc256 c256_182--c256_f_183 :: Chunk-c256_f_183 = fc256 c256_183--c256_f_184 :: Chunk-c256_f_184 = fc256 c256_184--c256_f_185 :: Chunk-c256_f_185 = fc256 c256_185--c256_f_186 :: Chunk-c256_f_186 = fc256 c256_186--c256_f_187 :: Chunk-c256_f_187 = fc256 c256_187--c256_f_188 :: Chunk-c256_f_188 = fc256 c256_188--c256_f_189 :: Chunk-c256_f_189 = fc256 c256_189--c256_f_190 :: Chunk-c256_f_190 = fc256 c256_190--c256_f_191 :: Chunk-c256_f_191 = fc256 c256_191--c256_f_192 :: Chunk-c256_f_192 = fc256 c256_192--c256_f_193 :: Chunk-c256_f_193 = fc256 c256_193--c256_f_194 :: Chunk-c256_f_194 = fc256 c256_194--c256_f_195 :: Chunk-c256_f_195 = fc256 c256_195--c256_f_196 :: Chunk-c256_f_196 = fc256 c256_196--c256_f_197 :: Chunk-c256_f_197 = fc256 c256_197--c256_f_198 :: Chunk-c256_f_198 = fc256 c256_198--c256_f_199 :: Chunk-c256_f_199 = fc256 c256_199--c256_f_200 :: Chunk-c256_f_200 = fc256 c256_200--c256_f_201 :: Chunk-c256_f_201 = fc256 c256_201--c256_f_202 :: Chunk-c256_f_202 = fc256 c256_202--c256_f_203 :: Chunk-c256_f_203 = fc256 c256_203--c256_f_204 :: Chunk-c256_f_204 = fc256 c256_204--c256_f_205 :: Chunk-c256_f_205 = fc256 c256_205--c256_f_206 :: Chunk-c256_f_206 = fc256 c256_206--c256_f_207 :: Chunk-c256_f_207 = fc256 c256_207--c256_f_208 :: Chunk-c256_f_208 = fc256 c256_208--c256_f_209 :: Chunk-c256_f_209 = fc256 c256_209--c256_f_210 :: Chunk-c256_f_210 = fc256 c256_210--c256_f_211 :: Chunk-c256_f_211 = fc256 c256_211--c256_f_212 :: Chunk-c256_f_212 = fc256 c256_212--c256_f_213 :: Chunk-c256_f_213 = fc256 c256_213--c256_f_214 :: Chunk-c256_f_214 = fc256 c256_214--c256_f_215 :: Chunk-c256_f_215 = fc256 c256_215--c256_f_216 :: Chunk-c256_f_216 = fc256 c256_216--c256_f_217 :: Chunk-c256_f_217 = fc256 c256_217--c256_f_218 :: Chunk-c256_f_218 = fc256 c256_218--c256_f_219 :: Chunk-c256_f_219 = fc256 c256_219--c256_f_220 :: Chunk-c256_f_220 = fc256 c256_220--c256_f_221 :: Chunk-c256_f_221 = fc256 c256_221--c256_f_222 :: Chunk-c256_f_222 = fc256 c256_222--c256_f_223 :: Chunk-c256_f_223 = fc256 c256_223--c256_f_224 :: Chunk-c256_f_224 = fc256 c256_224--c256_f_225 :: Chunk-c256_f_225 = fc256 c256_225--c256_f_226 :: Chunk-c256_f_226 = fc256 c256_226--c256_f_227 :: Chunk-c256_f_227 = fc256 c256_227--c256_f_228 :: Chunk-c256_f_228 = fc256 c256_228--c256_f_229 :: Chunk-c256_f_229 = fc256 c256_229--c256_f_230 :: Chunk-c256_f_230 = fc256 c256_230--c256_f_231 :: Chunk-c256_f_231 = fc256 c256_231--c256_f_232 :: Chunk-c256_f_232 = fc256 c256_232--c256_f_233 :: Chunk-c256_f_233 = fc256 c256_233--c256_f_234 :: Chunk-c256_f_234 = fc256 c256_234--c256_f_235 :: Chunk-c256_f_235 = fc256 c256_235--c256_f_236 :: Chunk-c256_f_236 = fc256 c256_236--c256_f_237 :: Chunk-c256_f_237 = fc256 c256_237--c256_f_238 :: Chunk-c256_f_238 = fc256 c256_238--c256_f_239 :: Chunk-c256_f_239 = fc256 c256_239--c256_f_240 :: Chunk-c256_f_240 = fc256 c256_240--c256_f_241 :: Chunk-c256_f_241 = fc256 c256_241--c256_f_242 :: Chunk-c256_f_242 = fc256 c256_242--c256_f_243 :: Chunk-c256_f_243 = fc256 c256_243--c256_f_244 :: Chunk-c256_f_244 = fc256 c256_244--c256_f_245 :: Chunk-c256_f_245 = fc256 c256_245--c256_f_246 :: Chunk-c256_f_246 = fc256 c256_246--c256_f_247 :: Chunk-c256_f_247 = fc256 c256_247--c256_f_248 :: Chunk-c256_f_248 = fc256 c256_248--c256_f_249 :: Chunk-c256_f_249 = fc256 c256_249--c256_f_250 :: Chunk-c256_f_250 = fc256 c256_250--c256_f_251 :: Chunk-c256_f_251 = fc256 c256_251--c256_f_252 :: Chunk-c256_f_252 = fc256 c256_252--c256_f_253 :: Chunk-c256_f_253 = fc256 c256_253--c256_f_254 :: Chunk-c256_f_254 = fc256 c256_254--c256_f_255 :: Chunk-c256_f_255 = fc256 c256_255---- * 256 colors, background, numbered--c256_b_0 :: Chunk-c256_b_0 = bc256 c256_0--c256_b_1 :: Chunk-c256_b_1 = bc256 c256_1--c256_b_2 :: Chunk-c256_b_2 = bc256 c256_2--c256_b_3 :: Chunk-c256_b_3 = bc256 c256_3--c256_b_4 :: Chunk-c256_b_4 = bc256 c256_4--c256_b_5 :: Chunk-c256_b_5 = bc256 c256_5--c256_b_6 :: Chunk-c256_b_6 = bc256 c256_6--c256_b_7 :: Chunk-c256_b_7 = bc256 c256_7--c256_b_8 :: Chunk-c256_b_8 = bc256 c256_8--c256_b_9 :: Chunk-c256_b_9 = bc256 c256_9--c256_b_10 :: Chunk-c256_b_10 = bc256 c256_10--c256_b_11 :: Chunk-c256_b_11 = bc256 c256_11--c256_b_12 :: Chunk-c256_b_12 = bc256 c256_12--c256_b_13 :: Chunk-c256_b_13 = bc256 c256_13--c256_b_14 :: Chunk-c256_b_14 = bc256 c256_14--c256_b_15 :: Chunk-c256_b_15 = bc256 c256_15--c256_b_16 :: Chunk-c256_b_16 = bc256 c256_16--c256_b_17 :: Chunk-c256_b_17 = bc256 c256_17--c256_b_18 :: Chunk-c256_b_18 = bc256 c256_18--c256_b_19 :: Chunk-c256_b_19 = bc256 c256_19--c256_b_20 :: Chunk-c256_b_20 = bc256 c256_20--c256_b_21 :: Chunk-c256_b_21 = bc256 c256_21--c256_b_22 :: Chunk-c256_b_22 = bc256 c256_22--c256_b_23 :: Chunk-c256_b_23 = bc256 c256_23--c256_b_24 :: Chunk-c256_b_24 = bc256 c256_24--c256_b_25 :: Chunk-c256_b_25 = bc256 c256_25--c256_b_26 :: Chunk-c256_b_26 = bc256 c256_26--c256_b_27 :: Chunk-c256_b_27 = bc256 c256_27--c256_b_28 :: Chunk-c256_b_28 = bc256 c256_28--c256_b_29 :: Chunk-c256_b_29 = bc256 c256_29--c256_b_30 :: Chunk-c256_b_30 = bc256 c256_30--c256_b_31 :: Chunk-c256_b_31 = bc256 c256_31--c256_b_32 :: Chunk-c256_b_32 = bc256 c256_32--c256_b_33 :: Chunk-c256_b_33 = bc256 c256_33--c256_b_34 :: Chunk-c256_b_34 = bc256 c256_34--c256_b_35 :: Chunk-c256_b_35 = bc256 c256_35--c256_b_36 :: Chunk-c256_b_36 = bc256 c256_36--c256_b_37 :: Chunk-c256_b_37 = bc256 c256_37--c256_b_38 :: Chunk-c256_b_38 = bc256 c256_38--c256_b_39 :: Chunk-c256_b_39 = bc256 c256_39--c256_b_40 :: Chunk-c256_b_40 = bc256 c256_40--c256_b_41 :: Chunk-c256_b_41 = bc256 c256_41--c256_b_42 :: Chunk-c256_b_42 = bc256 c256_42--c256_b_43 :: Chunk-c256_b_43 = bc256 c256_43--c256_b_44 :: Chunk-c256_b_44 = bc256 c256_44--c256_b_45 :: Chunk-c256_b_45 = bc256 c256_45--c256_b_46 :: Chunk-c256_b_46 = bc256 c256_46--c256_b_47 :: Chunk-c256_b_47 = bc256 c256_47--c256_b_48 :: Chunk-c256_b_48 = bc256 c256_48--c256_b_49 :: Chunk-c256_b_49 = bc256 c256_49--c256_b_50 :: Chunk-c256_b_50 = bc256 c256_50--c256_b_51 :: Chunk-c256_b_51 = bc256 c256_51--c256_b_52 :: Chunk-c256_b_52 = bc256 c256_52--c256_b_53 :: Chunk-c256_b_53 = bc256 c256_53--c256_b_54 :: Chunk-c256_b_54 = bc256 c256_54--c256_b_55 :: Chunk-c256_b_55 = bc256 c256_55--c256_b_56 :: Chunk-c256_b_56 = bc256 c256_56--c256_b_57 :: Chunk-c256_b_57 = bc256 c256_57--c256_b_58 :: Chunk-c256_b_58 = bc256 c256_58--c256_b_59 :: Chunk-c256_b_59 = bc256 c256_59--c256_b_60 :: Chunk-c256_b_60 = bc256 c256_60--c256_b_61 :: Chunk-c256_b_61 = bc256 c256_61--c256_b_62 :: Chunk-c256_b_62 = bc256 c256_62--c256_b_63 :: Chunk-c256_b_63 = bc256 c256_63--c256_b_64 :: Chunk-c256_b_64 = bc256 c256_64--c256_b_65 :: Chunk-c256_b_65 = bc256 c256_65--c256_b_66 :: Chunk-c256_b_66 = bc256 c256_66--c256_b_67 :: Chunk-c256_b_67 = bc256 c256_67--c256_b_68 :: Chunk-c256_b_68 = bc256 c256_68--c256_b_69 :: Chunk-c256_b_69 = bc256 c256_69--c256_b_70 :: Chunk-c256_b_70 = bc256 c256_70--c256_b_71 :: Chunk-c256_b_71 = bc256 c256_71--c256_b_72 :: Chunk-c256_b_72 = bc256 c256_72--c256_b_73 :: Chunk-c256_b_73 = bc256 c256_73--c256_b_74 :: Chunk-c256_b_74 = bc256 c256_74--c256_b_75 :: Chunk-c256_b_75 = bc256 c256_75--c256_b_76 :: Chunk-c256_b_76 = bc256 c256_76--c256_b_77 :: Chunk-c256_b_77 = bc256 c256_77--c256_b_78 :: Chunk-c256_b_78 = bc256 c256_78--c256_b_79 :: Chunk-c256_b_79 = bc256 c256_79--c256_b_80 :: Chunk-c256_b_80 = bc256 c256_80--c256_b_81 :: Chunk-c256_b_81 = bc256 c256_81--c256_b_82 :: Chunk-c256_b_82 = bc256 c256_82--c256_b_83 :: Chunk-c256_b_83 = bc256 c256_83--c256_b_84 :: Chunk-c256_b_84 = bc256 c256_84--c256_b_85 :: Chunk-c256_b_85 = bc256 c256_85--c256_b_86 :: Chunk-c256_b_86 = bc256 c256_86--c256_b_87 :: Chunk-c256_b_87 = bc256 c256_87--c256_b_88 :: Chunk-c256_b_88 = bc256 c256_88--c256_b_89 :: Chunk-c256_b_89 = bc256 c256_89--c256_b_90 :: Chunk-c256_b_90 = bc256 c256_90--c256_b_91 :: Chunk-c256_b_91 = bc256 c256_91--c256_b_92 :: Chunk-c256_b_92 = bc256 c256_92--c256_b_93 :: Chunk-c256_b_93 = bc256 c256_93--c256_b_94 :: Chunk-c256_b_94 = bc256 c256_94--c256_b_95 :: Chunk-c256_b_95 = bc256 c256_95--c256_b_96 :: Chunk-c256_b_96 = bc256 c256_96--c256_b_97 :: Chunk-c256_b_97 = bc256 c256_97--c256_b_98 :: Chunk-c256_b_98 = bc256 c256_98--c256_b_99 :: Chunk-c256_b_99 = bc256 c256_99--c256_b_100 :: Chunk-c256_b_100 = bc256 c256_100--c256_b_101 :: Chunk-c256_b_101 = bc256 c256_101--c256_b_102 :: Chunk-c256_b_102 = bc256 c256_102--c256_b_103 :: Chunk-c256_b_103 = bc256 c256_103--c256_b_104 :: Chunk-c256_b_104 = bc256 c256_104--c256_b_105 :: Chunk-c256_b_105 = bc256 c256_105--c256_b_106 :: Chunk-c256_b_106 = bc256 c256_106--c256_b_107 :: Chunk-c256_b_107 = bc256 c256_107--c256_b_108 :: Chunk-c256_b_108 = bc256 c256_108--c256_b_109 :: Chunk-c256_b_109 = bc256 c256_109--c256_b_110 :: Chunk-c256_b_110 = bc256 c256_110--c256_b_111 :: Chunk-c256_b_111 = bc256 c256_111--c256_b_112 :: Chunk-c256_b_112 = bc256 c256_112--c256_b_113 :: Chunk-c256_b_113 = bc256 c256_113--c256_b_114 :: Chunk-c256_b_114 = bc256 c256_114--c256_b_115 :: Chunk-c256_b_115 = bc256 c256_115--c256_b_116 :: Chunk-c256_b_116 = bc256 c256_116--c256_b_117 :: Chunk-c256_b_117 = bc256 c256_117--c256_b_118 :: Chunk-c256_b_118 = bc256 c256_118--c256_b_119 :: Chunk-c256_b_119 = bc256 c256_119--c256_b_120 :: Chunk-c256_b_120 = bc256 c256_120--c256_b_121 :: Chunk-c256_b_121 = bc256 c256_121--c256_b_122 :: Chunk-c256_b_122 = bc256 c256_122--c256_b_123 :: Chunk-c256_b_123 = bc256 c256_123--c256_b_124 :: Chunk-c256_b_124 = bc256 c256_124--c256_b_125 :: Chunk-c256_b_125 = bc256 c256_125--c256_b_126 :: Chunk-c256_b_126 = bc256 c256_126--c256_b_127 :: Chunk-c256_b_127 = bc256 c256_127--c256_b_128 :: Chunk-c256_b_128 = bc256 c256_128--c256_b_129 :: Chunk-c256_b_129 = bc256 c256_129--c256_b_130 :: Chunk-c256_b_130 = bc256 c256_130--c256_b_131 :: Chunk-c256_b_131 = bc256 c256_131--c256_b_132 :: Chunk-c256_b_132 = bc256 c256_132--c256_b_133 :: Chunk-c256_b_133 = bc256 c256_133--c256_b_134 :: Chunk-c256_b_134 = bc256 c256_134--c256_b_135 :: Chunk-c256_b_135 = bc256 c256_135--c256_b_136 :: Chunk-c256_b_136 = bc256 c256_136--c256_b_137 :: Chunk-c256_b_137 = bc256 c256_137--c256_b_138 :: Chunk-c256_b_138 = bc256 c256_138--c256_b_139 :: Chunk-c256_b_139 = bc256 c256_139--c256_b_140 :: Chunk-c256_b_140 = bc256 c256_140--c256_b_141 :: Chunk-c256_b_141 = bc256 c256_141--c256_b_142 :: Chunk-c256_b_142 = bc256 c256_142--c256_b_143 :: Chunk-c256_b_143 = bc256 c256_143--c256_b_144 :: Chunk-c256_b_144 = bc256 c256_144--c256_b_145 :: Chunk-c256_b_145 = bc256 c256_145--c256_b_146 :: Chunk-c256_b_146 = bc256 c256_146--c256_b_147 :: Chunk-c256_b_147 = bc256 c256_147--c256_b_148 :: Chunk-c256_b_148 = bc256 c256_148--c256_b_149 :: Chunk-c256_b_149 = bc256 c256_149--c256_b_150 :: Chunk-c256_b_150 = bc256 c256_150--c256_b_151 :: Chunk-c256_b_151 = bc256 c256_151--c256_b_152 :: Chunk-c256_b_152 = bc256 c256_152--c256_b_153 :: Chunk-c256_b_153 = bc256 c256_153--c256_b_154 :: Chunk-c256_b_154 = bc256 c256_154--c256_b_155 :: Chunk-c256_b_155 = bc256 c256_155--c256_b_156 :: Chunk-c256_b_156 = bc256 c256_156--c256_b_157 :: Chunk-c256_b_157 = bc256 c256_157--c256_b_158 :: Chunk-c256_b_158 = bc256 c256_158--c256_b_159 :: Chunk-c256_b_159 = bc256 c256_159--c256_b_160 :: Chunk-c256_b_160 = bc256 c256_160--c256_b_161 :: Chunk-c256_b_161 = bc256 c256_161--c256_b_162 :: Chunk-c256_b_162 = bc256 c256_162--c256_b_163 :: Chunk-c256_b_163 = bc256 c256_163--c256_b_164 :: Chunk-c256_b_164 = bc256 c256_164--c256_b_165 :: Chunk-c256_b_165 = bc256 c256_165--c256_b_166 :: Chunk-c256_b_166 = bc256 c256_166--c256_b_167 :: Chunk-c256_b_167 = bc256 c256_167--c256_b_168 :: Chunk-c256_b_168 = bc256 c256_168--c256_b_169 :: Chunk-c256_b_169 = bc256 c256_169--c256_b_170 :: Chunk-c256_b_170 = bc256 c256_170--c256_b_171 :: Chunk-c256_b_171 = bc256 c256_171--c256_b_172 :: Chunk-c256_b_172 = bc256 c256_172--c256_b_173 :: Chunk-c256_b_173 = bc256 c256_173--c256_b_174 :: Chunk-c256_b_174 = bc256 c256_174--c256_b_175 :: Chunk-c256_b_175 = bc256 c256_175--c256_b_176 :: Chunk-c256_b_176 = bc256 c256_176--c256_b_177 :: Chunk-c256_b_177 = bc256 c256_177--c256_b_178 :: Chunk-c256_b_178 = bc256 c256_178--c256_b_179 :: Chunk-c256_b_179 = bc256 c256_179--c256_b_180 :: Chunk-c256_b_180 = bc256 c256_180--c256_b_181 :: Chunk-c256_b_181 = bc256 c256_181--c256_b_182 :: Chunk-c256_b_182 = bc256 c256_182--c256_b_183 :: Chunk-c256_b_183 = bc256 c256_183--c256_b_184 :: Chunk-c256_b_184 = bc256 c256_184--c256_b_185 :: Chunk-c256_b_185 = bc256 c256_185--c256_b_186 :: Chunk-c256_b_186 = bc256 c256_186--c256_b_187 :: Chunk-c256_b_187 = bc256 c256_187--c256_b_188 :: Chunk-c256_b_188 = bc256 c256_188--c256_b_189 :: Chunk-c256_b_189 = bc256 c256_189--c256_b_190 :: Chunk-c256_b_190 = bc256 c256_190--c256_b_191 :: Chunk-c256_b_191 = bc256 c256_191--c256_b_192 :: Chunk-c256_b_192 = bc256 c256_192--c256_b_193 :: Chunk-c256_b_193 = bc256 c256_193--c256_b_194 :: Chunk-c256_b_194 = bc256 c256_194--c256_b_195 :: Chunk-c256_b_195 = bc256 c256_195--c256_b_196 :: Chunk-c256_b_196 = bc256 c256_196--c256_b_197 :: Chunk-c256_b_197 = bc256 c256_197--c256_b_198 :: Chunk-c256_b_198 = bc256 c256_198--c256_b_199 :: Chunk-c256_b_199 = bc256 c256_199--c256_b_200 :: Chunk-c256_b_200 = bc256 c256_200--c256_b_201 :: Chunk-c256_b_201 = bc256 c256_201--c256_b_202 :: Chunk-c256_b_202 = bc256 c256_202--c256_b_203 :: Chunk-c256_b_203 = bc256 c256_203--c256_b_204 :: Chunk-c256_b_204 = bc256 c256_204--c256_b_205 :: Chunk-c256_b_205 = bc256 c256_205--c256_b_206 :: Chunk-c256_b_206 = bc256 c256_206--c256_b_207 :: Chunk-c256_b_207 = bc256 c256_207--c256_b_208 :: Chunk-c256_b_208 = bc256 c256_208--c256_b_209 :: Chunk-c256_b_209 = bc256 c256_209--c256_b_210 :: Chunk-c256_b_210 = bc256 c256_210--c256_b_211 :: Chunk-c256_b_211 = bc256 c256_211--c256_b_212 :: Chunk-c256_b_212 = bc256 c256_212--c256_b_213 :: Chunk-c256_b_213 = bc256 c256_213--c256_b_214 :: Chunk-c256_b_214 = bc256 c256_214--c256_b_215 :: Chunk-c256_b_215 = bc256 c256_215--c256_b_216 :: Chunk-c256_b_216 = bc256 c256_216--c256_b_217 :: Chunk-c256_b_217 = bc256 c256_217--c256_b_218 :: Chunk-c256_b_218 = bc256 c256_218--c256_b_219 :: Chunk-c256_b_219 = bc256 c256_219--c256_b_220 :: Chunk-c256_b_220 = bc256 c256_220--c256_b_221 :: Chunk-c256_b_221 = bc256 c256_221--c256_b_222 :: Chunk-c256_b_222 = bc256 c256_222--c256_b_223 :: Chunk-c256_b_223 = bc256 c256_223--c256_b_224 :: Chunk-c256_b_224 = bc256 c256_224--c256_b_225 :: Chunk-c256_b_225 = bc256 c256_225--c256_b_226 :: Chunk-c256_b_226 = bc256 c256_226--c256_b_227 :: Chunk-c256_b_227 = bc256 c256_227--c256_b_228 :: Chunk-c256_b_228 = bc256 c256_228--c256_b_229 :: Chunk-c256_b_229 = bc256 c256_229--c256_b_230 :: Chunk-c256_b_230 = bc256 c256_230--c256_b_231 :: Chunk-c256_b_231 = bc256 c256_231--c256_b_232 :: Chunk-c256_b_232 = bc256 c256_232--c256_b_233 :: Chunk-c256_b_233 = bc256 c256_233--c256_b_234 :: Chunk-c256_b_234 = bc256 c256_234--c256_b_235 :: Chunk-c256_b_235 = bc256 c256_235--c256_b_236 :: Chunk-c256_b_236 = bc256 c256_236--c256_b_237 :: Chunk-c256_b_237 = bc256 c256_237--c256_b_238 :: Chunk-c256_b_238 = bc256 c256_238--c256_b_239 :: Chunk-c256_b_239 = bc256 c256_239--c256_b_240 :: Chunk-c256_b_240 = bc256 c256_240--c256_b_241 :: Chunk-c256_b_241 = bc256 c256_241--c256_b_242 :: Chunk-c256_b_242 = bc256 c256_242--c256_b_243 :: Chunk-c256_b_243 = bc256 c256_243--c256_b_244 :: Chunk-c256_b_244 = bc256 c256_244--c256_b_245 :: Chunk-c256_b_245 = bc256 c256_245--c256_b_246 :: Chunk-c256_b_246 = bc256 c256_246--c256_b_247 :: Chunk-c256_b_247 = bc256 c256_247--c256_b_248 :: Chunk-c256_b_248 = bc256 c256_248--c256_b_249 :: Chunk-c256_b_249 = bc256 c256_249--c256_b_250 :: Chunk-c256_b_250 = bc256 c256_250--c256_b_251 :: Chunk-c256_b_251 = bc256 c256_251--c256_b_252 :: Chunk-c256_b_252 = bc256 c256_252--c256_b_253 :: Chunk-c256_b_253 = bc256 c256_253--c256_b_254 :: Chunk-c256_b_254 = bc256 c256_254--c256_b_255 :: Chunk-c256_b_255 = bc256 c256_255----- * Utility functions---- | Make a Color into a 8-color foreground Chunk.-fc8 :: Color8 -> Chunk-fc8 c = x { textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- foreground8 = Last . Just $ c }}}- where- x = mempty---- | Make a terminfo Color into a 8-color background Chunk.-bc8 :: Color8 -> Chunk-bc8 c = x { textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- background8 = Last . Just $ c }}}- where- x = mempty---- | Make a terminfo Color into a 256-color foreground Chunk.-fc256 :: Color256 -> Chunk-fc256 c = x { textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- foreground256 = Last . Just $ c }}}- where- x = mempty---- | Make a terminfo Color into a 256-color background Chunk.-bc256 :: Color256 -> Chunk-bc256 c = x { textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- background256 = Last . Just $ c }}}- where- x = mempty-
− lib/System/Console/Rainbow/Colors.hs
@@ -1,1240 +0,0 @@--- | Ordinarily you should not need this module. Typically you will--- just need to use "System.Console.Rainbow.ColorChunks", which is--- re-exported from "System.Console.Rainbow". However this module--- can be useful if you want names for individual colors, as opposed--- to names for chunks, which is what--- "System.Console.Rainbow.ColorChunks" provides.-module System.Console.Rainbow.Colors- (- - -- * Color types- Color8- , unColor8- , Color256- , unColor256- , to256-- -- * 8 colors, named- , c8_default- , c8_black- , c8_red- , c8_green- , c8_yellow- , c8_blue- , c8_magenta- , c8_cyan- , c8_white-- -- * 8 colors, numbered- , c8_0- , c8_1- , c8_2- , c8_3- , c8_4- , c8_5- , c8_6- , c8_7-- -- * All 8-colors- , c8_all-- -- * 256 colors, named- , c256_default- , c256_black- , c256_red- , c256_green- , c256_yellow- , c256_blue- , c256_magenta- , c256_cyan- , c256_white- , c256_grey-- -- * 256 colors, bright- , c256_red_bright- , c256_green_bright- , c256_yellow_bright- , c256_blue_bright- , c256_magenta_bright- , c256_cyan_bright- , c256_white_bright-- -- * 256 colors, numbered- , c256_0- , c256_1- , c256_2- , c256_3- , c256_4- , c256_5- , c256_6- , c256_7- , c256_8- , c256_9- , c256_10- , c256_11- , c256_12- , c256_13- , c256_14- , c256_15- , c256_16- , c256_17- , c256_18- , c256_19- , c256_20- , c256_21- , c256_22- , c256_23- , c256_24- , c256_25- , c256_26- , c256_27- , c256_28- , c256_29- , c256_30- , c256_31- , c256_32- , c256_33- , c256_34- , c256_35- , c256_36- , c256_37- , c256_38- , c256_39- , c256_40- , c256_41- , c256_42- , c256_43- , c256_44- , c256_45- , c256_46- , c256_47- , c256_48- , c256_49- , c256_50- , c256_51- , c256_52- , c256_53- , c256_54- , c256_55- , c256_56- , c256_57- , c256_58- , c256_59- , c256_60- , c256_61- , c256_62- , c256_63- , c256_64- , c256_65- , c256_66- , c256_67- , c256_68- , c256_69- , c256_70- , c256_71- , c256_72- , c256_73- , c256_74- , c256_75- , c256_76- , c256_77- , c256_78- , c256_79- , c256_80- , c256_81- , c256_82- , c256_83- , c256_84- , c256_85- , c256_86- , c256_87- , c256_88- , c256_89- , c256_90- , c256_91- , c256_92- , c256_93- , c256_94- , c256_95- , c256_96- , c256_97- , c256_98- , c256_99- , c256_100- , c256_101- , c256_102- , c256_103- , c256_104- , c256_105- , c256_106- , c256_107- , c256_108- , c256_109- , c256_110- , c256_111- , c256_112- , c256_113- , c256_114- , c256_115- , c256_116- , c256_117- , c256_118- , c256_119- , c256_120- , c256_121- , c256_122- , c256_123- , c256_124- , c256_125- , c256_126- , c256_127- , c256_128- , c256_129- , c256_130- , c256_131- , c256_132- , c256_133- , c256_134- , c256_135- , c256_136- , c256_137- , c256_138- , c256_139- , c256_140- , c256_141- , c256_142- , c256_143- , c256_144- , c256_145- , c256_146- , c256_147- , c256_148- , c256_149- , c256_150- , c256_151- , c256_152- , c256_153- , c256_154- , c256_155- , c256_156- , c256_157- , c256_158- , c256_159- , c256_160- , c256_161- , c256_162- , c256_163- , c256_164- , c256_165- , c256_166- , c256_167- , c256_168- , c256_169- , c256_170- , c256_171- , c256_172- , c256_173- , c256_174- , c256_175- , c256_176- , c256_177- , c256_178- , c256_179- , c256_180- , c256_181- , c256_182- , c256_183- , c256_184- , c256_185- , c256_186- , c256_187- , c256_188- , c256_189- , c256_190- , c256_191- , c256_192- , c256_193- , c256_194- , c256_195- , c256_196- , c256_197- , c256_198- , c256_199- , c256_200- , c256_201- , c256_202- , c256_203- , c256_204- , c256_205- , c256_206- , c256_207- , c256_208- , c256_209- , c256_210- , c256_211- , c256_212- , c256_213- , c256_214- , c256_215- , c256_216- , c256_217- , c256_218- , c256_219- , c256_220- , c256_221- , c256_222- , c256_223- , c256_224- , c256_225- , c256_226- , c256_227- , c256_228- , c256_229- , c256_230- , c256_231- , c256_232- , c256_233- , c256_234- , c256_235- , c256_236- , c256_237- , c256_238- , c256_239- , c256_240- , c256_241- , c256_242- , c256_243- , c256_244- , c256_245- , c256_246- , c256_247- , c256_248- , c256_249- , c256_250- , c256_251- , c256_252- , c256_253- , c256_254- , c256_255-- -- * All 256-colors- , c256_all- ) where---import qualified System.Console.Terminfo as T---- | Color for an 8-color terminal.--newtype Color8 = Color8- { unColor8 :: Maybe T.Color- -- ^ Nothing indicates to use the default color for the terminal;- -- otherwise, the Terminfo 'T.Color' is returned.- } deriving (Eq, Ord, Show)---- | Color for an 256-color terminal.--newtype Color256 = Color256- { unColor256 :: Maybe T.Color- -- ^ Nothing indicates to use the default color for the terminal;- -- otherwise, the Terminfo 'T.Color' is returned.- } deriving (Eq, Ord, Show)----- | Any color for an 8-color terminal can also be used in a--- 256-color terminal.-to256 :: Color8 -> Color256-to256 = Color256 . unColor8---- * 8 color--c8_default :: Color8-c8_default = Color8 Nothing--c8_black :: Color8-c8_black = Color8 (Just T.Black)--c8_red :: Color8-c8_red = Color8 (Just T.Red)--c8_green :: Color8-c8_green = Color8 (Just T.Green)--c8_yellow :: Color8-c8_yellow = Color8 (Just T.Yellow)--c8_blue :: Color8-c8_blue = Color8 (Just T.Blue)--c8_magenta :: Color8-c8_magenta = Color8 (Just T.Magenta)--c8_cyan :: Color8-c8_cyan = Color8 (Just T.Cyan)--c8_white :: Color8-c8_white = Color8 (Just T.White)---- * 8 colors, numbered--c8_0 :: Color8-c8_0 = Color8 . Just . T.ColorNumber $ 0--c8_1 :: Color8-c8_1 = Color8 . Just . T.ColorNumber $ 1--c8_2 :: Color8-c8_2 = Color8 . Just . T.ColorNumber $ 2--c8_3 :: Color8-c8_3 = Color8 . Just . T.ColorNumber $ 3--c8_4 :: Color8-c8_4 = Color8 . Just . T.ColorNumber $ 4--c8_5 :: Color8-c8_5 = Color8 . Just . T.ColorNumber $ 5--c8_6 :: Color8-c8_6 = Color8 . Just . T.ColorNumber $ 6--c8_7 :: Color8-c8_7 = Color8 . Just . T.ColorNumber $ 7---- | All colors available for an 8-color terminal, in an association--- list indexed by color number. Does not include the default--- color, 'c8_default'.-c8_all :: [(Int, Color8)]-c8_all = map f [0..7]- where- f n = (n, Color8 . Just . T.ColorNumber $ n)---- * 256 color--c256_default :: Color256-c256_default = Color256 Nothing--c256_0 :: Color256-c256_0 = Color256 (Just (T.ColorNumber 0))--c256_black :: Color256-c256_black = Color256 (Just (T.ColorNumber 0))--c256_1 :: Color256-c256_1 = Color256 (Just (T.ColorNumber 1))--c256_red :: Color256-c256_red = Color256 (Just (T.ColorNumber 1))--c256_2 :: Color256-c256_2 = Color256 (Just (T.ColorNumber 2))--c256_green :: Color256-c256_green = Color256 (Just (T.ColorNumber 2))--c256_3 :: Color256-c256_3 = Color256 (Just (T.ColorNumber 3))--c256_yellow :: Color256-c256_yellow = Color256 (Just (T.ColorNumber 3))--c256_4 :: Color256-c256_4 = Color256 (Just (T.ColorNumber 4))--c256_blue :: Color256-c256_blue = Color256 (Just (T.ColorNumber 4))--c256_5 :: Color256-c256_5 = Color256 (Just (T.ColorNumber 5))--c256_magenta :: Color256-c256_magenta = Color256 (Just (T.ColorNumber 5))--c256_6 :: Color256-c256_6 = Color256 (Just (T.ColorNumber 6))--c256_cyan :: Color256-c256_cyan = Color256 (Just (T.ColorNumber 6))--c256_7 :: Color256-c256_7 = Color256 (Just (T.ColorNumber 7))--c256_white :: Color256-c256_white = Color256 (Just (T.ColorNumber 7))--c256_8 :: Color256-c256_8 = Color256 (Just (T.ColorNumber 8))--c256_grey :: Color256-c256_grey = Color256 (Just (T.ColorNumber 8))--c256_9 :: Color256-c256_9 = Color256 (Just (T.ColorNumber 9))--c256_red_bright :: Color256-c256_red_bright = Color256 (Just (T.ColorNumber 9))--c256_10 :: Color256-c256_10 = Color256 (Just (T.ColorNumber 10))--c256_green_bright :: Color256-c256_green_bright = Color256 (Just (T.ColorNumber 10))--c256_11 :: Color256-c256_11 = Color256 (Just (T.ColorNumber 11))--c256_yellow_bright :: Color256-c256_yellow_bright = Color256 (Just (T.ColorNumber 11))--c256_12 :: Color256-c256_12 = Color256 (Just (T.ColorNumber 12))--c256_blue_bright :: Color256-c256_blue_bright = Color256 (Just (T.ColorNumber 12))--c256_13 :: Color256-c256_13 = Color256 (Just (T.ColorNumber 13))--c256_magenta_bright :: Color256-c256_magenta_bright = Color256 (Just (T.ColorNumber 13))--c256_14 :: Color256-c256_14 = Color256 (Just (T.ColorNumber 14))--c256_cyan_bright :: Color256-c256_cyan_bright = Color256 (Just (T.ColorNumber 14))--c256_15 :: Color256-c256_15 = Color256 (Just (T.ColorNumber 15))--c256_white_bright :: Color256-c256_white_bright = Color256 (Just (T.ColorNumber 15))--c256_16 :: Color256-c256_16 = Color256 (Just (T.ColorNumber 16))--c256_17 :: Color256-c256_17 = Color256 (Just (T.ColorNumber 17))--c256_18 :: Color256-c256_18 = Color256 (Just (T.ColorNumber 18))--c256_19 :: Color256-c256_19 = Color256 (Just (T.ColorNumber 19))--c256_20 :: Color256-c256_20 = Color256 (Just (T.ColorNumber 20))--c256_21 :: Color256-c256_21 = Color256 (Just (T.ColorNumber 21))--c256_22 :: Color256-c256_22 = Color256 (Just (T.ColorNumber 22))--c256_23 :: Color256-c256_23 = Color256 (Just (T.ColorNumber 23))--c256_24 :: Color256-c256_24 = Color256 (Just (T.ColorNumber 24))--c256_25 :: Color256-c256_25 = Color256 (Just (T.ColorNumber 25))--c256_26 :: Color256-c256_26 = Color256 (Just (T.ColorNumber 26))--c256_27 :: Color256-c256_27 = Color256 (Just (T.ColorNumber 27))--c256_28 :: Color256-c256_28 = Color256 (Just (T.ColorNumber 28))--c256_29 :: Color256-c256_29 = Color256 (Just (T.ColorNumber 29))--c256_30 :: Color256-c256_30 = Color256 (Just (T.ColorNumber 30))--c256_31 :: Color256-c256_31 = Color256 (Just (T.ColorNumber 31))--c256_32 :: Color256-c256_32 = Color256 (Just (T.ColorNumber 32))--c256_33 :: Color256-c256_33 = Color256 (Just (T.ColorNumber 33))--c256_34 :: Color256-c256_34 = Color256 (Just (T.ColorNumber 34))--c256_35 :: Color256-c256_35 = Color256 (Just (T.ColorNumber 35))--c256_36 :: Color256-c256_36 = Color256 (Just (T.ColorNumber 36))--c256_37 :: Color256-c256_37 = Color256 (Just (T.ColorNumber 37))--c256_38 :: Color256-c256_38 = Color256 (Just (T.ColorNumber 38))--c256_39 :: Color256-c256_39 = Color256 (Just (T.ColorNumber 39))--c256_40 :: Color256-c256_40 = Color256 (Just (T.ColorNumber 40))--c256_41 :: Color256-c256_41 = Color256 (Just (T.ColorNumber 41))--c256_42 :: Color256-c256_42 = Color256 (Just (T.ColorNumber 42))--c256_43 :: Color256-c256_43 = Color256 (Just (T.ColorNumber 43))--c256_44 :: Color256-c256_44 = Color256 (Just (T.ColorNumber 44))--c256_45 :: Color256-c256_45 = Color256 (Just (T.ColorNumber 45))--c256_46 :: Color256-c256_46 = Color256 (Just (T.ColorNumber 46))--c256_47 :: Color256-c256_47 = Color256 (Just (T.ColorNumber 47))--c256_48 :: Color256-c256_48 = Color256 (Just (T.ColorNumber 48))--c256_49 :: Color256-c256_49 = Color256 (Just (T.ColorNumber 49))--c256_50 :: Color256-c256_50 = Color256 (Just (T.ColorNumber 50))--c256_51 :: Color256-c256_51 = Color256 (Just (T.ColorNumber 51))--c256_52 :: Color256-c256_52 = Color256 (Just (T.ColorNumber 52))--c256_53 :: Color256-c256_53 = Color256 (Just (T.ColorNumber 53))--c256_54 :: Color256-c256_54 = Color256 (Just (T.ColorNumber 54))--c256_55 :: Color256-c256_55 = Color256 (Just (T.ColorNumber 55))--c256_56 :: Color256-c256_56 = Color256 (Just (T.ColorNumber 56))--c256_57 :: Color256-c256_57 = Color256 (Just (T.ColorNumber 57))--c256_58 :: Color256-c256_58 = Color256 (Just (T.ColorNumber 58))--c256_59 :: Color256-c256_59 = Color256 (Just (T.ColorNumber 59))--c256_60 :: Color256-c256_60 = Color256 (Just (T.ColorNumber 60))--c256_61 :: Color256-c256_61 = Color256 (Just (T.ColorNumber 61))--c256_62 :: Color256-c256_62 = Color256 (Just (T.ColorNumber 62))--c256_63 :: Color256-c256_63 = Color256 (Just (T.ColorNumber 63))--c256_64 :: Color256-c256_64 = Color256 (Just (T.ColorNumber 64))--c256_65 :: Color256-c256_65 = Color256 (Just (T.ColorNumber 65))--c256_66 :: Color256-c256_66 = Color256 (Just (T.ColorNumber 66))--c256_67 :: Color256-c256_67 = Color256 (Just (T.ColorNumber 67))--c256_68 :: Color256-c256_68 = Color256 (Just (T.ColorNumber 68))--c256_69 :: Color256-c256_69 = Color256 (Just (T.ColorNumber 69))--c256_70 :: Color256-c256_70 = Color256 (Just (T.ColorNumber 70))--c256_71 :: Color256-c256_71 = Color256 (Just (T.ColorNumber 71))--c256_72 :: Color256-c256_72 = Color256 (Just (T.ColorNumber 72))--c256_73 :: Color256-c256_73 = Color256 (Just (T.ColorNumber 73))--c256_74 :: Color256-c256_74 = Color256 (Just (T.ColorNumber 74))--c256_75 :: Color256-c256_75 = Color256 (Just (T.ColorNumber 75))--c256_76 :: Color256-c256_76 = Color256 (Just (T.ColorNumber 76))--c256_77 :: Color256-c256_77 = Color256 (Just (T.ColorNumber 77))--c256_78 :: Color256-c256_78 = Color256 (Just (T.ColorNumber 78))--c256_79 :: Color256-c256_79 = Color256 (Just (T.ColorNumber 79))--c256_80 :: Color256-c256_80 = Color256 (Just (T.ColorNumber 80))--c256_81 :: Color256-c256_81 = Color256 (Just (T.ColorNumber 81))--c256_82 :: Color256-c256_82 = Color256 (Just (T.ColorNumber 82))--c256_83 :: Color256-c256_83 = Color256 (Just (T.ColorNumber 83))--c256_84 :: Color256-c256_84 = Color256 (Just (T.ColorNumber 84))--c256_85 :: Color256-c256_85 = Color256 (Just (T.ColorNumber 85))--c256_86 :: Color256-c256_86 = Color256 (Just (T.ColorNumber 86))--c256_87 :: Color256-c256_87 = Color256 (Just (T.ColorNumber 87))--c256_88 :: Color256-c256_88 = Color256 (Just (T.ColorNumber 88))--c256_89 :: Color256-c256_89 = Color256 (Just (T.ColorNumber 89))--c256_90 :: Color256-c256_90 = Color256 (Just (T.ColorNumber 90))--c256_91 :: Color256-c256_91 = Color256 (Just (T.ColorNumber 91))--c256_92 :: Color256-c256_92 = Color256 (Just (T.ColorNumber 92))--c256_93 :: Color256-c256_93 = Color256 (Just (T.ColorNumber 93))--c256_94 :: Color256-c256_94 = Color256 (Just (T.ColorNumber 94))--c256_95 :: Color256-c256_95 = Color256 (Just (T.ColorNumber 95))--c256_96 :: Color256-c256_96 = Color256 (Just (T.ColorNumber 96))--c256_97 :: Color256-c256_97 = Color256 (Just (T.ColorNumber 97))--c256_98 :: Color256-c256_98 = Color256 (Just (T.ColorNumber 98))--c256_99 :: Color256-c256_99 = Color256 (Just (T.ColorNumber 99))--c256_100 :: Color256-c256_100 = Color256 (Just (T.ColorNumber 100))--c256_101 :: Color256-c256_101 = Color256 (Just (T.ColorNumber 101))--c256_102 :: Color256-c256_102 = Color256 (Just (T.ColorNumber 102))--c256_103 :: Color256-c256_103 = Color256 (Just (T.ColorNumber 103))--c256_104 :: Color256-c256_104 = Color256 (Just (T.ColorNumber 104))--c256_105 :: Color256-c256_105 = Color256 (Just (T.ColorNumber 105))--c256_106 :: Color256-c256_106 = Color256 (Just (T.ColorNumber 106))--c256_107 :: Color256-c256_107 = Color256 (Just (T.ColorNumber 107))--c256_108 :: Color256-c256_108 = Color256 (Just (T.ColorNumber 108))--c256_109 :: Color256-c256_109 = Color256 (Just (T.ColorNumber 109))--c256_110 :: Color256-c256_110 = Color256 (Just (T.ColorNumber 110))--c256_111 :: Color256-c256_111 = Color256 (Just (T.ColorNumber 111))--c256_112 :: Color256-c256_112 = Color256 (Just (T.ColorNumber 112))--c256_113 :: Color256-c256_113 = Color256 (Just (T.ColorNumber 113))--c256_114 :: Color256-c256_114 = Color256 (Just (T.ColorNumber 114))--c256_115 :: Color256-c256_115 = Color256 (Just (T.ColorNumber 115))--c256_116 :: Color256-c256_116 = Color256 (Just (T.ColorNumber 116))--c256_117 :: Color256-c256_117 = Color256 (Just (T.ColorNumber 117))--c256_118 :: Color256-c256_118 = Color256 (Just (T.ColorNumber 118))--c256_119 :: Color256-c256_119 = Color256 (Just (T.ColorNumber 119))--c256_120 :: Color256-c256_120 = Color256 (Just (T.ColorNumber 120))--c256_121 :: Color256-c256_121 = Color256 (Just (T.ColorNumber 121))--c256_122 :: Color256-c256_122 = Color256 (Just (T.ColorNumber 122))--c256_123 :: Color256-c256_123 = Color256 (Just (T.ColorNumber 123))--c256_124 :: Color256-c256_124 = Color256 (Just (T.ColorNumber 124))--c256_125 :: Color256-c256_125 = Color256 (Just (T.ColorNumber 125))--c256_126 :: Color256-c256_126 = Color256 (Just (T.ColorNumber 126))--c256_127 :: Color256-c256_127 = Color256 (Just (T.ColorNumber 127))--c256_128 :: Color256-c256_128 = Color256 (Just (T.ColorNumber 128))--c256_129 :: Color256-c256_129 = Color256 (Just (T.ColorNumber 129))--c256_130 :: Color256-c256_130 = Color256 (Just (T.ColorNumber 130))--c256_131 :: Color256-c256_131 = Color256 (Just (T.ColorNumber 131))--c256_132 :: Color256-c256_132 = Color256 (Just (T.ColorNumber 132))--c256_133 :: Color256-c256_133 = Color256 (Just (T.ColorNumber 133))--c256_134 :: Color256-c256_134 = Color256 (Just (T.ColorNumber 134))--c256_135 :: Color256-c256_135 = Color256 (Just (T.ColorNumber 135))--c256_136 :: Color256-c256_136 = Color256 (Just (T.ColorNumber 136))--c256_137 :: Color256-c256_137 = Color256 (Just (T.ColorNumber 137))--c256_138 :: Color256-c256_138 = Color256 (Just (T.ColorNumber 138))--c256_139 :: Color256-c256_139 = Color256 (Just (T.ColorNumber 139))--c256_140 :: Color256-c256_140 = Color256 (Just (T.ColorNumber 140))--c256_141 :: Color256-c256_141 = Color256 (Just (T.ColorNumber 141))--c256_142 :: Color256-c256_142 = Color256 (Just (T.ColorNumber 142))--c256_143 :: Color256-c256_143 = Color256 (Just (T.ColorNumber 143))--c256_144 :: Color256-c256_144 = Color256 (Just (T.ColorNumber 144))--c256_145 :: Color256-c256_145 = Color256 (Just (T.ColorNumber 145))--c256_146 :: Color256-c256_146 = Color256 (Just (T.ColorNumber 146))--c256_147 :: Color256-c256_147 = Color256 (Just (T.ColorNumber 147))--c256_148 :: Color256-c256_148 = Color256 (Just (T.ColorNumber 148))--c256_149 :: Color256-c256_149 = Color256 (Just (T.ColorNumber 149))--c256_150 :: Color256-c256_150 = Color256 (Just (T.ColorNumber 150))--c256_151 :: Color256-c256_151 = Color256 (Just (T.ColorNumber 151))--c256_152 :: Color256-c256_152 = Color256 (Just (T.ColorNumber 152))--c256_153 :: Color256-c256_153 = Color256 (Just (T.ColorNumber 153))--c256_154 :: Color256-c256_154 = Color256 (Just (T.ColorNumber 154))--c256_155 :: Color256-c256_155 = Color256 (Just (T.ColorNumber 155))--c256_156 :: Color256-c256_156 = Color256 (Just (T.ColorNumber 156))--c256_157 :: Color256-c256_157 = Color256 (Just (T.ColorNumber 157))--c256_158 :: Color256-c256_158 = Color256 (Just (T.ColorNumber 158))--c256_159 :: Color256-c256_159 = Color256 (Just (T.ColorNumber 159))--c256_160 :: Color256-c256_160 = Color256 (Just (T.ColorNumber 160))--c256_161 :: Color256-c256_161 = Color256 (Just (T.ColorNumber 161))--c256_162 :: Color256-c256_162 = Color256 (Just (T.ColorNumber 162))--c256_163 :: Color256-c256_163 = Color256 (Just (T.ColorNumber 163))--c256_164 :: Color256-c256_164 = Color256 (Just (T.ColorNumber 164))--c256_165 :: Color256-c256_165 = Color256 (Just (T.ColorNumber 165))--c256_166 :: Color256-c256_166 = Color256 (Just (T.ColorNumber 166))--c256_167 :: Color256-c256_167 = Color256 (Just (T.ColorNumber 167))--c256_168 :: Color256-c256_168 = Color256 (Just (T.ColorNumber 168))--c256_169 :: Color256-c256_169 = Color256 (Just (T.ColorNumber 169))--c256_170 :: Color256-c256_170 = Color256 (Just (T.ColorNumber 170))--c256_171 :: Color256-c256_171 = Color256 (Just (T.ColorNumber 171))--c256_172 :: Color256-c256_172 = Color256 (Just (T.ColorNumber 172))--c256_173 :: Color256-c256_173 = Color256 (Just (T.ColorNumber 173))--c256_174 :: Color256-c256_174 = Color256 (Just (T.ColorNumber 174))--c256_175 :: Color256-c256_175 = Color256 (Just (T.ColorNumber 175))--c256_176 :: Color256-c256_176 = Color256 (Just (T.ColorNumber 176))--c256_177 :: Color256-c256_177 = Color256 (Just (T.ColorNumber 177))--c256_178 :: Color256-c256_178 = Color256 (Just (T.ColorNumber 178))--c256_179 :: Color256-c256_179 = Color256 (Just (T.ColorNumber 179))--c256_180 :: Color256-c256_180 = Color256 (Just (T.ColorNumber 180))--c256_181 :: Color256-c256_181 = Color256 (Just (T.ColorNumber 181))--c256_182 :: Color256-c256_182 = Color256 (Just (T.ColorNumber 182))--c256_183 :: Color256-c256_183 = Color256 (Just (T.ColorNumber 183))--c256_184 :: Color256-c256_184 = Color256 (Just (T.ColorNumber 184))--c256_185 :: Color256-c256_185 = Color256 (Just (T.ColorNumber 185))--c256_186 :: Color256-c256_186 = Color256 (Just (T.ColorNumber 186))--c256_187 :: Color256-c256_187 = Color256 (Just (T.ColorNumber 187))--c256_188 :: Color256-c256_188 = Color256 (Just (T.ColorNumber 188))--c256_189 :: Color256-c256_189 = Color256 (Just (T.ColorNumber 189))--c256_190 :: Color256-c256_190 = Color256 (Just (T.ColorNumber 190))--c256_191 :: Color256-c256_191 = Color256 (Just (T.ColorNumber 191))--c256_192 :: Color256-c256_192 = Color256 (Just (T.ColorNumber 192))--c256_193 :: Color256-c256_193 = Color256 (Just (T.ColorNumber 193))--c256_194 :: Color256-c256_194 = Color256 (Just (T.ColorNumber 194))--c256_195 :: Color256-c256_195 = Color256 (Just (T.ColorNumber 195))--c256_196 :: Color256-c256_196 = Color256 (Just (T.ColorNumber 196))--c256_197 :: Color256-c256_197 = Color256 (Just (T.ColorNumber 197))--c256_198 :: Color256-c256_198 = Color256 (Just (T.ColorNumber 198))--c256_199 :: Color256-c256_199 = Color256 (Just (T.ColorNumber 199))--c256_200 :: Color256-c256_200 = Color256 (Just (T.ColorNumber 200))--c256_201 :: Color256-c256_201 = Color256 (Just (T.ColorNumber 201))--c256_202 :: Color256-c256_202 = Color256 (Just (T.ColorNumber 202))--c256_203 :: Color256-c256_203 = Color256 (Just (T.ColorNumber 203))--c256_204 :: Color256-c256_204 = Color256 (Just (T.ColorNumber 204))--c256_205 :: Color256-c256_205 = Color256 (Just (T.ColorNumber 205))--c256_206 :: Color256-c256_206 = Color256 (Just (T.ColorNumber 206))--c256_207 :: Color256-c256_207 = Color256 (Just (T.ColorNumber 207))--c256_208 :: Color256-c256_208 = Color256 (Just (T.ColorNumber 208))--c256_209 :: Color256-c256_209 = Color256 (Just (T.ColorNumber 209))--c256_210 :: Color256-c256_210 = Color256 (Just (T.ColorNumber 210))--c256_211 :: Color256-c256_211 = Color256 (Just (T.ColorNumber 211))--c256_212 :: Color256-c256_212 = Color256 (Just (T.ColorNumber 212))--c256_213 :: Color256-c256_213 = Color256 (Just (T.ColorNumber 213))--c256_214 :: Color256-c256_214 = Color256 (Just (T.ColorNumber 214))--c256_215 :: Color256-c256_215 = Color256 (Just (T.ColorNumber 215))--c256_216 :: Color256-c256_216 = Color256 (Just (T.ColorNumber 216))--c256_217 :: Color256-c256_217 = Color256 (Just (T.ColorNumber 217))--c256_218 :: Color256-c256_218 = Color256 (Just (T.ColorNumber 218))--c256_219 :: Color256-c256_219 = Color256 (Just (T.ColorNumber 219))--c256_220 :: Color256-c256_220 = Color256 (Just (T.ColorNumber 220))--c256_221 :: Color256-c256_221 = Color256 (Just (T.ColorNumber 221))--c256_222 :: Color256-c256_222 = Color256 (Just (T.ColorNumber 222))--c256_223 :: Color256-c256_223 = Color256 (Just (T.ColorNumber 223))--c256_224 :: Color256-c256_224 = Color256 (Just (T.ColorNumber 224))--c256_225 :: Color256-c256_225 = Color256 (Just (T.ColorNumber 225))--c256_226 :: Color256-c256_226 = Color256 (Just (T.ColorNumber 226))--c256_227 :: Color256-c256_227 = Color256 (Just (T.ColorNumber 227))--c256_228 :: Color256-c256_228 = Color256 (Just (T.ColorNumber 228))--c256_229 :: Color256-c256_229 = Color256 (Just (T.ColorNumber 229))--c256_230 :: Color256-c256_230 = Color256 (Just (T.ColorNumber 230))--c256_231 :: Color256-c256_231 = Color256 (Just (T.ColorNumber 231))--c256_232 :: Color256-c256_232 = Color256 (Just (T.ColorNumber 232))--c256_233 :: Color256-c256_233 = Color256 (Just (T.ColorNumber 233))--c256_234 :: Color256-c256_234 = Color256 (Just (T.ColorNumber 234))--c256_235 :: Color256-c256_235 = Color256 (Just (T.ColorNumber 235))--c256_236 :: Color256-c256_236 = Color256 (Just (T.ColorNumber 236))--c256_237 :: Color256-c256_237 = Color256 (Just (T.ColorNumber 237))--c256_238 :: Color256-c256_238 = Color256 (Just (T.ColorNumber 238))--c256_239 :: Color256-c256_239 = Color256 (Just (T.ColorNumber 239))--c256_240 :: Color256-c256_240 = Color256 (Just (T.ColorNumber 240))--c256_241 :: Color256-c256_241 = Color256 (Just (T.ColorNumber 241))--c256_242 :: Color256-c256_242 = Color256 (Just (T.ColorNumber 242))--c256_243 :: Color256-c256_243 = Color256 (Just (T.ColorNumber 243))--c256_244 :: Color256-c256_244 = Color256 (Just (T.ColorNumber 244))--c256_245 :: Color256-c256_245 = Color256 (Just (T.ColorNumber 245))--c256_246 :: Color256-c256_246 = Color256 (Just (T.ColorNumber 246))--c256_247 :: Color256-c256_247 = Color256 (Just (T.ColorNumber 247))--c256_248 :: Color256-c256_248 = Color256 (Just (T.ColorNumber 248))--c256_249 :: Color256-c256_249 = Color256 (Just (T.ColorNumber 249))--c256_250 :: Color256-c256_250 = Color256 (Just (T.ColorNumber 250))--c256_251 :: Color256-c256_251 = Color256 (Just (T.ColorNumber 251))--c256_252 :: Color256-c256_252 = Color256 (Just (T.ColorNumber 252))--c256_253 :: Color256-c256_253 = Color256 (Just (T.ColorNumber 253))--c256_254 :: Color256-c256_254 = Color256 (Just (T.ColorNumber 254))--c256_255 :: Color256-c256_255 = Color256 (Just (T.ColorNumber 255))---- | All available colors for a 256-color terminal, in an--- association list by color number. Does not include the default--- color, 'c256_default'.--c256_all :: [(Int, Color256)]-c256_all = map f [0..255]- where- f n = (n, Color256 . Just . T.ColorNumber $ n)
− lib/System/Console/Rainbow/Types.hs
@@ -1,483 +0,0 @@--- | The innards of Rainbow. Ordinarily you should not need this--- module; instead, just import "System.Console.Rainbow", which--- re-exports the most useful names from this module.--module System.Console.Rainbow.Types where---- # Imports--import qualified Data.String as Str-import Data.Monoid-import Data.Text (Text)-import Data.Maybe (fromMaybe)-import qualified Data.Text as X-import qualified Data.Text.Lazy as XL-import qualified System.Console.Terminfo as T-import System.IO as IO-import System.Environment as Env-import System.Console.Rainbow.Colors------- Terminal definitions------- | Which terminal definition to use.-data Term- = Dumb- -- ^ Using this terminal should always succeed. This suppresses all- -- colors. Uesful if output is not going to a TTY, or if you just do- -- not like colors.-- | TermName String- -- ^ Use the terminal with this given name. You might get this from- -- the TERM environment variable, or set it explicitly. A runtime- -- error will result if the terminfo database does not have a- -- definition for this terminal. If this terminal supports 256- -- colors, then 256 colors are used. If this terminal supports less- -- than 256 colors, but at least 8 colors, then 8 colors are- -- used. Otherwise, no colors are used.- deriving (Eq, Show)---- | Gets the terminal definition from the environment. If the--- environment does not have a TERM veriable, use 'Dumb'.-termFromEnv :: IO Term-termFromEnv = do- t <- fmap (lookup "TERM") Env.getEnvironment- return $ maybe Dumb TermName t---- | Gets the terminal definition from the environment and a handle.--- If the handle is not a terminal, 'Dumb' is returned. Otherwise,--- the terminal is obtained from the environment.------ /Changed in version 0.12.0.0/ - the type of this function was--- different in previous versions.-smartTermFromEnv- :: IO.Handle- -- ^ Check this handle to see if it is a terminal (typically you- -- will use stdout).-- -> IO Term-smartTermFromEnv h = IO.hIsTerminalDevice h >>= f- where- f isTerm | isTerm = termFromEnv- | otherwise = return Dumb---- For Background8, Background256, Foreground8, Foreground256: the--- Last wraps a Maybe (Terminfo Color). If the inner Maybe is Nothing,--- use the default color.--type Background8 = Last Color8-type Background256 = Last Color256-type Foreground8 = Last Color8-type Foreground256 = Last Color256------- Styles------- | Style elements that apply in both 8 and 256 color--- terminals. However, the elements are described separately for 8 and--- 256 color terminals, so that the text appearance can change--- depending on how many colors a terminal has.-data StyleCommon = StyleCommon- { scBold :: Last Bool- , scUnderline :: Last Bool- , scFlash :: Last Bool- , scInverse :: Last Bool- } deriving (Show, Eq, Ord)---instance Monoid StyleCommon where- mempty = StyleCommon (Last Nothing) (Last Nothing)- (Last Nothing) (Last Nothing)- mappend (StyleCommon b1 u1 f1 i1) (StyleCommon b2 u2 f2 i2)- = StyleCommon (b1 <> b2) (u1 <> u2) (f1 <> f2) (i1 <> i2)---- | Describes text appearance (foreground and background colors, as--- well as other attributes such as bold) for an 8 color terminal.-data Style8 = Style8- { foreground8 :: Foreground8- , background8 :: Background8- , common8 :: StyleCommon- } deriving (Show, Eq, Ord)---instance Monoid Style8 where- mappend (Style8 fx bx cx) (Style8 fy by cy)- = Style8 (fx <> fy) (bx <> by) (cx <> cy)- mempty = Style8 mempty mempty mempty---- | Describes text appearance (foreground and background colors, as--- well as other attributes such as bold) for a 256 color terminal.-data Style256 = Style256- { foreground256 :: Foreground256- , background256 :: Background256- , common256 :: StyleCommon- } deriving (Show, Eq, Ord)---instance Monoid Style256 where- mappend (Style256 fx bx cx) (Style256 fy by cy)- = Style256 (fx <> fy) (bx <> by) (cx <> cy)- mempty = Style256 mempty mempty mempty------- TextSpec------- | The TextSpec bundles together the styles for the 8 and 256 color--- terminals, so that the text can be portrayed on any terminal.-data TextSpec = TextSpec- { style8 :: Style8- , style256 :: Style256- } deriving (Show, Eq, Ord)---instance Monoid TextSpec where- mappend (TextSpec x1 x2) (TextSpec y1 y2)- = TextSpec (x1 <> y1) (x2 <> y2)- mempty = TextSpec mempty mempty------- Chunks------- | A chunk is some textual data coupled with a description of what--- color the text is, attributes like whether it is bold or--- underlined, etc. The chunk knows what foreground and background--- colors and what attributes to use for both an 8 color terminal and--- a 256 color terminal.------ The text is held as a list of strict 'Text'.--data Chunk = Chunk- { textSpec :: TextSpec- , text :: [Text]- } deriving (Eq, Show, Ord)---instance Str.IsString Chunk where- fromString s = Chunk mempty [(X.pack s)]---- | Creates a 'Chunk' from a strict 'X.Text' with default colors--- and no special effects.-fromText :: Text -> Chunk-fromText = Chunk mempty . (:[])---- | Creates a 'Chunk' from a lazy 'XL.Text' with default colors and--- no special effects.-fromLazyText :: XL.Text -> Chunk-fromLazyText = Chunk mempty . XL.toChunks--instance Monoid Chunk where- mempty = Chunk mempty mempty- mappend (Chunk s1 t1) (Chunk s2 t2) = Chunk (s1 <> s2) (t1 <> t2)---defaultColors :: T.Terminal -> T.TermOutput-defaultColors term =- fromMaybe mempty (T.getCapability term T.restoreDefaultColors)---commonAttrs :: T.Terminal -> StyleCommon -> T.TermOutput-commonAttrs t s =- let a = T.Attributes- { T.standoutAttr = False- , T.underlineAttr = fromMaybe False- . getLast . scUnderline $ s- , T.reverseAttr = fromMaybe False- . getLast . scInverse $ s- , T.blinkAttr = fromMaybe False- . getLast . scFlash $ s- , T.dimAttr = False- , T.boldAttr = fromMaybe False- . getLast . scBold $ s- , T.invisibleAttr = False- , T.protectedAttr = False- }- in case T.getCapability t (T.setAttributes) of- Nothing -> error $ "System.Console.Rainbow: commonAttrs: "- ++ "capability failed; should never happen"- Just f -> f a----- | Gets the right set of terminal codes to apply the desired--- highlighting, bold, underlining, etc. Be sure to apply the--- attributes first (bold, underlining, etc) and then the--- colors. Setting the colors first and then the attributes seems to--- reset the colors, giving blank output.-getTermCodes- :: T.Terminal- -> TextSpec- -> T.TermOutput-getTermCodes t ts = fromMaybe mempty $ do- cols <- T.getCapability t T.termColors- let TextSpec s8 s256 = ts- Style8 f8 b8 c8 = s8- Style256 f256 b256 c256 = s256- setFg <- T.getCapability t T.setForegroundColor- setBg <- T.getCapability t T.setBackgroundColor- (fg, bg, cm) <- case () of- _ | cols >= 256 -> Just $ ( fmap unColor256 $ getLast f256- , fmap unColor256 $ getLast b256- , c256)- | cols >= 8 -> Just ( fmap unColor8 $ getLast f8- , fmap unColor8 $ getLast b8- , c8)- | otherwise -> Nothing- let oFg = maybe mempty (maybe mempty setFg) fg- oBg = maybe mempty (maybe mempty setBg) bg- oCm = commonAttrs t cm- return $ mconcat [oCm, oFg, oBg]---hPrintChunk :: IO.Handle -> T.Terminal -> Chunk -> IO ()-hPrintChunk h t (Chunk ts xs) =- T.hRunTermOutput h t- . mconcat- $ defaultColors t : codes : (map (T.termText . X.unpack) $ xs)- where- codes = getTermCodes t ts---- | Sends a list of chunks to the given handle for printing. Sets up--- the terminal (this only needs to be done once.) Lazily processes--- the list of Chunk. See 'putChunks' for notes on how many colors--- are used.-hPutChunks :: IO.Handle -> Term -> [Chunk] -> IO ()-hPutChunks h t cs = do- let setup = case t of- Dumb -> T.setupTerm "dumb"- TermName s -> T.setupTerm s- term <- setup- mapM_ (hPrintChunk h term) cs- T.hRunTermOutput h term (defaultColors term)- T.hRunTermOutput h term- $ case T.getCapability term T.allAttributesOff of- Nothing -> error $ "System.Console.Rainbow.putChunks: error: "- ++ "allAttributesOff failed"- Just s -> s---- | Sends a list of chunks to standard output for printing. Sets up--- the terminal (this only needs to be done once.) Lazily processes--- the list of Chunk.------ Which colors are used depends upon the 'Term'. If it is 'Dumb',--- then no colors are used on output. If the 'Term' is specified with--- 'TermName', the UNIX terminfo library is used to determine how many--- colors the terminal supports. If it supports at least 256 colors,--- then 256 colors are used. If it supports at least 8 colors but less--- than 256 colors, then 256 colors are used. Otherwise, no colors are--- used. A runtime error will occur if the 'TermName' is not found in--- the system terminal database.-putChunks :: Term -> [Chunk] -> IO ()-putChunks = hPutChunks IO.stdout---- | Print one chunk at a time, to a handle-hPutChunk :: IO.Handle -> Chunk -> IO ()-hPutChunk h c = do- t <- termFromEnv- hPutChunks h t [c]---- | Print one chunk at a time, to standard output-putChunk :: Chunk -> IO ()-putChunk = hPutChunk IO.stdout---- | Print one chunk at a time, to a handle, append a newline-hPutChunkLn :: IO.Handle -> Chunk -> IO ()-hPutChunkLn h c = hPutChunk h c >> IO.hPutStr h "\n"---- | Print one chunk at a time, to standard output, append a newline-putChunkLn :: Chunk -> IO ()-putChunkLn c = putChunk c >> putStr "\n"--bold8 :: Chunk-bold8 = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scBold = Last (Just True) }}}}- where- x = mempty--bold8off :: Chunk-bold8off = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scBold = Last (Just False) }}}}- where- x = mempty---underline8 :: Chunk-underline8 = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scUnderline = Last (Just True) }}}}- where- x = mempty---underline8off :: Chunk-underline8off = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scUnderline = Last (Just False) }}}}- where- x = mempty--flash8 :: Chunk-flash8 = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scFlash = Last (Just True) }}}}- where- x = mempty--flash8off :: Chunk-flash8off = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scFlash = Last (Just False) }}}}- where- x = mempty---inverse8 :: Chunk-inverse8 = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scInverse = Last (Just True) }}}}- where- x = mempty--inverse8off :: Chunk-inverse8off = x {- textSpec = (textSpec x) {- style8 = (style8 (textSpec x)) {- common8 = (common8 (style8 (textSpec x))) {- scInverse = Last (Just False) }}}}- where- x = mempty---underline256 :: Chunk-underline256 = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scUnderline = Last (Just True) }}}}- where- x = mempty---underline256off :: Chunk-underline256off = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scUnderline = Last (Just False) }}}}- where- x = mempty--bold256 :: Chunk-bold256 = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scBold = Last (Just True) }}}}- where- x = mempty--bold256off :: Chunk-bold256off = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scBold = Last (Just False) }}}}- where- x = mempty---inverse256 :: Chunk-inverse256 = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scInverse = Last (Just True) }}}}- where- x = mempty--inverse256off :: Chunk-inverse256off = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scInverse = Last (Just False) }}}}- where- x = mempty---flash256 :: Chunk-flash256 = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scFlash = Last (Just True) }}}}- where- x = mempty---flash256off :: Chunk-flash256off = x {- textSpec = (textSpec x) {- style256 = (style256 (textSpec x)) {- common256 = (common256 (style256 (textSpec x))) {- scFlash = Last (Just False) }}}}- where- x = mempty-------- All-------- | Bold. What actually happens when you use Bold is going to depend--- on your terminal. For example, xterm allows you actually use a bold--- font for bold, if you have one. Otherwise, it might simulate bold--- by using overstriking. Another possibility is that your terminal--- might use a different color to indicate bold. For more details (at--- least for xterm), look at xterm (1) and search for @boldColors@.------ If your terminal uses a different color for bold, this allows an--- 8-color terminal to really have 16 colors.-bold :: Chunk-bold = bold8 <> bold256--boldOff :: Chunk-boldOff = bold8off <> bold256off--inverse :: Chunk-inverse = inverse8 <> inverse256--inverseOff :: Chunk-inverseOff = inverse8off <> inverse256off--flash :: Chunk-flash = flash8 <> flash256--flashOff :: Chunk-flashOff = flash8off <> flash256off--underline :: Chunk-underline = underline8 <> underline256--underlineOff :: Chunk-underlineOff = underline8off <> underline256off-
− minimum-versions.txt
@@ -1,40 +0,0 @@-This package was tested to work with these dependency-versions and compiler version.-These are the minimum versions given in the .cabal file.-Tested as of: 2014-06-14 00:45:34.239001 UTC-Path to compiler: ghc-7.4.1-Compiler description: 7.4.1--/opt/ghc/7.4.1/lib/ghc-7.4.1/package.conf.d:- Cabal-1.14.0- array-0.4.0.0- base-4.5.0.0- bin-package-db-0.0.0.0- binary-0.5.1.0- bytestring-0.9.2.1- containers-0.4.2.1- deepseq-1.3.0.0- directory-1.1.0.2- extensible-exceptions-0.1.1.4- filepath-1.3.0.0- (ghc-7.4.1)- ghc-prim-0.2.0.0- (haskell2010-1.1.0.1)- (haskell98-2.0.0.1)- hoopl-3.8.7.3- hpc-0.5.1.1- integer-gmp-0.4.0.0- old-locale-1.0.0.4- old-time-1.1.0.0- pretty-1.1.1.0- process-1.1.0.1- rts-1.0- template-haskell-2.7.0.0- time-1.4- unix-2.5.1.0--/home/massysett/rainbow/sunlight-9457/db:- rainbow-0.14.0.2- terminfo-0.3.2- text-0.11.2.0-
rainbow.cabal view
@@ -1,60 +1,95 @@--- This Cabal file generated using the Cartel library.--- Cartel is available at:--- http://www.github.com/massysett/cartel+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.31.2. ----- Script name used to generate: genCabal.hs--- Generated on: 2014-06-13 20:41:19.59408 EDT--- Cartel library version: 0.10.0.2-name: rainbow-version: 0.14.0.2-cabal-version: >= 1.14-build-type: Simple-license: BSD3-license-file: LICENSE-copyright: Copyright 2013 - 2014 Omari Norman-author: Omari Norman-maintainer: omari@smileystation.com-stability: Experimental-homepage: http://www.github.com/massysett/rainbow-bug-reports: http://www.github.com/massyett/rainbow/issues-synopsis: Print text to terminal with colors and effects-description:- rainbow helps you print Text chunks to a terminal with colors and effects- such as bold, underlining, etc. You pair each Text with a description- of how it should appear. Rainbow works with both 8-color and 256-color- terminals.- .- rainbow uses the terminfo package which, in turn, needs the full C- library for ncurses installed, including the development- headers. Before installing terminfo, you may need to install the- ncurses headers (for instance, on Debian systems, install the- libncurses5-dev package.)-category: System-tested-with: GHC == 7.4.1, GHC == 7.6.3, GHC == 7.8.2+-- see: https://github.com/sol/hpack+--+-- hash: 837a60ee2540f28dc14f871885d041b7f60038586de137f1f3e495154992b4fe++name: rainbow+version: 0.34.2.2+synopsis: Print text to terminal with colors and effects+description: Please see README.md+category: System+stability: Experimental+homepage: https://www.github.com/massysett/rainbow+bug-reports: https://www.github.com/massysett/rainbow/issues+author: Omari Norman+maintainer: omari@smileystation.com+copyright: Copyright 2013-2019 Omari Norman+license: BSD3+license-file: LICENSE+build-type: Simple extra-source-files: README.md- , sunlight-test.hs- , minimum-versions.txt- , current-versions.txt- , changelog+ stack.yaml+x-curation: uncurated source-repository head type: git- location: git://github.com/massysett/rainbow.git- branch: master+ location: https://github.com/massysett/rainbow -Library+library exposed-modules:- System.Console.Rainbow- , System.Console.Rainbow.ColorChunks- , System.Console.Rainbow.Colors- , System.Console.Rainbow.Types+ Rainbow+ Rainbow.Translate+ Rainbow.Types+ other-modules:+ Paths_rainbow+ hs-source-dirs:+ lib+ other-extensions: TemplateHaskell+ ghc-options: -Wall+ build-depends:+ base >=4.11 && <5+ , bytestring+ , lens+ , terminfo+ , text default-language: Haskell2010- ghc-options:- -Wall++test-suite rainbow-instances+ type: exitcode-stdio-1.0+ main-is: rainbow-instances.hs+ other-modules:+ Rainbow+ Rainbow.Translate+ Rainbow.Types+ Rainbow.QuickCheck+ Paths_rainbow hs-source-dirs: lib+ tests+ other-extensions: TemplateHaskell+ ghc-options: -Wall build-depends:- base ((> 4.5.0.0 || == 4.5.0.0) && < 4.8.0.0)- , terminfo ((> 0.3.2 || == 0.3.2) && < 0.5.0.0)- , text ((> 0.11.2.0 || == 0.11.2.0) && < 1.2.0.0)+ QuickCheck+ , base >=4.11 && <5+ , bytestring+ , lens+ , terminfo+ , text+ default-language: Haskell2010++test-suite rainbow-visual+ type: exitcode-stdio-1.0+ main-is: rainbow-visual.hs+ other-modules:+ Rainbow+ Rainbow.Translate+ Rainbow.Types+ Rainbow.QuickCheck+ Paths_rainbow+ hs-source-dirs:+ lib+ tests+ other-extensions: TemplateHaskell+ ghc-options: -Wall+ build-depends:+ QuickCheck+ , base >=4.11 && <5+ , bytestring+ , lens+ , terminfo+ , text+ default-language: Haskell2010
+ stack.yaml view
@@ -0,0 +1,32 @@+# For more information, see: https://github.com/commercialhaskell/stack/blob/release/doc/yaml_configuration.md++# Specifies the GHC version and set of packages available (e.g., lts-3.5, nightly-2015-09-21, ghc-7.10.2)+resolver: lts-14.14++# Local packages, usually specified by relative directory name+packages:+- '.'++# Packages to be pulled from upstream that are not in the resolver (e.g., acme-missiles-0.3)+extra-deps: []++# Override default flag values for local packages and extra-deps+flags: {}++# Extra package databases containing global packages+extra-package-dbs: []++# Control whether we use the GHC we find on the path+# system-ghc: true++# Require a specific version of stack, using version ranges+# require-stack-version: -any # Default+# require-stack-version: >= 0.1.4.0++# Override the architecture used by stack, especially useful on Windows+# arch: i386+# arch: x86_64++# Extra directories used by stack for building+# extra-include-dirs: [/path/to/dir]+# extra-lib-dirs: [/path/to/dir]
− sunlight-test.hs
@@ -1,15 +0,0 @@-module Main where--import Test.Sunlight--inputs = TestInputs- { tiDescription = Nothing- , tiCabal = "cabal"- , tiLowest = ("7.4.1", "ghc-7.4.1", "ghc-pkg-7.4.1")- , tiDefault = [ ("7.4.1", "ghc-7.4.1", "ghc-pkg-7.4.1")- , ("7.6.3", "ghc-7.6.3", "ghc-pkg-7.6.3")- , ("7.8.2", "ghc-7.8.2", "ghc-pkg-7.8.2") ]- , tiTest = []- }--main = runTests inputs
+ tests/Rainbow/QuickCheck.hs view
@@ -0,0 +1,106 @@+{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE FlexibleInstances, DeriveGeneric, StandaloneDeriving #-}++-- | QuickCheck instances for all of Rainbow. Currently Rainbow does+-- not use these instances itself; they are only here for+-- cut-and-paste for other libraries that may need them. There is an+-- executable in Rainbow that is built solely to make sure this module+-- compiles without any errors.+--+-- To use these instances, just drop them into your own project+-- somewhere. They are not packaged as a library because there are+-- orphan instances.++module Rainbow.QuickCheck where++import qualified Data.Text as X+import Data.Typeable+import Rainbow.Types+import Test.QuickCheck++instance Arbitrary X.Text where+ arbitrary = fmap X.pack $ listOf genChar+ where+ genChar = elements ['a'..'z']+ shrink = fmap X.pack . shrink . X.unpack++instance CoArbitrary X.Text where+ coarbitrary = coarbitrary . X.unpack++instance (Typeable a, Arbitrary a) => Arbitrary (Color a) where+ arbitrary = Color <$> arbitrary+ shrink = genericShrink++instance CoArbitrary a => CoArbitrary (Color a) where+ coarbitrary (Color a) = coarbitrary a++varInt :: Int -> Gen b -> Gen b+varInt = variant++instance Arbitrary Enum8 where+ arbitrary = elements [E0, E1, E2, E3, E4, E5, E6, E7]+ shrink = genericShrink++instance CoArbitrary Enum8 where+ coarbitrary x = case x of+ E0 -> varInt 0+ E1 -> varInt 1+ E2 -> varInt 2+ E3 -> varInt 3+ E4 -> varInt 4+ E5 -> varInt 5+ E6 -> varInt 6+ E7 -> varInt 7++instance Arbitrary Format where+ arbitrary+ = Format <$> g <*> g <*> g <*> g <*> g <*> g <*> g <*> g+ where+ g = arbitrary+ shrink = genericShrink++instance CoArbitrary Format where+ coarbitrary (Format x0 x1 x2 x3 x4 x5 x6 x7)+ = coarbitrary x0+ . coarbitrary x1+ . coarbitrary x2+ . coarbitrary x3+ . coarbitrary x4+ . coarbitrary x5+ . coarbitrary x6+ . coarbitrary x7++instance (Arbitrary a, Typeable a) => Arbitrary (Style a) where+ arbitrary = Style <$> arbitrary <*> arbitrary <*> arbitrary+ shrink = genericShrink++instance CoArbitrary a => CoArbitrary (Style a) where+ coarbitrary (Style a b c)+ = coarbitrary a+ . coarbitrary b+ . coarbitrary c++instance Arbitrary Scheme where+ arbitrary = Scheme <$> arbitrary <*> arbitrary+ shrink = genericShrink++instance CoArbitrary Scheme where+ coarbitrary (Scheme a b) = coarbitrary a . coarbitrary b+++instance Arbitrary Chunk where+ arbitrary = Chunk <$> arbitrary <*> arbitrary+ shrink = genericShrink++instance CoArbitrary Chunk where+ coarbitrary (Chunk a b)+ = coarbitrary a+ . coarbitrary b++instance Arbitrary Radiant where+ arbitrary = Radiant <$> arbitrary <*> arbitrary+ shrink = genericShrink++instance CoArbitrary Radiant where+ coarbitrary (Radiant a b) = coarbitrary a . coarbitrary b+
+ tests/rainbow-instances.hs view
@@ -0,0 +1,10 @@+{-# OPTIONS_GHC -fno-warn-unused-imports #-}++-- | This program exists solely to import Rainbow.QuickCheck to make+-- sure it compiles.+module Main where++import Rainbow.QuickCheck++main :: IO ()+main = return ()
+ tests/rainbow-visual.hs view
@@ -0,0 +1,18 @@+{-# LANGUAGE OverloadedStrings #-}+module Main where++import Rainbow+import Data.Function ((&))++main :: IO ()+main = do+ putChunksLn+ [ "Red fore, green back " & fore red & back green+ , "Blue fore, magenta back" & fore blue & back magenta ]+ putChunksLn+ [ "Red, bold fore " & fore red & bold+ , "Red, underlined fore " & fore red & underline+ , "Cyan, italic fore" & fore cyan & italic+ ]+ putChunksLn+ [ "Light grey background on 256-color" & back (color256 254) ]