-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/

-- | Simple ANSI terminal support
--   
--   ANSI terminal support for Haskell: allows cursor movement, screen
--   clearing, color output, showing or hiding the cursor, and changing the
--   title. Works on UNIX and Windows.
@package ansi-terminal
@version 1.1.5

-- | 
Introduction
--   
--   Through this module, this library provides platform-independent
--   support for control character sequences following the 'ANSI' standards
--   (see further below) for terminal software that supports those
--   sequences, running on a Unix-like operating system or on Windows (see
--   further below).
--   
--   The sequences of control characters (also referred to as 'escape'
--   sequences or codes) provide a rich range of functionality for terminal
--   control, which includes:
--   
--   
--   
- Colored text output, with control over foreground, background and
--   (where supported) underlining colors
--   
- Clearing parts of a line or the screen
--   
- Hiding or showing the cursor
--   
- Moving the cursor around
--   
- Reporting the position of the cursor
--   
- Enabling or disabling automatic line wrapping
--   
- Scrolling the screen up or down
--   
- Switching between the Alternate and Normal Screen Buffers
--   
- Clickable hyperlinks to URIs
--   
- Changing the title of the terminal
--   
--   
--   A terminal that supports control character sequences acts on them when
--   they are flushed from the output buffer (with a newline character
--   "\n" or, for the standard output channel, hFlush
--   stdout).
--   
--   
'ANSI' standards
--   
--   The 'ANSI' standards refer to (1) standard ECMA-48 `Control Functions
--   for Coded Character Sets' (5th edition, 1991); (2) extensions in ITU-T
--   Recommendation (previously CCITT Recommendation) T.416 (03/93)
--   'Information Technology – Open Document Architecture (ODA) and
--   Interchange Format: Character Content Architectures` (also published
--   as ISO/IEC International Standard 8613-6); and (3) further extensions
--   used by 'XTerm', a terminal emulator for the X Window System. The
--   escape codes are described in a Wikipedia article and those
--   codes supported on current versions of Windows are descibed in
--   Microsoft's documentation.
--   
--   The whole of the 'ANSI' standards are not supported by this library
--   but most (if not all) of the parts that are popular and well-supported
--   by terminal software are supported (see further below).
--   
--   
Cursor positions
--   
--   The functions moving the cursor to an absolute position are 0-based
--   (the top-left corner is considered to be at row 0 column 0) (see
--   setCursorPosition) and so is getCursorPosition. The
--   'ANSI' standards themselves are 1-based (that is, the top-left corner
--   is considered to be at row 1 column 1) and some functions reporting
--   the position of the cursor are too (see reportCursorPosition).
--   
--   
Windows and control character sequences
--   
--   The native terminal software on Windows has developed over time.
--   Before Windows 10 version 1511 (known as the 'November [2015] Update'
--   or 'Threshold 2') that software did not support control character
--   sequences. From 2018, Microsoft introduced the Windows Pseudo Console
--   ('ConPTY') API and then Windows Terminal, with the objective of
--   replacing most of the Windows Console API with the use of control
--   character sequences and retiring the historical user-interface role of
--   Windows Console Host ('ConHost').
--   
--   Windows Terminal is supported on Windows 10 version 19041.0 or higher
--   and provided with Windows 11. It can be downloaded from the Microsoft
--   Store. Windows Terminal can be set as the default terminal application
--   on Windows 10 (from the 22H2 update) and is the default application on
--   Windows 11 (from the 22H2 update).
--   
--   Despite the above developments, some Windows users may continue to use
--   ConHost. ConHost does not enable the processing of 'ANSI' control
--   characters in output by default. See hNowSupportsANSI for a
--   function that can try to enable such processing.
--   
--   Terminal software other than the native software exists for Windows.
--   One example is the 'mintty' terminal emulator for 'Cygwin', 'MSYS' or
--   'MSYS2', and dervied projects, and for 'WSL' (Windows Subsystem for
--   Linux).
--   
--   GHC's management of input and output (IO) on Windows has also
--   developed over time. If they are supported by the terminal software,
--   some control character sequences cause data to be emitted into the
--   console input stream. For GHC's historical and default IO manager, the
--   function hGetBufNonBlocking in module System.IO does not
--   work on Windows. This has been attributed to the lack of non-blocking
--   primatives in the operating system (see GHC bug report #806.
--   GHC's native IO manager on Windows ('WinIO'), introduced as a preview
--   in GHC 9.0.1, has not yet provided a solution. On Windows, this
--   library uses emulation based on the Windows Console API to try to read
--   data emitted into the console input stream. Functions that use that
--   emulation are not supported on consoles, such as mintty, that are not
--   based on that API.
--   
--   
Function variants provided
--   
--   Every function exported by this module comes in three variants,
--   namely:
--   
--   
--   
- A variant that has an IO () type and doesn't take a
--   Handle (for example, clearScreen :: IO ()). This
--   variant just outputs the `ANSI` command directly to the standard
--   output channel (stdout) and any terminal corresponding to it.
--   Commands issued like this should work as you expect on both Unix-like
--   operating systems and Windows (unless exceptions on Windows are
--   stated).
--   
- An 'h...' variant that has an IO () type but
--   takes a Handle (for example, hClearScreen :: Handle ->
--   IO ()). This variant outputs the `ANSI` command to the supplied
--   handle and any terminal corresponding to it. Commands issued like this
--   should also work as you expect on both Unix-like operating systems and
--   Windows (unless exceptions on Windows are stated).
--   
- A '...Code' variant that has a String type (for
--   example, clearScreenCode :: String). This variant outputs the
--   sequence of control characters as a String, which can be added
--   to any other bit of text before being output. If a high degree of
--   backwards compatability is rewuired, the use of these codes is
--   discouraged because they will not work on legacy versions of Windows
--   where the terminal in use is not ANSI-enabled (see further above). On
--   Windows, where emulation has been necessary, these variants will
--   always output the empty string. That is done so that it is possible to
--   use them portably; for example, coloring console output on the
--   understanding that you will see colors only if you are running on a
--   Unix-like operating system or a version of Windows where emulation has
--   not been necessary. If the control characters are always required, see
--   module System.Console.ANSI.Codes.
--   
--   
--   
Examples of use
--   
--   A simple example is below:
--   
--   
--   module Main where
--   
--   import System.Console.ANSI
--   import System.IO (stdout)
--   
--   -- Set colors and write some text in those colors.
--   main :: IO ()
--   main = do
--     stdoutSupportsANSI <- hNowSupportsANSI stdout
--     if stdoutSupportsANSI
--       then do
--         setSGR [SetColor Foreground Vivid Red]
--         setSGR [SetColor Background Vivid Blue]
--         putStrLn "Red-On-Blue"
--         setSGR [Reset]  -- Reset to default colour scheme
--         putStrLn "Default colors."
--       else
--         putStrLn "Standard output does not support 'ANSI' escape codes."
--   
--   
--   Another example is below:
--   
--   
--   module Main where
--   
--   import System.IO (hFlush, stdout)
--   import System.Console.ANSI
--   
--   main :: IO ()
--   main = do
--     stdoutSupportsANSI <- hNowSupportsANSI stdout
--     if stdoutSupportsANSI
--       then do
--         setSGR [SetColor Foreground Dull Blue]
--         putStr "Enter your name: "
--         setSGR [SetColor Foreground Dull Yellow]
--         hFlush stdout  -- flush the output buffer before getLine
--         name <- getLine
--         setSGR [SetColor Foreground Dull Blue]
--         putStrLn $ "Hello, " ++ name ++ "!"
--         setSGR [Reset]  -- reset to default colour scheme
--       else
--         putStrLn "Standard output does not support 'ANSI' escape codes."
--   
--   
--   For many more examples, see the project's extensive Example.hs
--   file.
module System.Console.ANSI
cursorUp :: Int -> IO ()
cursorDown :: Int -> IO ()
cursorForward :: Int -> IO ()
cursorBackward :: Int -> IO ()
hCursorUp :: Handle -> Int -> IO ()
hCursorDown :: Handle -> Int -> IO ()
hCursorForward :: Handle -> Int -> IO ()
hCursorBackward :: Handle -> Int -> IO ()
cursorUpCode :: Int -> String
cursorDownCode :: Int -> String
cursorForwardCode :: Int -> String
cursorBackwardCode :: Int -> String
cursorUpLine :: Int -> IO ()
cursorDownLine :: Int -> IO ()
hCursorUpLine :: Handle -> Int -> IO ()
hCursorDownLine :: Handle -> Int -> IO ()
cursorUpLineCode :: Int -> String
cursorDownLineCode :: Int -> String

-- | Move the cursor to the specified column. The column numbering is
--   0-based (that is, the left-most column is numbered 0).
setCursorColumn :: Int -> IO ()

-- | Move the cursor to the specified position (row and column). The
--   position is 0-based (that is, the top-left corner is at row 0 column
--   0).
setCursorPosition :: Int -> Int -> IO ()
hSetCursorColumn :: Handle -> Int -> IO ()
hSetCursorPosition :: Handle -> Int -> Int -> IO ()

-- | Code to move the cursor to the specified column. The column numbering
--   is 0-based (that is, the left-most column is numbered 0).
setCursorColumnCode :: Int -> String

-- | Code to move the cursor to the specified position (row and column).
--   The position is 0-based (that is, the top-left corner is at row 0
--   column 0).
setCursorPositionCode :: Int -> Int -> String

-- | Save the cursor position in memory. The only way to access the saved
--   value is with the restoreCursor command.
saveCursor :: IO ()

-- | Restore the cursor position from memory. There will be no value saved
--   in memory until the first use of the saveCursor command.
restoreCursor :: IO ()

-- | Looking for a way to get the cursors position? See
--   getCursorPosition.
--   
--   Emit the cursor position into the console input stream, immediately
--   after being recognised on the output stream, as: ESC [ <cursor
--   row> ; <cursor column> R
--   
--   Note that the information that is emitted is 1-based (the top-left
--   corner is at row 1 column 1) but setCursorColumn and
--   setCursorPosition are 0-based.
--   
--   In isolation of getReportedCursorPosition or
--   getCursorPosition, this function may be of limited use on
--   Windows operating systems because of difficulties in obtaining the
--   data emitted into the console input stream.
reportCursorPosition :: IO ()
hSaveCursor :: Handle -> IO ()
hRestoreCursor :: Handle -> IO ()
hReportCursorPosition :: Handle -> IO ()

saveCursorCode :: String

restoreCursorCode :: String

-- | Code to emit the cursor position into the console input stream,
--   immediately after being recognised on the output stream, as: ESC [
--   <cursor row> ; <cursor column> R
--   
--   Note that the information that is emitted is 1-based (the top-left
--   corner is at row 1 column 1) but setCursorPositionCode is
--   0-based.
--   
--   In isolation of getReportedCursorPosition or
--   getCursorPosition, this function may be of limited use on
--   Windows operating systems because of difficulties in obtaining the
--   data emitted into the console input stream.
reportCursorPositionCode :: String
clearFromCursorToScreenEnd :: IO ()
clearFromCursorToScreenBeginning :: IO ()
clearScreen :: IO ()
clearFromCursorToLineEnd :: IO ()
clearFromCursorToLineBeginning :: IO ()
clearLine :: IO ()
hClearFromCursorToScreenEnd :: Handle -> IO ()
hClearFromCursorToScreenBeginning :: Handle -> IO ()
hClearScreen :: Handle -> IO ()
hClearFromCursorToLineEnd :: Handle -> IO ()
hClearFromCursorToLineBeginning :: Handle -> IO ()
hClearLine :: Handle -> IO ()
clearFromCursorToScreenEndCode :: String
clearFromCursorToScreenBeginningCode :: String
clearScreenCode :: String
clearFromCursorToLineEndCode :: String
clearFromCursorToLineBeginningCode :: String
clearLineCode :: String
enableLineWrap :: IO ()
disableLineWrap :: IO ()
hEnableLineWrap :: Handle -> IO ()
hDisableLineWrap :: Handle -> IO ()
enableLineWrapCode :: String
disableLineWrapCode :: String
scrollPageUp :: Int -> IO ()
scrollPageDown :: Int -> IO ()
hScrollPageUp :: Handle -> Int -> IO ()
hScrollPageDown :: Handle -> Int -> IO ()
scrollPageUpCode :: Int -> String
scrollPageDownCode :: Int -> String

-- | Use the Alternate Screen Buffer. If currently using the Normal Screen
--   Buffer, it will save the cursor position and switch to the Alternate
--   Screen Buffer. It will always clear the Alternate Screen Buffer. The
--   Alternate Screen Buffer has no scroll back facility.
--   
--   It is an application's responsibility to ensure that it switches back
--   to the Normal Screen Buffer if an exception is raised while the
--   Alternate Screen Buffer is being used. For example, by using
--   bracket_:
--   
--   
--   bracket_ useAlternateScreenBuffer useNormalScreenBuffer action
--   
useAlternateScreenBuffer :: IO ()

-- | Use the Normal Screen Buffer. If currently using the Alternate Screen
--   Buffer, it will clear the Alternate Screen Buffer, and switch to the
--   Normal Screen Buffer. It will always restore the saved cursor
--   position.
useNormalScreenBuffer :: IO ()
hUseAlternateScreenBuffer :: Handle -> IO ()
hUseNormalScreenBuffer :: Handle -> IO ()
useAlternateScreenBufferCode :: String
useNormalScreenBufferCode :: String

-- | Looking for a way to get layer colors? See getLayerColor.
--   
--   Emit the layerColor into the console input stream, immediately after
--   being recognised on the output stream, as: ESC ] <Ps> ; rgb:
--   <red> ; <green> ; <blue> <ST> where
--   <Ps> is 10 for Foreground and
--   11 for Background; <red>,
--   <green> and <blue> are the color channel
--   values in hexadecimal (4, 8, 12 and 16 bit values are possible,
--   although 16 bit values are most common); and <ST> is
--   the STRING TERMINATOR (ST). ST depends on the terminal software and
--   may be the BEL character or ESC \ characters.
--   
--   This function may be of limited, or no, use on Windows operating
--   systems because (1) the function is not supported on native terminals
--   and is emulated, but the emulation does not work on Windows Terminal
--   and (2) of difficulties in obtaining the data emitted into the console
--   input stream.
--   
--   Underlining is not supported.
reportLayerColor :: ConsoleLayer -> IO ()
hReportLayerColor :: Handle -> ConsoleLayer -> IO ()

-- | Code to emit the foreground or backgrond layer color into the console
--   input stream, immediately after being recognised on the output stream,
--   as:
--   
--   
--   ESC ] <Ps> ; rgb: <red> ; <green> ; <blue> <ST>
--   
--   
--   where <Ps> is 10 for Foreground and
--   11 for Background; <red>,
--   <green> and <blue> are the color channel
--   values in hexadecimal (4, 8, 12 and 16 bit values are possible,
--   although 16 bit values are most common); and <ST> is
--   the STRING TERMINATOR (ST). ST depends on the terminal software and
--   may be the BEL character or ESC \ characters.
--   
--   This function may be of limited, or no, use on Windows operating
--   systems because (1) the control character sequence is not supported on
--   native terminals (2) of difficulties in obtaining the data emitted
--   into the console input stream. See getReportedLayerColor.
--   
--   Underlining is not supported.
reportLayerColorCode :: ConsoleLayer -> String

-- | Set the Select Graphic Rendition mode
setSGR :: [SGR] -> IO ()
hSetSGR :: Handle -> [SGR] -> IO ()
setSGRCode :: [SGR] -> String
hideCursor :: IO ()
showCursor :: IO ()
hHideCursor :: Handle -> IO ()
hShowCursor :: Handle -> IO ()
hideCursorCode :: String
showCursorCode :: String

-- | Introduce a hyperlink.
hyperlink :: String -> String -> IO ()

-- | Introduce a hyperlink with an identifier for the link. Some terminals
--   support an identifier, so that hyperlinks with the same identifier are
--   treated as connected.
hyperlinkWithId :: String -> String -> String -> IO ()

-- | Introduce a hyperlink with (key, value) parameters. Some terminals
--   support an id parameter key, so that hyperlinks with the same
--   id value are treated as connected.
hyperlinkWithParams :: [(String, String)] -> String -> String -> IO ()
hHyperlink :: Handle -> String -> String -> IO ()
hHyperlinkWithId :: Handle -> String -> String -> String -> IO ()
hHyperlinkWithParams :: Handle -> [(String, String)] -> String -> String -> IO ()

-- | Code to introduce a hyperlink.
hyperlinkCode :: String -> String -> String

-- | Code to introduce a hyperlink with an identifier for the link. Some
--   terminals support an identifier, so that hyperlinks with the same
--   identifier are treated as connected.
hyperlinkWithIdCode :: String -> String -> String -> String

-- | Code to introduce a hyperlink with (key, value) parameters. Some
--   terminals support an id parameter key, so that hyperlinks
--   with the same id value are treated as connected.
hyperlinkWithParamsCode :: [(String, String)] -> String -> String -> String

-- | Set the terminal window title and icon name (that is, the text for the
--   window in the Start bar, or similar).
setTitle :: String -> IO ()
hSetTitle :: Handle -> String -> IO ()

-- | Code to set the terminal window title and the icon name (that is, the
--   text for the window in the Start bar, or similar).
setTitleCode :: String -> String

-- | Use heuristics to determine whether the functions defined in this
--   package will work with a given handle.
--   
--   If the handle is not writable (that is, it cannot manage output - see
--   hIsWritable), then pure False is returned.
--   
--   For Unix-like operating systems, the current implementation checks
--   that: (1) the handle is a terminal; and (2) a TERM
--   environment variable is not set to dumb (which is what the
--   GNU Emacs text editor sets for its integrated terminal).
--   
--   For Windows, the current implementation checks: first that (1) the
--   handle is a terminal, (2) a TERM environment variable is not
--   set to dumb, and (3) the processing of 'ANSI' control
--   characters in output is enabled; and second, as an alternative,
--   whether the handle is connected to a 'mintty' terminal. (That is
--   because the function hIsTerminalDevice is used to check if the
--   handle is a terminal. However, where a non-native Windows terminal
--   (such as 'mintty') is implemented using redirection, that function
--   will not identify a handle to the terminal as a terminal.) If it is
--   not already enabled, this function does *not* enable the processing of
--   'ANSI' control characters in output (see hNowSupportsANSI).
hSupportsANSI :: Handle -> IO Bool

-- | With one exception, equivalent to hSupportsANSI. The exception
--   is that, on Windows only, if a TERM environment variable is
--   not set to dumb and the processing of 'ANSI' control
--   characters in output is not enabled, this function first tries to
--   enable such processing.
hNowSupportsANSI :: Handle -> IO Bool

-- | Some terminals (e.g. Emacs) are not fully ANSI compliant but can
--   support ANSI colors. This can be used in such cases, if colors are all
--   that is needed.
hSupportsANSIColor :: Handle -> IO Bool

-- | Attempts to get the reported cursor position, combining the functions
--   reportCursorPosition, getReportedCursorPosition and
--   cursorPosition. Any position (row, column) is
--   translated to be 0-based (that is, the top-left corner is at (0,
--   0)), consistent with setCursorColumn and
--   setCursorPosition. (Note that the information emitted into the
--   console input stream by reportCursorPosition is 1-based.)
--   Returns Nothing if any data emitted by
--   reportCursorPosition, obtained by
--   getReportedCursorPosition, cannot be parsed by
--   cursorPosition. Uses stdout. If stdout will be
--   redirected, see hGetCursorPosition for a more general function.
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on the Windows' Console
--   API. (Command Prompt and PowerShell are based on the Console API.)
--   
--   This operation may fail with an error if stdin has been
--   redirected.
getCursorPosition :: IO (Maybe (Int, Int))

-- | Attempts to get the reported cursor position, combining the functions
--   hReportCursorPosition (with the specified handle),
--   getReportedCursorPosition and cursorPosition. Any
--   position (row, column) is translated to be 0-based (that is,
--   the top-left corner is at (0, 0)), consistent with
--   hSetCursorColumn and hSetCursorPosition. (Note that the
--   information emitted into the console input stream by
--   hReportCursorPosition is 1-based.) Returns Nothing if
--   any data emitted by hReportCursorPosition, obtained by
--   getReportedCursorPosition, cannot be parsed by
--   cursorPosition.
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on the Windows' Console
--   API. (Command Prompt and PowerShell are based on the Console API.)
--   
--   This operation may fail with an error if stdin has been
--   redirected.
hGetCursorPosition :: Handle -> IO (Maybe (Int, Int))

-- | Attempts to get the reported cursor position data from the console
--   input stream. The function is intended to be called immediately after
--   reportCursorPosition (or related functions) have caused
--   characters to be emitted into the stream.
--   
--   For example, on a Unix-like operating system:
--   
--   
--   -- set no buffering (if 'no buffering' is not already set, the contents of
--   -- the buffer will be discarded, so this needs to be done before the cursor
--   -- positon is emitted)
--   hSetBuffering stdin NoBuffering
--   -- ensure that echoing is off
--   input <- bracket (hGetEcho stdin) (hSetEcho stdin) $ \_ -> do
--     hSetEcho stdin False
--     reportCursorPosition
--     hFlush stdout -- ensure the report cursor position code is sent to the
--                   -- operating system
--     getReportedCursorPosition
--   
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on the Windows' Console
--   API. (Command Prompt and PowerShell are based on the Console API.)
getReportedCursorPosition :: IO String

-- | Parses the characters emitted by reportCursorPosition into the
--   console input stream. Returns the cursor row and column as a tuple.
--   
--   For example, if the characters emitted by reportCursorPosition
--   are in String input then the parser could be applied
--   like this:
--   
--   
--   let result = readP_to_S cursorPosition input
--   case result of
--       [] -> putStrLn $ "Error: could not parse " ++ show input
--       [((row, column), _)] -> putStrLn $ "The cursor was at row " ++ show row
--           ++ " and column" ++ show column ++ "."
--       (_:_) -> putStrLn $ "Error: parse not unique"
--   
cursorPosition :: ReadP (Int, Int)

-- | Attempts to get the current terminal size (height in rows, width in
--   columns).
--   
--   There is no 'ANSI' control character sequence that reports the
--   terminal size. So, it attempts to set the cursor position beyond the
--   bottom right corner of the terminal and then use
--   getCursorPosition to query the console input stream. It works
--   only on terminals that support each step and if data can be emitted to
--   stdin. (Use hIsTerminalDevice to test if stdin is
--   connected to a terminal.) Uses stdout. If stdout will be
--   redirected, see hGetTerminalSize for a more general function.
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on Windows' Console API.
--   (Command Prompt and PowerShell are based on the Console API.)
--   
--   This operation may fail with an error if stdin has been
--   redirected.
--   
--   For a different approach, one that does not use control character
--   sequences and works when stdin is redirected, see the
--   terminal-size package.
getTerminalSize :: IO (Maybe (Int, Int))

-- | Attempts to get the current terminal size (height in rows, width in
--   columns), by writing control character sequences to the specified
--   handle (which will typically be stdout or stderr).
--   
--   There is no 'ANSI' control character sequence that reports the
--   terminal size. So, it attempts to set the cursor position beyond the
--   bottom right corner of the terminal and then use
--   hGetCursorPosition to query the console input stream. It works
--   only on terminals that support each step and if data can be emitted to
--   stdin. (Use hIsTerminalDevice to test if stdin is
--   connected to a terminal.)
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on the Windows' Console
--   API. (Command Prompt and PowerShell are based on the Console API.)
--   
--   This operation may fail with an error if stdin has been
--   redirected.
--   
--   For a different approach, one that does not use control character
--   sequences and works when stdin is redirected, see the
--   terminal-size package.
hGetTerminalSize :: Handle -> IO (Maybe (Int, Int))

-- | Attempts to get the reported layer color, combining the functions
--   reportLayerColor, getReportedLayerColor and
--   layerColor. Any RGB color is scaled to be 16 bits per channel,
--   the most common format reported by terminal software. Returns
--   Nothing if any data emitted by reportLayerColor,
--   obtained by getReportedLayerColor, cannot be parsed by
--   layerColor. Uses stdout. If stdout will be
--   redirected, see hGetLayerColor for a more general function.
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on the Windows' Console
--   API. (Command Prompt and PowerShell are based on the Console API.)
--   This function also relies on emulation that does not work on Windows
--   Terminal.
--   
--   Underlining is not supported.
--   
--   This operation may fail with an error if stdin has been
--   redirected.
getLayerColor :: ConsoleLayer -> IO (Maybe (RGB Word16))

-- | Attempts to get the reported layer color, combining the functions
--   hReportLayerColor, getReportedLayerColor and
--   layerColor. Any RGB color is scaled to be 16 bits per channel,
--   the most common format reported by terminal software. Returns
--   Nothing if any data emitted by hReportLayerColor,
--   obtained by getReportedLayerColor, cannot be parsed by
--   layerColor.
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on the Windows' Console
--   API. (Command Prompt and PowerShell are based on the Console API.)
--   This function also relies on emulation that does not work on Windows
--   Terminal.
--   
--   Underlining is not supported.
--   
--   This operation may fail with an error if stdin has been
--   redirected.
hGetLayerColor :: Handle -> ConsoleLayer -> IO (Maybe (RGB Word16))

-- | Attempts to get the reported layer color data from the console input
--   stream. The function is intended to be called immediately after
--   reportLayerColor (or related functions) have caused characters
--   to be emitted into the stream.
--   
--   For example, on a Unix-like operating system:
--   
--   
--   -- set no buffering (if 'no buffering' is not already set, the contents of
--   -- the buffer will be discarded, so this needs to be done before the cursor
--   -- positon is emitted)
--   hSetBuffering stdin NoBuffering
--   -- ensure that echoing is off
--   input <- bracket (hGetEcho stdin) (hSetEcho stdin) $ \_ -> do
--     hSetEcho stdin False
--     reportLayerColor Foreground
--     hFlush stdout -- ensure the report cursor position code is sent to the
--                   -- operating system
--     getReportedLayerColor Foreground
--   
--   
--   On Windows operating systems, the function is not supported on
--   consoles, such as mintty, that are not based on the Windows' Console
--   API. (Command Prompt and PowerShell are based on the Console API.)
--   
--   Underlining is not supported.
getReportedLayerColor :: ConsoleLayer -> IO String

-- | Parses the characters emitted by reportLayerColor into the
--   console input stream.
--   
--   For example, if the characters emitted by reportLayerColor are
--   in String input then the parser could be applied like
--   this:
--   
--   
--   let result = readP_to_S (layerColor layer) input
--   case result of
--       [] -> putStrLn $ "Error: could not parse " ++ show input
--       [(col, _)] -> putStrLn $ "The color was " ++ show col ++ "."
--       (_:_) -> putStrLn $ "Error: parse not unique"
--   
--   
--   Underlining is not supported.
layerColor :: ConsoleLayer -> ReadP (RGB Word16)

-- | Use heuristics to determine whether a given handle will support 'ANSI'
--   control characters in output. The function is consistent with
--   hNowSupportsANSI.
--   
--   This function is deprecated as, from version 1.0, the package no
--   longer supports legacy versions of Windows that required emulation.

-- | Deprecated: See Haddock documentation and hNowSupportsANSI.
hSupportsANSIWithoutEmulation :: Handle -> IO (Maybe Bool)
