    {-# LANGUAGE CPP                 #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TupleSections       #-}
    {-# LANGUAGE OverloadedStrings   #-}
    {-# LANGUAGE FlexibleContexts    #-}
    {- |
       Module      : Text.Pandoc.App.CommandLineOptions
       Copyright   : Copyright (C) 2006-2024 John MacFarlane
       License     : GNU GPL, version 2 or above

       Maintainer  : John MacFarlane <jgm@berkeley@edu>
       Stability   : alpha
       Portability : portable

    Does a pandoc conversion based on command-line options.
    -}
    module Text.Pandoc.App.CommandLineOptions (
                parseOptions
              , parseOptionsFromArgs
              , handleOptInfo
              , options
              , engines
              , setVariable
              , versionInfo
              ) where
    import Control.Monad.Trans
    import Control.Monad.State.Strict
    import Data.Containers.ListUtils (nubOrd)
    import Data.Aeson (eitherDecode)
    import Data.Aeson.Encode.Pretty (encodePretty', Config(..), keyOrder,
             defConfig, Indent(..), NumberFormat(..))
    import Data.Bifunctor (second)
    import Data.Char (toLower)
    import Data.List (intercalate, sort)
    import qualified Data.List as L
    #ifdef _WINDOWS
    import Data.List (isPrefixOf)
    #endif
    import Data.Maybe (fromMaybe, isJust)
    import Data.Text (Text)
    import Safe (tailDef)
    import Skylighting (Syntax (..), defaultSyntaxMap)
    import System.Console.GetOpt
    import System.Environment (getArgs, getProgName)
    import System.Exit (exitSuccess)
    import System.FilePath
    import System.IO (stdout)
    import Text.DocTemplates (Context (..), ToContext (toVal), Val (..))
    import Text.Pandoc
    import Text.Pandoc.Builder (setMeta)
    import Data.Version (showVersion)
    import Text.Pandoc.App.Opt (Opt (..), LineEnding (..), IpynbOutput (..),
                                DefaultsState (..), applyDefaults,
                                fullDefaultsPath, OptInfo(..))
    import Text.Pandoc.Filter (Filter (..))
    import Text.Pandoc.Highlighting (highlightingStyles, lookupHighlightingStyle)
    import Text.Pandoc.Scripting (ScriptingEngine (..), customTemplate)
    import Text.Pandoc.Shared (safeStrRead)
    import Text.Printf
    import qualified Control.Exception as E
    import Control.Monad.Except (ExceptT(..), runExceptT, throwError)
    import qualified Data.ByteString as BS
    import qualified Data.ByteString.Lazy as B
    import qualified Data.Map as M
    import qualified Data.Set as Set
    import qualified Data.Text as T
    import qualified Text.Pandoc.UTF8 as UTF8

    parseOptions :: [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
                 -> Opt -> IO (Either OptInfo Opt)
    parseOptions :: [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    -> Opt -> IO (Either OptInfo Opt)
    parseOptions [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options' Opt
    defaults = do
      rawArgs <- IO [String] -> IO [String]
    forall a. IO a -> IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO IO [String]
    getArgs
      prg <- liftIO getProgName
      parseOptionsFromArgs options' defaults prg rawArgs

    parseOptionsFromArgs
      :: [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
      -> Opt -> String -> [String] -> IO (Either OptInfo Opt)
    parseOptionsFromArgs :: [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    -> Opt -> String -> [String] -> IO (Either OptInfo Opt)
    parseOptionsFromArgs [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options' Opt
    defaults String
    prg [String]
    rawArgs = do
      let ([Opt -> ExceptT OptInfo IO Opt]
    actions, [String]
    args, [String]
    unrecognizedOpts, [String]
    errors) =
               ArgOrder (Opt -> ExceptT OptInfo IO Opt)
    -> [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    -> [String]
    -> ([Opt -> ExceptT OptInfo IO Opt], [String], [String], [String])
    forall a.
    ArgOrder a
    -> [OptDescr a] -> [String] -> ([a], [String], [String], [String])
    getOpt' ArgOrder (Opt -> ExceptT OptInfo IO Opt)
    forall a. ArgOrder a
    Permute [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options' ([String] -> [String]
    preprocessArgs [String]
    rawArgs)

      let unknownOptionErrors :: [String]
    unknownOptionErrors =
           (String -> [String] -> [String])
    -> [String] -> [String] -> [String]
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (String -> [String] -> [String]
    handleUnrecognizedOption (String -> [String] -> [String])
    -> (String -> String) -> String -> [String] -> [String]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> Bool) -> String -> String
    forall a. (a -> Bool) -> [a] -> [a]
    takeWhile (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Char
    '=')) []
           [String]
    unrecognizedOpts

      let mbArgs :: Maybe [String]
    mbArgs = case [String]
    args of
                     [] -> Maybe [String]
    forall a. Maybe a
    Nothing
                     [String]
    xs -> [String] -> Maybe [String]
    forall a. a -> Maybe a
    Just [String]
    xs

      let adjustOpts :: Opt -> Opt
    adjustOpts Opt
    opts =
               Opt
    opts{ optInputFiles =
                       map normalizePath <$> (optInputFiles opts <> mbArgs)
                   , optStandalone = -- certain other options imply standalone
                       optStandalone opts ||
                         isJust (optTemplate opts) ||
                         optSelfContained opts ||
                         not (null (optIncludeInHeader opts)) ||
                         not (null (optIncludeBeforeBody opts)) ||
                         not (null (optIncludeAfterBody opts)) }

      if ([String] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [String]
    errors Bool -> Bool -> Bool
    && [String] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [String]
    unknownOptionErrors)
         then -- thread option data structure through all supplied option actions
           ExceptT OptInfo IO Opt -> IO (Either OptInfo Opt)
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT (ExceptT OptInfo IO Opt -> IO (Either OptInfo Opt))
    -> ExceptT OptInfo IO Opt -> IO (Either OptInfo Opt)
    forall a b. (a -> b) -> a -> b
    $ Opt -> Opt
    adjustOpts (Opt -> Opt) -> ExceptT OptInfo IO Opt -> ExceptT OptInfo IO Opt
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((ExceptT OptInfo IO Opt
     -> (Opt -> ExceptT OptInfo IO Opt) -> ExceptT OptInfo IO Opt)
    -> ExceptT OptInfo IO Opt
    -> [Opt -> ExceptT OptInfo IO Opt]
    -> ExceptT OptInfo IO Opt
    forall b a. (b -> a -> b) -> b -> [a] -> b
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    L.foldl' ExceptT OptInfo IO Opt
    -> (Opt -> ExceptT OptInfo IO Opt) -> ExceptT OptInfo IO Opt
    forall a b.
    ExceptT OptInfo IO a
    -> (a -> ExceptT OptInfo IO b) -> ExceptT OptInfo IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    (>>=) (Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    defaults) [Opt -> ExceptT OptInfo IO Opt]
    actions)
         else Either OptInfo Opt -> IO (Either OptInfo Opt)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Either OptInfo Opt -> IO (Either OptInfo Opt))
    -> Either OptInfo Opt -> IO (Either OptInfo Opt)
    forall a b. (a -> b) -> a -> b
    $ OptInfo -> Either OptInfo Opt
    forall a b. a -> Either a b
    Left (OptInfo -> Either OptInfo Opt) -> OptInfo -> Either OptInfo Opt
    forall a b. (a -> b) -> a -> b
    $ PandocError -> OptInfo
    OptError (PandocError -> OptInfo) -> PandocError -> OptInfo
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $
                 [String] -> String
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat [String]
    errors String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ [String] -> String
    unlines [String]
    unknownOptionErrors String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++
                 (String
    "Try " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    prg String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    " --help for more information.")

    -- | React to an 'OptInfo' by printing the requested information
    -- and exiting or (if there was a parsing error) raising an error.
    handleOptInfo :: ScriptingEngine -> OptInfo -> IO ()
    handleOptInfo :: ScriptingEngine -> OptInfo -> IO ()
    handleOptInfo ScriptingEngine
    engine OptInfo
    info = (PandocError -> IO ()) -> IO () -> IO ()
    forall e a. Exception e => (e -> IO a) -> IO a -> IO a
    E.handle (Either PandocError () -> IO ()
    forall a. Either PandocError a -> IO a
    handleError (Either PandocError () -> IO ())
    -> (PandocError -> Either PandocError ()) -> PandocError -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PandocError -> Either PandocError ()
    forall a b. a -> Either a b
    Left) (IO () -> IO ()) -> IO () -> IO ()
    forall a b. (a -> b) -> a -> b
    $ do
      case OptInfo
    info of
        OptInfo
    BashCompletion -> do
          datafiles <- IO [String]
    getDataFileNames
          tpl <- runIOorExplode $
                   UTF8.toString <$>
                     readDefaultDataFile "bash_completion.tpl"
          let optnames (Option String
    shorts [String]
    longs ArgDescr a
    _ String
    _) =
                (Char -> String) -> String -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (\Char
    c -> [Char
    '-',Char
    c]) String
    shorts [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++
                (String -> String) -> [String] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (String
    "--" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++) [String]
    longs
          let allopts = [String] -> String
    unwords ((OptDescr (Opt -> ExceptT OptInfo IO Opt) -> [String])
    -> [OptDescr (Opt -> ExceptT OptInfo IO Opt)] -> [String]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap OptDescr (Opt -> ExceptT OptInfo IO Opt) -> [String]
    forall {a}. OptDescr a -> [String]
    optnames [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options)
          UTF8.hPutStrLn stdout $ T.pack $ printf tpl allopts
              (T.unpack $ T.unwords readersNames)
              (T.unpack $ T.unwords writersNames)
              (T.unpack $ T.unwords $ map fst highlightingStyles)
              (unwords datafiles)
        OptInfo
    ListInputFormats -> (Text -> IO ()) -> [Text] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Handle -> Text -> IO ()
    UTF8.hPutStrLn Handle
    stdout) [Text]
    readersNames
        OptInfo
    ListOutputFormats -> (Text -> IO ()) -> [Text] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Handle -> Text -> IO ()
    UTF8.hPutStrLn Handle
    stdout) [Text]
    writersNames
        ListExtensions Maybe Text
    mbfmt -> do
          let formatName :: Text
    formatName = Text -> Maybe Text -> Text
    forall a. a -> Maybe a -> a
    fromMaybe Text
    "markdown" Maybe Text
    mbfmt
          let allExts :: Extensions
    allExts = Text -> Extensions
    getAllExtensions Text
    formatName
          if Text
    formatName Text -> [Text] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `notElem`
              (((Text, Reader PandocPure) -> Text)
    -> [(Text, Reader PandocPure)] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text, Reader PandocPure) -> Text
    forall a b. (a, b) -> a
    fst ([(Text, Reader PandocPure)]
    forall (m :: * -> *). PandocMonad m => [(Text, Reader m)]
    readers :: [(Text, Reader PandocPure)]) [Text] -> [Text] -> [Text]
    forall a. [a] -> [a] -> [a]
    ++
               ((Text, Writer PandocPure) -> Text)
    -> [(Text, Writer PandocPure)] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text, Writer PandocPure) -> Text
    forall a b. (a, b) -> a
    fst ([(Text, Writer PandocPure)]
    forall (m :: * -> *). PandocMonad m => [(Text, Writer m)]
    writers :: [(Text, Writer PandocPure)]))
             then PandocError -> IO ()
    forall e a. (HasCallStack, Exception e) => e -> IO a
    E.throwIO (PandocError -> IO ()) -> PandocError -> IO ()
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ Text
    formatName Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <>
                    Text
    " is not a recognized reader or writer format"
             else do
               let defExts :: Extensions
    defExts = Text -> Extensions
    getDefaultExtensions Text
    formatName
               let showExt :: Extension -> String
    showExt Extension
    x =
                    (if Extension -> Extensions -> Bool
    extensionEnabled Extension
    x Extensions
    defExts
                        then Char
    '+'
                        else if Extension -> Extensions -> Bool
    extensionEnabled Extension
    x Extensions
    allExts
                                then Char
    '-'
                                else Char
    ' ') Char -> String -> String
    forall a. a -> [a] -> [a]
    : Int -> String -> String
    forall a. Int -> [a] -> [a]
    drop Int
    4 (Extension -> String
    forall a. Show a => a -> String
    show Extension
    x)
               (Extension -> IO ()) -> [Extension] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Handle -> Text -> IO ()
    UTF8.hPutStrLn Handle
    stdout (Text -> IO ()) -> (Extension -> Text) -> Extension -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Text
    T.pack (String -> Text) -> (Extension -> String) -> Extension -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Extension -> String
    showExt)
                  (Extensions -> [Extension]
    extensionsToList Extensions
    allExts)
        OptInfo
    ListHighlightLanguages -> do
          let langs :: [String]
    langs = [ Text -> String
    T.unpack (Text -> Text
    T.toLower (Syntax -> Text
    sShortname Syntax
    s))
                      | Syntax
    s <- Map Text Syntax -> [Syntax]
    forall k a. Map k a -> [a]
    M.elems Map Text Syntax
    defaultSyntaxMap
                      , Syntax -> Text
    sShortname Syntax
    s Text -> [Text] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `notElem`
                         [String -> Text
    T.pack String
    "Alert", String -> Text
    T.pack String
    "Alert_indent"]
                      ]
          (String -> IO ()) -> [String] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Handle -> Text -> IO ()
    UTF8.hPutStrLn Handle
    stdout (Text -> IO ()) -> (String -> Text) -> String -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Text
    T.pack) ([String] -> [String]
    forall a. Ord a => [a] -> [a]
    sort [String]
    langs)
        OptInfo
    ListHighlightStyles -> do
          ((Text, Style) -> IO ()) -> [(Text, Style)] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Handle -> Text -> IO ()
    UTF8.hPutStrLn Handle
    stdout (Text -> IO ())
    -> ((Text, Style) -> Text) -> (Text, Style) -> IO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Text, Style) -> Text
    forall a b. (a, b) -> a
    fst) [(Text, Style)]
    highlightingStyles
        PrintDefaultTemplate Maybe String
    mbout Text
    fmt -> do
          let write :: Text -> IO ()
    write = (Text -> IO ())
    -> (String -> Text -> IO ()) -> Maybe String -> Text -> IO ()
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (Handle -> Text -> IO ()
    UTF8.hPutStr Handle
    stdout) (String -> Text -> IO ()
    UTF8.writeFile) Maybe String
    mbout

          templ <- PandocIO Text -> IO (Either PandocError Text)
    forall a. PandocIO a -> IO (Either PandocError a)
    runIO (PandocIO Text -> IO (Either PandocError Text))
    -> PandocIO Text -> IO (Either PandocError Text)
    forall a b. (a -> b) -> a -> b
    $
                   case String -> (String, String)
    splitExtension (Text -> String
    T.unpack Text
    fmt) of
                        (String
    _, String
    "") -> do
                          -- built-in format
                          Maybe String -> PandocIO ()
    forall (m :: * -> *). PandocMonad m => Maybe String -> m ()
    setUserDataDir Maybe String
    forall a. Maybe a
    Nothing
                          Text -> PandocIO Text
    forall (m :: * -> *). PandocMonad m => Text -> m Text
    getDefaultTemplate Text
    fmt
                        (String, String)
    _ -> do
                          -- format looks like a filepath => custom writer
                          components <- ScriptingEngine
    -> forall (m :: * -> *).
       (PandocMonad m, MonadIO m) =>
       String -> m (CustomComponents m)
    engineLoadCustom ScriptingEngine
    engine (Text -> String
    T.unpack Text
    fmt)
                          case customTemplate components of
                            Just Text
    t  -> Text -> PandocIO Text
    forall a. a -> PandocIO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Text
    t
                            Maybe Text
    Nothing -> PandocError -> PandocIO Text
    forall a e. (HasCallStack, Exception e) => e -> a
    E.throw (PandocError -> PandocIO Text) -> PandocError -> PandocIO Text
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocNoTemplateError Text
    fmt
          case templ of
               Right Text
    t
                 | Text -> Bool
    T.null Text
    t -> -- e.g. for docx, odt, json:
                     PandocError -> IO ()
    forall e a. (HasCallStack, Exception e) => e -> IO a
    E.throwIO (PandocError -> IO ()) -> PandocError -> IO ()
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocCouldNotFindDataFileError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack
                       (String
    "templates/default." String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Text -> String
    T.unpack Text
    fmt)
                 | Bool
    otherwise -> Text -> IO ()
    write Text
    t
               Left PandocError
    e  -> PandocError -> IO ()
    forall e a. (HasCallStack, Exception e) => e -> IO a
    E.throwIO PandocError
    e
        PrintDefaultDataFile Maybe String
    mbout Text
    f -> do
          let write :: ByteString -> IO ()
    write = (ByteString -> IO ())
    -> (String -> ByteString -> IO ())
    -> Maybe String
    -> ByteString
    -> IO ()
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe ByteString -> IO ()
    BS.putStr String -> ByteString -> IO ()
    BS.writeFile Maybe String
    mbout
          PandocIO () -> IO ()
    forall a. PandocIO a -> IO a
    runIOorExplode (PandocIO () -> IO ()) -> PandocIO () -> IO ()
    forall a b. (a -> b) -> a -> b
    $ String -> PandocIO ByteString
    forall (m :: * -> *). PandocMonad m => String -> m ByteString
    readDefaultDataFile (Text -> String
    T.unpack Text
    f) PandocIO ByteString -> (ByteString -> PandocIO ()) -> PandocIO ()
    forall a b. PandocIO a -> (a -> PandocIO b) -> PandocIO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= IO () -> PandocIO ()
    forall a. IO a -> PandocIO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> PandocIO ())
    -> (ByteString -> IO ()) -> ByteString -> PandocIO ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> IO ()
    write
        PrintHighlightStyle Maybe String
    mbout Text
    styleName -> do
           let write :: ByteString -> IO ()
    write = (ByteString -> IO ())
    -> (String -> ByteString -> IO ())
    -> Maybe String
    -> ByteString
    -> IO ()
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe ByteString -> IO ()
    B.putStr String -> ByteString -> IO ()
    B.writeFile Maybe String
    mbout
           sty <- PandocIO Style -> IO Style
    forall a. PandocIO a -> IO a
    runIOorExplode (PandocIO Style -> IO Style) -> PandocIO Style -> IO Style
    forall a b. (a -> b) -> a -> b
    $ String -> PandocIO Style
    forall (m :: * -> *). PandocMonad m => String -> m Style
    lookupHighlightingStyle (Text -> String
    T.unpack Text
    styleName)
           write $ encodePretty'
             defConfig{confIndent = Spaces 4
                      ,confCompare = keyOrder
                        (map T.pack
                         ["text-color"
                         ,"background-color"
                         ,"line-number-color"
                         ,"line-number-background-color"
                         ,"bold"
                         ,"italic"
                         ,"underline"
                         ,"text-styles"])
                      ,confNumFormat = Generic
                      ,confTrailingNewline = True} sty
        OptInfo
    VersionInfo -> [String] -> Maybe String -> String -> IO ()
    versionInfo [] Maybe String
    forall a. Maybe a
    Nothing String
    ""
        OptInfo
    Help -> do
          prg <- IO String
    getProgName
          mapM_ (UTF8.hPutStrLn stdout . T.stripEnd . T.pack) $
            lines $ usageMessage prg options
        OptError PandocError
    e -> PandocError -> IO ()
    forall e a. (HasCallStack, Exception e) => e -> IO a
    E.throwIO PandocError
    e
      IO ()
    forall a. IO a
    exitSuccess

    -- | Supported LaTeX engines; the first item is used as default engine
    -- when going through LaTeX.
    latexEngines :: [String]
    latexEngines :: [String]
    latexEngines  = [ String
    "pdflatex", String
    "lualatex", String
    "xelatex", String
    "latexmk", String
    "tectonic"
                    , String
    "pdflatex-dev", String
    "lualatex-dev" ]

    -- | Supported HTML PDF engines; the first item is used as default
    -- engine when going through HTML.
    htmlEngines :: [String]
    htmlEngines :: [String]
    htmlEngines  = [String
    "weasyprint", String
    "wkhtmltopdf", String
    "pagedjs-cli", String
    "prince"]

    engines :: [(Text, String)]
    engines :: [(Text, String)]
    engines = (String -> (Text, String)) -> [String] -> [(Text, String)]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text
    "html",) [String]
    htmlEngines [(Text, String)] -> [(Text, String)] -> [(Text, String)]
    forall a. [a] -> [a] -> [a]
    ++
              (String -> (Text, String)) -> [String] -> [(Text, String)]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text
    "html5",) [String]
    htmlEngines [(Text, String)] -> [(Text, String)] -> [(Text, String)]
    forall a. [a] -> [a] -> [a]
    ++
              (String -> (Text, String)) -> [String] -> [(Text, String)]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text
    "latex",) [String]
    latexEngines [(Text, String)] -> [(Text, String)] -> [(Text, String)]
    forall a. [a] -> [a] -> [a]
    ++
              (String -> (Text, String)) -> [String] -> [(Text, String)]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text
    "beamer",) [String]
    latexEngines [(Text, String)] -> [(Text, String)] -> [(Text, String)]
    forall a. [a] -> [a] -> [a]
    ++
              [ (Text
    "ms", String
    "groff")
              , (Text
    "ms", String
    "pdfroff")
              , (Text
    "typst", String
    "typst")
              , (Text
    "context", String
    "context")
              ]

    pdfEngines :: [String]
    pdfEngines :: [String]
    pdfEngines = [String] -> [String]
    forall a. Ord a => [a] -> [a]
    nubOrd ([String] -> [String]) -> [String] -> [String]
    forall a b. (a -> b) -> a -> b
    $ ((Text, String) -> String) -> [(Text, String)] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text, String) -> String
    forall a b. (a, b) -> b
    snd [(Text, String)]
    engines

    -- For motivation see #8956.  We want to allow things like `-si` without
    -- causing the `i` to be parsed as an optional boolean argument of `-s`.
    -- This is for backwards compatibility given the addition of optional
    -- boolean arguments in #8879.
    preprocessArgs :: [String] -> [String]
    preprocessArgs :: [String] -> [String]
    preprocessArgs [] = []
    preprocessArgs (String
    "--":[String]
    xs) = String
    "--" String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    : [String]
    xs -- a bare '--' ends option parsing
    -- note that -strue is interpreted as -strue while
    -- -stmarkdown is interpreted as -s -tmarkdown
    preprocessArgs ((Char
    '-':Char
    c:Char
    d:String
    cs):[String]
    xs)
      | Char -> Bool
    isShortBooleanOpt Char
    c
      , case Char -> Char
    toLower (Char -> Char) -> String -> String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Char
    dChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    cs) of
          String
    "true" -> Bool
    True
          String
    "false" -> Bool
    True
          String
    _ -> Bool
    False
        = (Char
    '-'Char -> String -> String
    forall a. a -> [a] -> [a]
    :Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :Char
    dChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    cs) String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    : [String] -> [String]
    preprocessArgs [String]
    xs
      | Char -> Bool
    isShortBooleanOpt Char
    c
      , Char -> Bool
    isShortOpt Char
    d = String -> [String]
    splitArg (Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :Char
    dChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    cs) [String] -> [String] -> [String]
    forall a. [a] -> [a] -> [a]
    ++ [String] -> [String]
    preprocessArgs [String]
    xs
    preprocessArgs (String
    x:[String]
    xs) = String
    x String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    : [String] -> [String]
    preprocessArgs [String]
    xs

    isShortBooleanOpt :: Char -> Bool
    isShortBooleanOpt :: Char -> Bool
    isShortBooleanOpt = (Char -> Set Char -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` Set Char
    shortBooleanOpts)
     where
      shortBooleanOpts :: Set Char
    shortBooleanOpts =
         String -> Set Char
    forall a. Ord a => [a] -> Set a
    Set.fromList [Char
    c | Option [Char
    c] [String]
    _ (OptArg Maybe String -> Opt -> ExceptT OptInfo IO Opt
    _ String
    "true|false") String
    _ <- [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options]

    isShortOpt :: Char -> Bool
    isShortOpt :: Char -> Bool
    isShortOpt = (Char -> Set Char -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` Set Char
    shortOpts)
     where
      shortOpts :: Set Char
    shortOpts = String -> Set Char
    forall a. Ord a => [a] -> Set a
    Set.fromList (String -> Set Char) -> String -> Set Char
    forall a b. (a -> b) -> a -> b
    $ [String] -> String
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat [String
    cs | Option String
    cs [String]
    _ ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    _ String
    _ <- [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options]

    splitArg :: String -> [String]
    splitArg :: String -> [String]
    splitArg (Char
    c:Char
    d:String
    cs)
      | Char -> Bool
    isShortBooleanOpt Char
    c
      , Char -> Bool
    isShortOpt Char
    d
      = [Char
    '-',Char
    c] String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    : String -> [String]
    splitArg (Char
    dChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    cs)
    splitArg (Char
    c:String
    cs) = [Char
    '-'Char -> String -> String
    forall a. a -> [a] -> [a]
    :Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    cs]
    splitArg [] = []

    -- | A list of functions, each transforming the options data structure
    --   in response to a command-line option.
    options :: [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options :: [OptDescr (Opt -> ExceptT OptInfo IO Opt)]
    options =
        [ String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "fr" [String
    "from",String
    "read"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optFrom = Just $ T.pack arg })
                      String
    "FORMAT")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "tw" [String
    "to",String
    "write"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optTo = Just $ T.pack arg })
                      String
    "FORMAT")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "o" [String
    "output"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optOutputFile =
                                                 Just (normalizePath arg) })
                      String
    "FILE")
                     String
    "" -- "Name of output file"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "data-dir"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optDataDir =
                                      Just (normalizePath arg) })
                     String
    "DIRECTORY") -- "Directory containing pandoc data files."
                    String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "M" [String
    "metadata"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         let (String
    key, String
    val) = String -> (String, String)
    splitField String
    arg
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optMetadata = addMeta key val $
                                                     optMetadata opt })
                      String
    "KEY[=VALUE]")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "metadata-file"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optMetadataFiles =
                          optMetadataFiles opt ++ [normalizePath arg] })
                      String
    "FILE")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "d" [String
    "defaults"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         res <- IO (Either PandocError Opt)
    -> ExceptT OptInfo IO (Either PandocError Opt)
    forall a. IO a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Either PandocError Opt)
     -> ExceptT OptInfo IO (Either PandocError Opt))
    -> IO (Either PandocError Opt)
    -> ExceptT OptInfo IO (Either PandocError Opt)
    forall a b. (a -> b) -> a -> b
    $ PandocIO Opt -> IO (Either PandocError Opt)
    forall a. PandocIO a -> IO (Either PandocError a)
    runIO (PandocIO Opt -> IO (Either PandocError Opt))
    -> PandocIO Opt -> IO (Either PandocError Opt)
    forall a b. (a -> b) -> a -> b
    $ do
                           let defsState :: DefaultsState
    defsState =
                                 DefaultsState { curDefaults :: Maybe String
    curDefaults = Maybe String
    forall a. Maybe a
    Nothing,
                                                 inheritanceGraph :: [[String]]
    inheritanceGraph = [] }
                           fp <- Maybe String -> String -> PandocIO String
    forall (m :: * -> *).
    (PandocMonad m, MonadIO m) =>
    Maybe String -> String -> m String
    fullDefaultsPath (Opt -> Maybe String
    optDataDir Opt
    opt) String
    arg
                           evalStateT (applyDefaults opt fp) defsState
                         case res of
                           Left PandocError
    e -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError PandocError
    e
                           Right Opt
    x -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    x
                      )
                      String
    "FILE")
                    String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "file-scope"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--file-scope" Maybe String
    arg
                            return opt { optFileScope = boolValue })
                      String
    "true|false")
                     String
    "" -- "Parse input files before combining"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "sandbox"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--sandbox" Maybe String
    arg
                            return opt { optSandbox = boolValue })
                      String
    "true|false")
                     String
    ""

         , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "s" [String
    "standalone"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--standalone/-s" Maybe String
    arg
                            return opt { optStandalone = boolValue })
                      String
    "true|false")
                     String
    "" -- "Include needed header and footer on output"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "template"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optTemplate = Just (normalizePath arg) })
                      String
    "FILE")
                     String
    "" -- "Use custom template"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "V" [String
    "variable"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         let (String
    key, String
    val) = String -> (String, String)
    splitField String
    arg
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optVariables =
                                      setVariable (T.pack key) (T.pack val) $
                                        optVariables opt })
                      String
    "KEY[=VALUE]")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "variable-json"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         let (String
    key, String
    json) = String -> (String, String)
    splitField String
    arg
                         case ByteString -> Either String (Val Text)
    forall a. FromJSON a => ByteString -> Either String a
    eitherDecode (ByteString -> ByteString
    B.fromStrict (ByteString -> ByteString)
    -> (String -> ByteString) -> String -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ByteString
    UTF8.fromString (String -> ByteString) -> String -> ByteString
    forall a b. (a -> b) -> a -> b
    $ String
    json) of
                           Right (Val Text
    val :: Val Text) ->
                             Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optVariables =
                                          let Context m = optVariables opt
                                           in Context $ M.insert (T.pack key) val m }
                               -- note that this replaces any existing value, which
                               -- is different from what --variable does
                           Left String
    err'  -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $
                              Text
    "Could not parse '" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> String -> Text
    T.pack String
    json Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    "' as JSON:\n" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <>
                               String -> Text
    T.pack String
    err')
                      String
    "KEY[:JSON]")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "wrap"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                        case String
    arg of
                          String
    "auto" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optWrap = WrapAuto }
                          String
    "none" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optWrap = WrapNone }
                          String
    "preserve" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optWrap = WrapPreserve }
                          String
    _      -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                     Text
    "--wrap must be auto, none, or preserve")
                     String
    "auto|none|preserve")
                     String
    "" -- "Option for wrapping text in output"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "ascii"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--ascii" Maybe String
    arg
                            return opt { optAscii = boolValue })
                      String
    "true|false")
                     String
    ""  -- "Prefer ASCII output"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "toc", String
    "table-of-contents"]
                    ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                     (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--toc/--table-of-contents" Maybe String
    arg
                            return opt { optTableOfContents = boolValue })
                     String
    "true|false")
                   String
    "" -- "Include table of contents"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "toc-depth"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    1 Bool -> Bool -> Bool
    && Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    6 ->
                                        Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optTOCDepth = t }
                               Maybe Int
    _ -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                    Text
    "Argument of --toc-depth must be a number 1-6")
                     String
    "NUMBER")
                     String
    "" -- "Number of levels to include in TOC"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "lof", String
    "list-of-figures"]
                    ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                     (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--lof/--list-of-figures" Maybe String
    arg
                            return opt { optListOfFigures = boolValue })
                     String
    "true|false")
                   String
    "" -- "Include list of figures"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "lot", String
    "list-of-tables"]
                    ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                     (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--lot/--list-of-tables" Maybe String
    arg
                            return opt { optListOfTables = boolValue })
                     String
    "true|false")
                   String
    "" -- "Include list of tables"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "N" [String
    "number-sections"]
                      ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                       (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--number-sections/-N" Maybe String
    arg
                            return opt { optNumberSections = boolValue })
                      String
    "true|false")
                     String
    "" -- "Number sections"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "number-offset"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String -> Maybe [Int]
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead (String
    "[" String -> String -> String
    forall a. Semigroup a => a -> a -> a
    <> String
    arg String -> String -> String
    forall a. Semigroup a => a -> a -> a
    <> String
    "]") of
                               Just [Int]
    ns -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optNumberOffset = ns,
                                                       optNumberSections = True }
                               Maybe [Int]
    _      -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                           Text
    "could not parse argument of --number-offset")
                     String
    "NUMBERS")
                     String
    "" -- "Starting number for sections, subsections, etc."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "top-level-division"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String
    arg of
                            String
    "section" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optTopLevelDivision =
                                            TopLevelSection }
                            String
    "chapter" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optTopLevelDivision =
                                            TopLevelChapter }
                            String
    "part"    -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optTopLevelDivision =
                                            TopLevelPart }
                            String
    "default" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optTopLevelDivision =
                                            TopLevelDefault }
                            String
    _ -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $
                                    Text
    "Argument of --top-level division must be " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <>
                                    Text
    "section,  chapter, part, or default" )
                       String
    "section|chapter|part")
                     String
    "" -- "Use top-level division type in LaTeX, ConTeXt, DocBook"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "extract-media"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                        Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optExtractMedia =
                                      Just (normalizePath arg) })
                      String
    "PATH")
                     String
    "" -- "Directory to which to extract embedded media"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "resource-path"]
                    ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optResourcePath =
                                       splitSearchPath arg ++
                                        optResourcePath opt })
                       String
    "SEARCHPATH")
                      String
    "" -- "Paths to search for images and other resources"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "H" [String
    "include-in-header"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optIncludeInHeader =
                                                 optIncludeInHeader opt ++
                                                 [normalizePath arg] })
                      String
    "FILE")
                     String
    "" -- "File to include at end of header (implies -s)"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "B" [String
    "include-before-body"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optIncludeBeforeBody =
                                                optIncludeBeforeBody opt ++
                                                [normalizePath arg] })
                      String
    "FILE")
                     String
    "" -- "File to include before document body"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "A" [String
    "include-after-body"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optIncludeAfterBody =
                                                optIncludeAfterBody opt ++
                                                [normalizePath arg] })
                      String
    "FILE")
                     String
    "" -- "File to include after document body"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "no-highlight"]
                    ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                     (\Opt
    opt -> do
                         String -> String -> ExceptT OptInfo IO ()
    deprecatedOption String
    "--no-highlight"
                           String
    "Use --syntax-highlighting=none instead."
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optSyntaxHighlighting = NoHighlightingString }))
                     String
    "" -- "Don't highlight source code"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "highlight-style"]
                    ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                     (\String
    arg Opt
    opt -> do
                         String -> String -> ExceptT OptInfo IO ()
    deprecatedOption String
    "--highlight-style"
                           String
    "Use --syntax-highlighting instead."
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optSyntaxHighlighting =
                                     T.pack $ normalizePath arg })
                     String
    "STYLE|FILE")
                     String
    "" -- "Style for highlighted code"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "syntax-definition"]
                    ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                     (\String
    arg Opt
    opt ->
                       Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optSyntaxDefinitions = normalizePath arg :
                                    optSyntaxDefinitions opt })
                     String
    "FILE")
                    String
    "" -- "Syntax definition (xml) file"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "syntax-highlighting"]
                    ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                     (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optSyntaxHighlighting =
                                     T.pack $ normalizePath arg })
                     String
    "none|default|idiomatic|<stylename>|<themepath>")
                     String
    "" -- "syntax highlighting method for code"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "dpi"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                        case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                             Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0 -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optDpi = t }
                             Maybe Int
    _              -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                            Text
    "Argument of --dpi must be a number greater than 0")
                      String
    "NUMBER")
                     String
    "" -- "Dpi (default 96)"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "eol"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                        case Char -> Char
    toLower (Char -> Char) -> String -> String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> String
    arg of
                          String
    "crlf"   -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optEol = CRLF }
                          String
    "lf"     -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optEol = LF }
                          String
    "native" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optEol = Native }
                          -- mac-syntax (cr) is not supported in ghc-base.
                          String
    _      -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                    Text
    "Argument of --eol must be crlf, lf, or native")
                      String
    "crlf|lf|native")
                     String
    "" -- "EOL (default OS-dependent)"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "columns"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0 -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optColumns = t }
                               Maybe Int
    _              -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                       Text
    "Argument of --columns must be a number greater than 0")
                     String
    "NUMBER")
                     String
    "" -- "Length of line in characters"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "p" [String
    "preserve-tabs"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--preserve-tabs/-p" Maybe String
    arg
                            return opt { optPreserveTabs = boolValue })
                      String
    "true|false")
                     String
    "" -- "Preserve tabs instead of converting to spaces"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "tab-stop"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0 -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optTabStop = t }
                               Maybe Int
    _              -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                      Text
    "Argument of --tab-stop must be a number greater than 0")
                      String
    "NUMBER")
                     String
    "" -- "Tab stop (default 4)"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "pdf-engine"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         let b :: String
    b = String -> String
    takeBaseName String
    arg
                         if String
    b String -> [String] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [String]
    pdfEngines
                            then Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optPdfEngine = Just arg }
                            else PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $
                                  Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $
                                  String
    "Argument of --pdf-engine must be one of\n"
                                   String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ (String -> String) -> [String] -> String
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap (\String
    e -> String
    "\t" String -> String -> String
    forall a. Semigroup a => a -> a -> a
    <> String
    e String -> String -> String
    forall a. Semigroup a => a -> a -> a
    <> String
    "\n") [String]
    pdfEngines)
                      String
    "PROGRAM")
                     String
    "" -- "Name of program to use in generating PDF"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "pdf-engine-opt"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                          let oldArgs :: [String]
    oldArgs = Opt -> [String]
    optPdfEngineOpts Opt
    opt
                          Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optPdfEngineOpts = oldArgs ++ [arg]})
                      String
    "STRING")
                     String
    "" -- "Flags to pass to the PDF-engine, all instances of this option are accumulated and used"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "reference-doc"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                        Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optReferenceDoc = Just $ normalizePath arg })
                      String
    "FILE")
                     String
    "" -- "Path of custom reference doc"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "self-contained"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            String -> String -> ExceptT OptInfo IO ()
    deprecatedOption String
    "--self-contained" String
    "use --embed-resources --standalone"
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--self-contained" Maybe String
    arg
                            return opt { optSelfContained = boolValue })
                        String
    "true|false")
                     String
    "" -- "Make slide shows include all the needed js and css (deprecated)"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "embed-resources"] -- maybe True (\argStr -> argStr == "true") arg
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--embed-resources" Maybe String
    arg
                            return opt { optEmbedResources =  boolValue })
                      String
    "true|false")
                     String
    "" -- "Make slide shows include all the needed js and css"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "link-images"] -- maybe True (\argStr -> argStr == "true") arg
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--link-images" Maybe String
    arg
                            return opt { optLinkImages =  boolValue })
                      String
    "true|false")
                     String
    "" -- "Link images in ODT rather than embedding them"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "request-header"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         let (String
    key, String
    val) = String -> (String, String)
    splitField String
    arg
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optRequestHeaders =
                           (T.pack key, T.pack val) : optRequestHeaders opt })
                      String
    "NAME=VALUE")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "no-check-certificate"]
                    ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                     (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--no-check-certificate" Maybe String
    arg
                            return opt { optNoCheckCertificate = boolValue })
                     String
    "true|false")
                    String
    "" -- "Disable certificate validation"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "abbreviations"]
                    ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                     (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optAbbreviations =
                                                Just $ normalizePath arg })
                    String
    "FILE")
                    String
    "" -- "Specify file for custom abbreviations"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "typst-input"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         let (String
    key, String
    val) = String -> (String, String)
    splitField String
    arg
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optTypstInputs = (T.pack key, T.pack val) : optTypstInputs opt })
                      String
    "KEY=VALUE")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "indented-code-classes"]
                      ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                       (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optIndentedCodeClasses = T.words $
                                                 T.map (\Char
    c -> if Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    ',' then Char
    ' ' else Char
    c) $
                                                 T.pack arg })
                       String
    "STRING")
                      String
    "" -- "Classes (whitespace- or comma-separated) to use for indented code-blocks"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "default-image-extension"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optDefaultImageExtension = T.pack arg })
                       String
    "extension")
                      String
    "" -- "Default extension for extensionless images"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "F" [String
    "filter"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optFilters =
                          optFilters opt ++ [JSONFilter (normalizePath arg)] })
                      String
    "PROGRAM")
                     String
    "" -- "External JSON filter"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "L" [String
    "lua-filter"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optFilters =
                          optFilters opt ++ [LuaFilter (normalizePath arg)] })
                      String
    "SCRIPTPATH")
                     String
    "" -- "Lua filter"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "shift-heading-level-by"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t ->
                                   Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optShiftHeadingLevelBy = t }
                               Maybe Int
    _              -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                                   Text
    "Argument of --shift-heading-level-by must be an integer")
                      String
    "NUMBER")
                     String
    "" -- "Shift heading level"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "base-header-level"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                          String -> String -> ExceptT OptInfo IO ()
    deprecatedOption String
    "--base-header-level"
                            String
    "Use --shift-heading-level-by instead."
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    0 Bool -> Bool -> Bool
    && Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    6 ->
                                   Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optShiftHeadingLevelBy = t - 1 }
                               Maybe Int
    _              -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                                   Text
    "Argument of --base-header-level must be 1-5")
                      String
    "NUMBER")
                     String
    "" -- "Headers base level"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "track-changes"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         action <- case String
    arg of
                                String
    "accept" -> TrackChanges -> ExceptT OptInfo IO TrackChanges
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return TrackChanges
    AcceptChanges
                                String
    "reject" -> TrackChanges -> ExceptT OptInfo IO TrackChanges
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return TrackChanges
    RejectChanges
                                String
    "all"    -> TrackChanges -> ExceptT OptInfo IO TrackChanges
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return TrackChanges
    AllChanges
                                String
    _        -> PandocError -> ExceptT OptInfo IO TrackChanges
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO TrackChanges)
    -> PandocError -> ExceptT OptInfo IO TrackChanges
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack
                                   String
    "Argument of --track-changes must be accept, reject, or all"
                         return opt { optTrackChanges = action })
                      String
    "accept|reject|all")
                     String
    "" -- "Accepting or reject MS Word track-changes.""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "strip-comments"]
                    ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                     (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--strip-comments" Maybe String
    arg
                            return opt { optStripComments = boolValue })
                     String
    "true|false")
                   String
    "" -- "Strip HTML comments"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "reference-links"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--reference-links" Maybe String
    arg
                            return opt { optReferenceLinks = boolValue })
                      String
    "true|false")
                     String
    "" -- "Use reference links in parsing HTML"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "reference-location"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         action <- case String
    arg of
                                String
    "block"    -> ReferenceLocation -> ExceptT OptInfo IO ReferenceLocation
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ReferenceLocation
    EndOfBlock
                                String
    "section"  -> ReferenceLocation -> ExceptT OptInfo IO ReferenceLocation
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ReferenceLocation
    EndOfSection
                                String
    "document" -> ReferenceLocation -> ExceptT OptInfo IO ReferenceLocation
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ReferenceLocation
    EndOfDocument
                                String
    _        -> PandocError -> ExceptT OptInfo IO ReferenceLocation
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO ReferenceLocation)
    -> PandocError -> ExceptT OptInfo IO ReferenceLocation
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack
                                   String
    "Argument of --reference-location must be block, section, or document"
                         return opt { optReferenceLocation = action })
                      String
    "block|section|document")
                     String
    "" -- "Specify where reference links and footnotes go"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "figure-caption-position"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         pos <- case String
    arg of
                                String
    "above"  -> CaptionPosition -> ExceptT OptInfo IO CaptionPosition
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CaptionPosition
    CaptionAbove
                                String
    "below"  -> CaptionPosition -> ExceptT OptInfo IO CaptionPosition
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CaptionPosition
    CaptionBelow
                                String
    _        -> PandocError -> ExceptT OptInfo IO CaptionPosition
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO CaptionPosition)
    -> PandocError -> ExceptT OptInfo IO CaptionPosition
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack
                                   String
    "Argument of --figure-caption-position must be above or below"
                         return opt { optFigureCaptionPosition = pos })
                      String
    "above|below")
                     String
    "" -- "Specify where figure captions go"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "table-caption-position"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         pos <- case String
    arg of
                                String
    "above"  -> CaptionPosition -> ExceptT OptInfo IO CaptionPosition
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CaptionPosition
    CaptionAbove
                                String
    "below"  -> CaptionPosition -> ExceptT OptInfo IO CaptionPosition
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CaptionPosition
    CaptionBelow
                                String
    _        -> PandocError -> ExceptT OptInfo IO CaptionPosition
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO CaptionPosition)
    -> PandocError -> ExceptT OptInfo IO CaptionPosition
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack
                                   String
    "Argument of --table-caption-position must be above or below"
                         return opt { optTableCaptionPosition = pos })
                      String
    "above|below")
                     String
    "" -- "Specify where table captions go"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "markdown-headings"]
                      ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                        (\String
    arg Opt
    opt -> do
                          headingFormat <- case String
    arg of
                            String
    "setext" -> Bool -> ExceptT OptInfo IO Bool
    forall a. a -> ExceptT OptInfo IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    True
                            String
    "atx" -> Bool -> ExceptT OptInfo IO Bool
    forall a. a -> ExceptT OptInfo IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    False
                            String
    _ -> PandocError -> ExceptT OptInfo IO Bool
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Bool)
    -> PandocError -> ExceptT OptInfo IO Bool
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack
                              String
    "Argument of --markdown-headings must be setext or atx"
                          pure opt { optSetextHeaders = headingFormat }
                        )
                      String
    "setext|atx")
                      String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "list-tables"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--list-tables" Maybe String
    arg
                            return opt { optListTables = boolValue })
                      String
    "true|false")
                     String
    "" -- "Use list tables for RST"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "listings"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                          String -> String -> ExceptT OptInfo IO ()
    deprecatedOption String
    "--listings"
                            String
    "Use --syntax-highlighting=idiomatic instead."
                          boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--listings" Maybe String
    arg
                          return $
                            if boolValue
                            then opt { optSyntaxHighlighting =
                                       IdiomaticHighlightingString }
                            else opt)
                      String
    "true|false")
                     String
    "" -- "Use listings package for LaTeX code blocks"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "i" [String
    "incremental"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--incremental/-i" Maybe String
    arg
                            return opt { optIncremental = boolValue })
                      String
    "true|false")
                     String
    "" -- "Make list items display incrementally in Slidy/Slideous/S5"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "slide-level"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    0 Bool -> Bool -> Bool
    && Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    6 ->
                                        Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optSlideLevel = Just t }
                               Maybe Int
    _      -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                        Text
    "Argument of --slide-level must be a number between 0 and 6")
                     String
    "NUMBER")
                     String
    "" -- "Force header level for slides"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "section-divs"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--section-divs" Maybe String
    arg
                            return opt { optSectionDivs = boolValue })
                      String
    "true|false")
                     String
    "" -- "Put sections in div tags in HTML"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "html-q-tags"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--html-q-tags" Maybe String
    arg
                            return opt { optHtmlQTags = boolValue })
                      String
    "true|false")
                     String
    "" -- "Use <q> tags for quotes in HTML"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "email-obfuscation"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                         method <- case String
    arg of
                                String
    "references" -> ObfuscationMethod -> ExceptT OptInfo IO ObfuscationMethod
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ObfuscationMethod
    ReferenceObfuscation
                                String
    "javascript" -> ObfuscationMethod -> ExceptT OptInfo IO ObfuscationMethod
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ObfuscationMethod
    JavascriptObfuscation
                                String
    "none"       -> ObfuscationMethod -> ExceptT OptInfo IO ObfuscationMethod
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ObfuscationMethod
    NoObfuscation
                                String
    _            -> PandocError -> ExceptT OptInfo IO ObfuscationMethod
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO ObfuscationMethod)
    -> PandocError -> ExceptT OptInfo IO ObfuscationMethod
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack
                                   String
    "Argument of --email-obfuscation must be references, javascript, or none"
                         return opt { optEmailObfuscation = method })
                      String
    "none|javascript|references")
                     String
    "" -- "Method for obfuscating email in HTML"

         , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "id-prefix"]
                      ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                       (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optIdentifierPrefix = T.pack arg })
                       String
    "STRING")
                      String
    "" -- "Prefix to add to automatically generated HTML identifiers"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "T" [String
    "title-prefix"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                        Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt {
                           optVariables =
                             setVariable "title-prefix" (T.pack arg) $
                               optVariables opt,
                           optStandalone = True })
                      String
    "STRING")
                     String
    "" -- "String to prefix to HTML window title"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "c" [String
    "css"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optCss = optCss opt ++ [arg] })
                      -- add new link to end, so it is included in proper order
                      String
    "URL")
                     String
    "" -- "Link to CSS style sheet"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "epub-subdirectory"]
                 ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optEpubSubdirectory = arg })
                      String
    "DIRNAME")
                     String
    "" -- "Name of subdirectory for epub content in OCF container"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "epub-cover-image"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optVariables =
                           setVariable "epub-cover-image"
                             (T.pack $ normalizePath arg) $
                             optVariables opt })
                      String
    "FILE")
                     String
    "" -- "Path of epub cover image"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "epub-title-page"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                         boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--epub-title-page" Maybe String
    arg
                         return opt{ optEpubTitlePage = boolValue })
                     String
    "true|false")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "epub-metadata"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optEpubMetadata = Just $
                                                 normalizePath arg })
                      String
    "FILE")
                     String
    "" -- "Path of epub metadata file"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "epub-embed-font"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optEpubFonts = normalizePath arg :
                                                    optEpubFonts opt })
                      String
    "FILE")
                     String
    "" -- "Directory of fonts to embed"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "split-level"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    1 Bool -> Bool -> Bool
    && Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    6 ->
                                        Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optSplitLevel = t }
                               Maybe Int
    _      -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                        Text
    "Argument of --split-level must be a number between 1 and 6")
                     String
    "NUMBER")
                     String
    "" -- "Header level at which to split documents in chunked HTML or EPUB"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "chunk-template"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optChunkTemplate = Just (T.pack arg) })
                     String
    "PATHTEMPLATE")
                     String
    "" -- "Template for file paths in chunkedhtml"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "epub-chapter-level"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                          String -> String -> ExceptT OptInfo IO ()
    deprecatedOption String
    "--epub-chapter-level"
                                           String
    "use --split-level"
                          case String -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
    safeStrRead String
    arg of
                               Just Int
    t | Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    1 Bool -> Bool -> Bool
    && Int
    t Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    6 ->
                                        Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optSplitLevel = t }
                               Maybe Int
    _      -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                        Text
    "Argument of --epub-chapter-level must be a number between 1 and 6")
                     String
    "NUMBER")
                     String
    "" -- "Header level at which to split documents in chunked HTML or EPUB"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "ipynb-output"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                        case String
    arg of
                          String
    "all" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optIpynbOutput = IpynbOutputAll }
                          String
    "best" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optIpynbOutput = IpynbOutputBest }
                          String
    "none" -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optIpynbOutput = IpynbOutputNone }
                          String
    _ -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                 Text
    "Argument of --ipynb-output must be all, none, or best")
                     String
    "all|none|best")
                     String
    "" -- "Starting number for sections, subsections, etc."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "C" [String
    "citeproc"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                      (\Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optFilters =
                          optFilters opt ++ [CiteprocFilter] }))
                     String
    "" -- "Process citations"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "bibliography"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optMetadata =
                                                addMeta "bibliography"
                                                  (normalizePath arg) $
                                                  optMetadata opt })
                       String
    "FILE")
                     String
    ""

         , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "csl"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> do
                        case Text -> Meta -> Maybe MetaValue
    lookupMeta (String -> Text
    T.pack String
    "csl") (Meta -> Maybe MetaValue) -> Meta -> Maybe MetaValue
    forall a b. (a -> b) -> a -> b
    $ Opt -> Meta
    optMetadata Opt
    opt of
                          Just MetaValue
    _ -> PandocError -> ExceptT OptInfo IO Opt
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Opt)
    -> PandocError -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError
                                       Text
    "--csl option can only be used once"
                          Maybe MetaValue
    Nothing -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optMetadata = addMeta "csl" (normalizePath arg) $
                          optMetadata opt })
                       String
    "FILE")
                     String
    ""

         , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "citation-abbreviations"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt ->
                         Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optMetadata =
                                      addMeta "citation-abbreviations"
                                        (normalizePath arg) $ optMetadata opt })
                       String
    "FILE")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "natbib"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                      (\Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optCiteMethod = Natbib }))
                     String
    "" -- "Use natbib cite commands in LaTeX output"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "biblatex"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                      (\Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optCiteMethod = Biblatex }))
                     String
    "" -- "Use biblatex cite commands in LaTeX output"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "mathml"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                      (\Opt
    opt ->
                          Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optHTMLMathMethod = MathML }))
                     String
    "" -- "Use mathml for HTML math"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "webtex"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                          let url' :: Text
    url' = Text -> (String -> Text) -> Maybe String -> Text
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Text
    defaultWebTeXURL String -> Text
    T.pack Maybe String
    arg
                          Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optHTMLMathMethod = WebTeX url' })
                      String
    "URL")
                     String
    "" -- "Use web service for HTML math"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "mathjax"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                          let url' :: Text
    url' = Text -> (String -> Text) -> Maybe String -> Text
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Text
    defaultMathJaxURL String -> Text
    T.pack Maybe String
    arg
                          Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optHTMLMathMethod = MathJax url'})
                      String
    "URL")
                     String
    "" -- "Use MathJax for HTML math"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "katex"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt ->
                          Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt
                            { optHTMLMathMethod = KaTeX $
                               maybe defaultKaTeXURL T.pack arg })
                      String
    "URL")
                      String
    "" -- Use KaTeX for HTML Math

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "gladtex"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                      (\Opt
    opt ->
                          Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optHTMLMathMethod = GladTeX }))
                     String
    "" -- "Use gladtex for HTML math"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "trace"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--trace" Maybe String
    arg
                            return opt { optTrace = boolValue })
                      String
    "true|false")
                     String
    "" -- "Turn on diagnostic tracing in readers."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "dump-args"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--dump-args" Maybe String
    arg
                            return opt { optDumpArgs = boolValue })
                      String
    "true|false")
                     String
    "" -- "Print output filename and arguments to stdout."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "ignore-args"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--ignore-args" Maybe String
    arg
                            return opt { optIgnoreArgs = boolValue })
                      String
    "true|false")
                     String
    "" -- "Ignore command-line arguments."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "verbose"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                      (\Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optVerbosity = INFO }))
                     String
    "" -- "Verbose diagnostic output."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "quiet"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg
                      (\Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt { optVerbosity = ERROR }))
                     String
    "" -- "Suppress warnings."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "fail-if-warnings"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg
                      (\Maybe String
    arg Opt
    opt -> do
                            boolValue <- Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    "--fail-if-warnings" Maybe String
    arg
                            return opt { optFailIfWarnings = boolValue })
                      String
    "true|false")
                     String
    "" -- "Exit with error status if there were  warnings."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "log"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opt -> Opt -> ExceptT OptInfo IO Opt
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Opt
    opt{ optLogFile = Just $
                                                normalizePath arg })
                    String
    "FILE")
                    String
    "" -- "Log messages in JSON format to this file."

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "bash-completion"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg (\Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo OptInfo
    BashCompletion))
                     String
    "" -- "Print bash completion script"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "list-input-formats"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg (\Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo OptInfo
    ListInputFormats))
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "list-output-formats"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg (\Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo OptInfo
    ListOutputFormats))
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "list-extensions"]
                     ((Maybe String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (Maybe String -> a) -> String -> ArgDescr a
    OptArg (\Maybe String
    arg Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo (OptInfo -> ExceptT OptInfo IO Opt)
    -> OptInfo -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Maybe Text -> OptInfo
    ListExtensions (Maybe Text -> OptInfo) -> Maybe Text -> OptInfo
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack (String -> Text) -> Maybe String -> Maybe Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe String
    arg)
                     String
    "FORMAT")
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "list-highlight-languages"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg (\Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo OptInfo
    ListHighlightLanguages))
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "list-highlight-styles"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg (\Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo OptInfo
    ListHighlightStyles))
                     String
    ""

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "D" [String
    "print-default-template"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opts -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo (OptInfo -> ExceptT OptInfo IO Opt)
    -> OptInfo -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $
                        Maybe String -> Text -> OptInfo
    PrintDefaultTemplate (Opt -> Maybe String
    optOutputFile Opt
    opts) (String -> Text
    T.pack String
    arg))
                     String
    "FORMAT")
                     String
    "" -- "Print default template for FORMAT"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "print-default-data-file"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opts -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo (OptInfo -> ExceptT OptInfo IO Opt)
    -> OptInfo -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $
                        Maybe String -> Text -> OptInfo
    PrintDefaultDataFile (Opt -> Maybe String
    optOutputFile Opt
    opts) (String -> Text
    T.pack String
    arg))
                     String
    "FILE")
                      String
    "" -- "Print default data file"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "" [String
    "print-highlight-style"]
                     ((String -> Opt -> ExceptT OptInfo IO Opt)
    -> String -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. (String -> a) -> String -> ArgDescr a
    ReqArg
                      (\String
    arg Opt
    opts ->
                        OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo (OptInfo -> ExceptT OptInfo IO Opt)
    -> OptInfo -> ExceptT OptInfo IO Opt
    forall a b. (a -> b) -> a -> b
    $ Maybe String -> Text -> OptInfo
    PrintHighlightStyle (Opt -> Maybe String
    optOutputFile Opt
    opts)
                                   (String -> Text
    T.pack String
    arg))
                      String
    "STYLE|FILE")
                     String
    "" -- "Print default template for FORMAT"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "v" [String
    "version"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg (\Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo OptInfo
    VersionInfo))
                     String
    "" -- "Print version"

        , String
    -> [String]
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    -> String
    -> OptDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
    Option String
    "h" [String
    "help"]
                     ((Opt -> ExceptT OptInfo IO Opt)
    -> ArgDescr (Opt -> ExceptT OptInfo IO Opt)
    forall a. a -> ArgDescr a
    NoArg (\Opt
    _ -> OptInfo -> ExceptT OptInfo IO Opt
    forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo OptInfo
    Help))
                     String
    "" -- "Show help"
        ]

    optError :: PandocError -> ExceptT OptInfo IO a
    optError :: forall a. PandocError -> ExceptT OptInfo IO a
    optError = OptInfo -> ExceptT OptInfo IO a
    forall a. OptInfo -> ExceptT OptInfo IO a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (OptInfo -> ExceptT OptInfo IO a)
    -> (PandocError -> OptInfo) -> PandocError -> ExceptT OptInfo IO a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PandocError -> OptInfo
    OptError

    optInfo :: OptInfo -> ExceptT OptInfo IO a
    optInfo :: forall a. OptInfo -> ExceptT OptInfo IO a
    optInfo = OptInfo -> ExceptT OptInfo IO a
    forall a. OptInfo -> ExceptT OptInfo IO a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError

    -- Returns usage message
    usageMessage :: String -> [OptDescr (Opt -> ExceptT OptInfo IO Opt)] -> String
    usageMessage :: String -> [OptDescr (Opt -> ExceptT OptInfo IO Opt)] -> String
    usageMessage String
    programName = String -> [OptDescr (Opt -> ExceptT OptInfo IO Opt)] -> String
    forall a. String -> [OptDescr a] -> String
    usageInfo (String
    programName String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    " [OPTIONS] [FILES]")

    copyrightMessage :: String
    copyrightMessage :: String
    copyrightMessage = String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    "\n" [
     String
    "Copyright (C) 2006-2025 John MacFarlane. Web:  https://pandoc.org",
     String
    "This is free software; see the source for copying conditions. There is no",
     String
    "warranty, not even for merchantability or fitness for a particular purpose." ]

    handleUnrecognizedOption :: String -> [String] -> [String]
    handleUnrecognizedOption :: String -> [String] -> [String]
    handleUnrecognizedOption String
    "--smart" =
      ((String
    "--smart/-S has been removed.  Use +smart or -smart extension instead.\n" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++
        String
    "For example: pandoc -f markdown+smart -t markdown-smart.") String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--normalize" =
      (String
    "--normalize has been removed.  Normalization is now automatic." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "-S" = String -> [String] -> [String]
    handleUnrecognizedOption String
    "--smart"
    handleUnrecognizedOption String
    "--old-dashes" =
      (String
    "--old-dashes has been removed.  Use +old_dashes extension instead." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--no-wrap" =
      (String
    "--no-wrap has been removed.  Use --wrap=none instead." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--latex-engine" =
      (String
    "--latex-engine has been removed.  Use --pdf-engine instead." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--latex-engine-opt" =
      (String
    "--latex-engine-opt has been removed.  Use --pdf-engine-opt instead." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--chapters" =
      (String
    "--chapters has been removed. Use --top-level-division=chapter instead." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--reference-docx" =
      (String
    "--reference-docx has been removed. Use --reference-doc instead." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--reference-odt" =
      (String
    "--reference-odt has been removed. Use --reference-doc instead." String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--parse-raw" =
      (String
    "--parse-raw/-R has been removed. Use +raw_html or +raw_tex extension.\n" String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "--epub-stylesheet" =
      (String
    "--epub-stylesheet has been removed. Use --css instead.\n" String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)
    handleUnrecognizedOption String
    "-R" = String -> [String] -> [String]
    handleUnrecognizedOption String
    "--parse-raw"
    handleUnrecognizedOption String
    x =
      ((String
    "Unknown option " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    x String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ".") String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    :)

    readersNames :: [Text]
    readersNames :: [Text]
    readersNames = [Text] -> [Text]
    forall a. Ord a => [a] -> [a]
    sort (((Text, Reader PandocIO) -> Text)
    -> [(Text, Reader PandocIO)] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text, Reader PandocIO) -> Text
    forall a b. (a, b) -> a
    fst ([(Text, Reader PandocIO)]
    forall (m :: * -> *). PandocMonad m => [(Text, Reader m)]
    readers :: [(Text, Reader PandocIO)]))

    writersNames :: [Text]
    writersNames :: [Text]
    writersNames = [Text] -> [Text]
    forall a. Ord a => [a] -> [a]
    sort
      (Text
    "pdf" Text -> [Text] -> [Text]
    forall a. a -> [a] -> [a]
    : ((Text, Writer PandocIO) -> Text)
    -> [(Text, Writer PandocIO)] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map (Text, Writer PandocIO) -> Text
    forall a b. (a, b) -> a
    fst ([(Text, Writer PandocIO)]
    forall (m :: * -> *). PandocMonad m => [(Text, Writer m)]
    writers :: [(Text, Writer PandocIO)]))

    splitField :: String -> (String, String)
    splitField :: String -> (String, String)
    splitField = (String -> String) -> (String, String) -> (String, String)
    forall b c a. (b -> c) -> (a, b) -> (a, c)
    forall (p :: * -> * -> *) b c a.
    Bifunctor p =>
    (b -> c) -> p a b -> p a c
    second (String -> String -> String
    forall a. [a] -> [a] -> [a]
    tailDef String
    "true") ((String, String) -> (String, String))
    -> (String -> (String, String)) -> String -> (String, String)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> Bool) -> String -> (String, String)
    forall a. (a -> Bool) -> [a] -> ([a], [a])
    break (\Char
    c -> Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    ':' Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '=')

    deprecatedOption :: String -> String -> ExceptT OptInfo IO ()
    deprecatedOption :: String -> String -> ExceptT OptInfo IO ()
    deprecatedOption String
    o String
    msg = do
      res <- IO (Either PandocError ())
    -> ExceptT OptInfo IO (Either PandocError ())
    forall a. IO a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Either PandocError ())
     -> ExceptT OptInfo IO (Either PandocError ()))
    -> IO (Either PandocError ())
    -> ExceptT OptInfo IO (Either PandocError ())
    forall a b. (a -> b) -> a -> b
    $ PandocIO () -> IO (Either PandocError ())
    forall a. PandocIO a -> IO (Either PandocError a)
    runIO (LogMessage -> PandocIO ()
    forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
    report (LogMessage -> PandocIO ()) -> LogMessage -> PandocIO ()
    forall a b. (a -> b) -> a -> b
    $ Text -> Text -> LogMessage
    Deprecated (String -> Text
    T.pack String
    o) (String -> Text
    T.pack String
    msg))
      case res of
           Right () -> () -> ExceptT OptInfo IO ()
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
           Left PandocError
    e   -> PandocError -> ExceptT OptInfo IO ()
    forall a. PandocError -> ExceptT OptInfo IO a
    optError PandocError
    e

    -- | Set text value in text context.  Create list if it has a value already,
    -- or add to a list value.
    setVariable :: Text -> Text -> Context Text -> Context Text
    setVariable :: Text -> Text -> Context Text -> Context Text
    setVariable Text
    key Text
    val (Context Map Text (Val Text)
    ctx) = Map Text (Val Text) -> Context Text
    forall a. Map Text (Val a) -> Context a
    Context (Map Text (Val Text) -> Context Text)
    -> Map Text (Val Text) -> Context Text
    forall a b. (a -> b) -> a -> b
    $ (Maybe (Val Text) -> Maybe (Val Text))
    -> Text -> Map Text (Val Text) -> Map Text (Val Text)
    forall k a.
    Ord k =>
    (Maybe a -> Maybe a) -> k -> Map k a -> Map k a
    M.alter Maybe (Val Text) -> Maybe (Val Text)
    forall {a}. ToContext a Text => Maybe (Val a) -> Maybe (Val a)
    go Text
    key Map Text (Val Text)
    ctx
      where go :: Maybe (Val a) -> Maybe (Val a)
    go Maybe (Val a)
    Nothing             = Val a -> Maybe (Val a)
    forall a. a -> Maybe a
    Just (Val a -> Maybe (Val a)) -> Val a -> Maybe (Val a)
    forall a b. (a -> b) -> a -> b
    $ Text -> Val a
    forall a b. ToContext a b => b -> Val a
    toVal Text
    val
            go (Just (ListVal [Val a]
    xs)) = Val a -> Maybe (Val a)
    forall a. a -> Maybe a
    Just (Val a -> Maybe (Val a)) -> Val a -> Maybe (Val a)
    forall a b. (a -> b) -> a -> b
    $ [Val a] -> Val a
    forall a. [Val a] -> Val a
    ListVal ([Val a] -> Val a) -> [Val a] -> Val a
    forall a b. (a -> b) -> a -> b
    $ [Val a]
    xs [Val a] -> [Val a] -> [Val a]
    forall a. [a] -> [a] -> [a]
    ++ [Text -> Val a
    forall a b. ToContext a b => b -> Val a
    toVal Text
    val]
            go (Just Val a
    x)            = Val a -> Maybe (Val a)
    forall a. a -> Maybe a
    Just (Val a -> Maybe (Val a)) -> Val a -> Maybe (Val a)
    forall a b. (a -> b) -> a -> b
    $ [Val a] -> Val a
    forall a. [Val a] -> Val a
    ListVal [Val a
    x, Text -> Val a
    forall a b. ToContext a b => b -> Val a
    toVal Text
    val]

    addMeta :: String -> String -> Meta -> Meta
    addMeta :: String -> String -> Meta -> Meta
    addMeta String
    k String
    v Meta
    meta =
      case Text -> Meta -> Maybe MetaValue
    lookupMeta Text
    k' Meta
    meta of
           Maybe MetaValue
    Nothing -> Text -> MetaValue -> Meta -> Meta
    forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
    forall b. ToMetaValue b => Text -> b -> Meta -> Meta
    setMeta Text
    k' MetaValue
    v' Meta
    meta
           Just (MetaList [MetaValue]
    xs) ->
                      Text -> MetaValue -> Meta -> Meta
    forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
    forall b. ToMetaValue b => Text -> b -> Meta -> Meta
    setMeta Text
    k' ([MetaValue] -> MetaValue
    MetaList ([MetaValue]
    xs [MetaValue] -> [MetaValue] -> [MetaValue]
    forall a. [a] -> [a] -> [a]
    ++ [MetaValue
    v'])) Meta
    meta
           Just MetaValue
    x  -> Text -> MetaValue -> Meta -> Meta
    forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
    forall b. ToMetaValue b => Text -> b -> Meta -> Meta
    setMeta Text
    k' ([MetaValue] -> MetaValue
    MetaList [MetaValue
    x, MetaValue
    v']) Meta
    meta
     where
      v' :: MetaValue
    v' = String -> MetaValue
    readMetaValue String
    v
      k' :: Text
    k' = String -> Text
    T.pack String
    k

    readMetaValue :: String -> MetaValue
    readMetaValue :: String -> MetaValue
    readMetaValue String
    s
      | String
    s String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "true"  = Bool -> MetaValue
    MetaBool Bool
    True
      | String
    s String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "True"  = Bool -> MetaValue
    MetaBool Bool
    True
      | String
    s String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "TRUE"  = Bool -> MetaValue
    MetaBool Bool
    True
      | String
    s String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "false" = Bool -> MetaValue
    MetaBool Bool
    False
      | String
    s String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "False" = Bool -> MetaValue
    MetaBool Bool
    False
      | String
    s String -> String -> Bool
    forall a. Eq a => a -> a -> Bool
    == String
    "FALSE" = Bool -> MetaValue
    MetaBool Bool
    False
      | Bool
    otherwise    = Text -> MetaValue
    MetaString (Text -> MetaValue) -> Text -> MetaValue
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack String
    s

    readBoolFromOptArg ::  Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg :: Text -> Maybe String -> ExceptT OptInfo IO Bool
    readBoolFromOptArg Text
    opt = ExceptT OptInfo IO Bool
    -> (String -> ExceptT OptInfo IO Bool)
    -> Maybe String
    -> ExceptT OptInfo IO Bool
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (Bool -> ExceptT OptInfo IO Bool
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    True) String -> ExceptT OptInfo IO Bool
    forall {f :: * -> *}.
    (Functor f, Eq (f Char), IsString (f Char)) =>
    f Char -> ExceptT OptInfo IO Bool
    readBoolFromArg
        where readBoolFromArg :: f Char -> ExceptT OptInfo IO Bool
    readBoolFromArg f Char
    arg = case Char -> Char
    toLower (Char -> Char) -> f Char -> f Char
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f Char
    arg of
                f Char
    "true"  -> Bool -> ExceptT OptInfo IO Bool
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    True
                f Char
    "false" -> Bool -> ExceptT OptInfo IO Bool
    forall a. a -> ExceptT OptInfo IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    False
                f Char
    _       -> PandocError -> ExceptT OptInfo IO Bool
    forall a. PandocError -> ExceptT OptInfo IO a
    optError (PandocError -> ExceptT OptInfo IO Bool)
    -> PandocError -> ExceptT OptInfo IO Bool
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocOptionError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $
                            Text
    "Argument of " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    opt Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    " must be either true or false"

    -- On Windows with ghc 8.6+, we need to rewrite paths
    -- beginning with \\ to \\?\UNC\. -- See #5127.
    normalizePath :: FilePath -> FilePath
    #ifdef _WINDOWS
    normalizePath fp =
      if "\\\\" `isPrefixOf` fp && not ("\\\\?\\" `isPrefixOf` fp)
        then "\\\\?\\UNC\\" ++ drop 2 fp
        else fp
    #else
    normalizePath :: String -> String
    normalizePath = String -> String
    forall a. a -> a
    id
    #endif

    -- | Print version information with customizable features and scripting engine
    versionInfo :: [String] -> Maybe String -> String -> IO ()
    versionInfo :: [String] -> Maybe String -> String -> IO ()
    versionInfo [String]
    features Maybe String
    mbScriptingEngineName String
    suffix = do
      defaultDatadir <- IO String
    defaultUserDataDir
      let featuresLine = if [String] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [String]
    features
                           then []
                           else [String
    "Features: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ [String] -> String
    unwords [String]
    features]
      let scriptingLine = case Maybe String
    mbScriptingEngineName of
                            Maybe String
    Nothing -> []
                            Just String
    name -> [String
    "Scripting engine: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    name]
      UTF8.putStr $ T.unlines $ map T.pack $
        ["pandoc " ++ showVersion pandocVersion ++ suffix] ++
        featuresLine ++
        scriptingLine ++
        ["User data directory: " ++ defaultDatadir,
         copyrightMessage]
      exitSuccess