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


-- | A tool for posting Haskelly articles to blogs
--   
--   Write blog posts in Markdown format, then use BlogLiterately to do
--   syntax highlighting, format ghci sessions, and upload to any blog
--   supporting the metaWeblog API (such as Wordpress):
--   <a>http://codex.wordpress.org/XML-RPC_MetaWeblog_API</a>.
--   
--   To get started, use the provided executable <tt>BlogLiterately</tt>;
--   see <a>http://byorgey.wordpress.com/blogliterately/</a> for complete
--   documentation.
--   
--   To make further customization possible, the internals of the
--   executable are made available as a library. In particular, it is easy
--   to create your own executable which adds extra custom transformations;
--   see <a>Text.BlogLiterately.Run</a>.
@package BlogLiterately
@version 0.8.6.3


-- | Utilities for working with code blocks.
module Text.BlogLiterately.Block

-- | Given a block, if begins with a tag in square brackets, strip off the
--   tag and return a pair consisting of the tag and de-tagged block.
--   Otherwise, return <tt>Nothing</tt> and the unchanged block.
unTag :: String -> (Maybe String, String)

-- | Run the given function on the attributes and source code of code
--   blocks with a tag matching the given tag (case insensitive). On any
--   other blocks (which don't have a matching tag, or are not code
--   blocks), run the other function.
onTag :: String -> (Attr -> String -> a) -> (Block -> a) -> Block -> a


-- | Format specially marked blocks as interactive ghci sessions. Uses some
--   ugly but effective code for interacting with an external ghci process
--   taken from lhs2TeX.
module Text.BlogLiterately.Ghci

-- | Information about a running process: stdin, stdout, stderr, and a
--   handle.
type ProcessInfo = (Handle, Handle, Handle, ProcessHandle)

-- | Evaluate an expression using an external <tt>ghci</tt> process.
ghciEval :: GhciInput -> ReaderT ProcessInfo IO GhciOutput

-- | Start an external ghci process, run a computation with access to it,
--   and finally stop the process.
withGhciProcess :: FilePath -> ReaderT ProcessInfo IO a -> IO a

-- | Poor man's check to see whether we have a literate Haskell file.
isLiterate :: String -> Bool

-- | Stop a ghci process by passing it <tt>:q</tt> and waiting for it to
--   exit.
stopGhci :: ProcessInfo -> IO ()

-- | There is nothing magic about the magic string.
magic :: String
extract' :: Handle -> IO String
extract :: String -> String
breaks :: ([a] -> Bool) -> [a] -> ([a], [a])

-- | Given the path to the <tt>.lhs</tt> source and its representation as a
--   <tt>Pandoc</tt> document, <tt>formatInlineGhci</tt> finds any
--   <tt>[ghci]</tt> blocks in it, runs them through <tt>ghci</tt>, and
--   formats the results as an interactive <tt>ghci</tt> session.
--   
--   Lines beginning in the first column of the block are interpreted as
--   inputs. Lines indented by one or more space are interpreted as
--   <i>expected outputs</i>. Consecutive indented lines are interpreted as
--   one multi-line expected output, with a number of spaces removed from
--   the beginning of each line equal to the number of spaces at the start
--   of the first indented line.
--   
--   If the output for a given input is the same as the expected output (or
--   if no expected output is given), the result is typeset normally. If
--   the actual and expected outputs differ, the actual output is typeset
--   first in red, then the expected output in blue.
formatInlineGhci :: FilePath -> Pandoc -> IO Pandoc
instance GHC.Show.Show Text.BlogLiterately.Ghci.GhciLine
instance GHC.Show.Show Text.BlogLiterately.Ghci.GhciOutput
instance GHC.Show.Show Text.BlogLiterately.Ghci.GhciInput


-- | Syntax highlighting.
module Text.BlogLiterately.Highlight

-- | Four modes for highlighting Haskell.
data HsHighlight

-- | Use hscolour and inline the styles.
HsColourInline :: StylePrefs -> HsHighlight

-- | Use hscolour in conjunction with an external CSS style sheet.
HsColourCSS :: HsHighlight

-- | Use highlighting-kate.
HsKate :: HsHighlight

-- | Do not highlight Haskell.
HsNoHighlight :: HsHighlight
_HsColourInline :: Prism' HsHighlight StylePrefs

-- | Use hscolour to syntax highlight some Haskell code. The first argument
--   indicates whether the code is literate Haskell.
colourIt :: Bool -> String -> String

-- | Prepend literate Haskell markers to some source code.
litify :: String -> String

-- | Style preferences are specified as a list of mappings from class
--   attributes to CSS style attributes.
type StylePrefs = [(String, String)]

-- | A default style that produces something that looks like the source
--   listings on Hackage.
defaultStylePrefs :: StylePrefs

-- | Read style preferences in from a file using the <tt>Read</tt> instance
--   for <tt>StylePrefs</tt>, or return the default style if the file name
--   is empty.
getStylePrefs :: Maybe FilePath -> IO StylePrefs

-- | Take a <tt>String</tt> of HTML produced by hscolour, and "bake" styles
--   into it by replacing class attributes with appropriate style
--   attributes.
bakeStyles :: StylePrefs -> String -> String

-- | Replace <tt>&lt;br/&gt;</tt> tags with newlines.
replaceBreaks :: String -> String

-- | Transform a <tt>CodeBlock</tt> into a <tt>RawHtml</tt> block, where
--   the content contains marked up Haskell (possibly with literate
--   markers), or marked up non-Haskell, if highlighting of non-Haskell has
--   been selected.
colouriseCodeBlock :: HsHighlight -> Bool -> Block -> Block

-- | Perform syntax highlighting on an entire Pandoc document.
colourisePandoc :: HsHighlight -> Bool -> Pandoc -> Pandoc
instance GHC.Classes.Eq Text.BlogLiterately.Highlight.HsHighlight
instance GHC.Show.Show Text.BlogLiterately.Highlight.HsHighlight
instance Data.Data.Data Text.BlogLiterately.Highlight.HsHighlight


-- | Utilities for working with embedded LaTeX.
module Text.BlogLiterately.LaTeX

-- | Pass LaTeX through unchanged.
rawTeXify :: Pandoc -> Pandoc

-- | WordPress can render LaTeX, but expects it in a special non-standard
--   format (<tt>$latex foo$</tt>). The <tt>wpTeXify</tt> function formats
--   LaTeX code using this format so that it can be processed by WordPress.
wpTeXify :: Pandoc -> Pandoc


-- | Configuation and command-line options.
module Text.BlogLiterately.Options

-- | Configuration record (and command-line options) for
--   <tt>BlogLiterately</tt>.
data BlogLiterately
BlogLiterately :: Maybe String -> Maybe HsHighlight -> Maybe Bool -> Maybe Bool -> Maybe Bool -> Maybe Bool -> Maybe Bool -> Maybe String -> Maybe Bool -> Maybe Bool -> [String] -> [String] -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe String -> Maybe Bool -> Maybe Bool -> Maybe Bool -> Maybe Bool -> [String] -> BlogLiterately

-- | Name of a style file
[_style] :: BlogLiterately -> Maybe String

-- | Haskell highlighting mode
[_hsHighlight] :: BlogLiterately -> Maybe HsHighlight

-- | Use highlighting-kate for non-Haskell?
[_otherHighlight] :: BlogLiterately -> Maybe Bool

-- | Parse as literate Haskell?
[_litHaskell] :: BlogLiterately -> Maybe Bool

-- | Generate a table of contents?
[_toc] :: BlogLiterately -> Maybe Bool

-- | Pass LaTeX through unchanged?
[_rawlatex] :: BlogLiterately -> Maybe Bool

-- | Format LaTeX for WordPress?
[_wplatex] :: BlogLiterately -> Maybe Bool

-- | Indicate how to format math
[_math] :: BlogLiterately -> Maybe String

-- | Automatically process ghci sessions?
[_ghci] :: BlogLiterately -> Maybe Bool

-- | Automatically upload images?
[_uploadImages] :: BlogLiterately -> Maybe Bool

-- | Categories for the post
[_categories] :: BlogLiterately -> [String]

-- | Tags for the post
[_tags] :: BlogLiterately -> [String]

-- | Blog-specific identifier (e.g. for blogging software handling multiple
--   blogs)
[_blogid] :: BlogLiterately -> Maybe String

-- | Name of profile to use.
[_profile] :: BlogLiterately -> Maybe String

-- | Blog xmlrpc URL
[_blog] :: BlogLiterately -> Maybe String

-- | Blog user name
[_user] :: BlogLiterately -> Maybe String

-- | Blog password (omit to be interactively prompted)
[_password] :: BlogLiterately -> Maybe String

-- | Post title
[_title] :: BlogLiterately -> Maybe String

-- | File to post
[_file] :: BlogLiterately -> Maybe String

-- | Format of the file (currently supported: markdown, rst)
[_format] :: BlogLiterately -> Maybe String

-- | ID of a post to update
[_postid] :: BlogLiterately -> Maybe String

-- | Create a "page" instead of a post
[_page] :: BlogLiterately -> Maybe Bool

-- | Should the post be published? (Otherwise it is uploaded as a draft.)
[_publish] :: BlogLiterately -> Maybe Bool

-- | Don't upload anything; just output HTML to stdout.
[_htmlOnly] :: BlogLiterately -> Maybe Bool

-- | Process citations? (default: true)
[_citations] :: BlogLiterately -> Maybe Bool

-- | Extension arguments, for use e.g. by custom transforms
[_xtra] :: BlogLiterately -> [String]

-- | Command-line configuration for use with <tt>cmdargs</tt>.
blOpts :: BlogLiterately
style :: Lens' BlogLiterately (Maybe String)
hsHighlight :: Lens' BlogLiterately (Maybe HsHighlight)
otherHighlight :: Lens' BlogLiterately (Maybe Bool)
litHaskell :: Lens' BlogLiterately (Maybe Bool)
toc :: Lens' BlogLiterately (Maybe Bool)
rawlatex :: Lens' BlogLiterately (Maybe Bool)
wplatex :: Lens' BlogLiterately (Maybe Bool)
math :: Lens' BlogLiterately (Maybe String)
ghci :: Lens' BlogLiterately (Maybe Bool)
uploadImages :: Lens' BlogLiterately (Maybe Bool)
categories :: Lens' BlogLiterately [String]
tags :: Lens' BlogLiterately [String]
blogid :: Lens' BlogLiterately (Maybe String)
profile :: Lens' BlogLiterately (Maybe String)
blog :: Lens' BlogLiterately (Maybe String)
user :: Lens' BlogLiterately (Maybe String)
password :: Lens' BlogLiterately (Maybe String)
title :: Lens' BlogLiterately (Maybe String)
file :: Lens' BlogLiterately (Maybe String)
format :: Lens' BlogLiterately (Maybe String)
postid :: Lens' BlogLiterately (Maybe String)
page :: Lens' BlogLiterately (Maybe Bool)
publish :: Lens' BlogLiterately (Maybe Bool)
htmlOnly :: Lens' BlogLiterately (Maybe Bool)
citations :: Lens' BlogLiterately (Maybe Bool)
xtra :: Lens' BlogLiterately [String]
style' :: BlogLiterately -> String
hsHighlight' :: BlogLiterately -> HsHighlight
otherHighlight' :: BlogLiterately -> Bool
litHaskell' :: BlogLiterately -> Bool
toc' :: BlogLiterately -> Bool
rawlatex' :: BlogLiterately -> Bool
wplatex' :: BlogLiterately -> Bool
math' :: BlogLiterately -> String
ghci' :: BlogLiterately -> Bool
uploadImages' :: BlogLiterately -> Bool
blogid' :: BlogLiterately -> String
profile' :: BlogLiterately -> String
blog' :: BlogLiterately -> String
user' :: BlogLiterately -> String
password' :: BlogLiterately -> String
title' :: BlogLiterately -> String
file' :: BlogLiterately -> String
format' :: BlogLiterately -> String
postid' :: BlogLiterately -> String
page' :: BlogLiterately -> Bool
publish' :: BlogLiterately -> Bool
htmlOnly' :: BlogLiterately -> Bool
citations' :: BlogLiterately -> Bool
instance GHC.Base.Semigroup Text.BlogLiterately.Options.BlogLiterately
instance GHC.Base.Monoid Text.BlogLiterately.Options.BlogLiterately
instance Data.Data.Data Text.BlogLiterately.Options.BlogLiterately
instance GHC.Show.Show Text.BlogLiterately.Options.BlogLiterately


-- | Uploading images embedded in posts to the server.
module Text.BlogLiterately.Image

-- | Transform a document by uploading any "local" images to the server,
--   and replacing their filenames with the URLs returned by the server.
--   Only upload any given image once (determined by file name), even
--   across runs: uploaded images and their associated URL on the server is
--   tracked in a special dotfile,
--   <tt>.BlogLiterately-uploaded-images</tt>.
uploadAllImages :: BlogLiterately -> Pandoc -> IO Pandoc

-- | Upload a file using the <tt>metaWeblog.newMediaObject</tt> XML-RPC
--   method call.
uploadIt :: String -> FilePath -> BlogLiterately -> IO (Maybe Value)

-- | Prepare a file for upload.
mkMediaObject :: FilePath -> IO (Maybe Value)


-- | Parsing configuration options from special <tt>[BLOpts]</tt> blocks.
module Text.BlogLiterately.Options.Parse

-- | Convert the contents of a <tt>[BLOpts]</tt> block into an options
--   record and a list of parse errors.
readBLOptions :: String -> ([ParseError], BlogLiterately)

-- | Read a single line from a <tt>[BLOpts]</tt> block.
readBLOption :: String -> Either ParseError BlogLiterately

-- | Parse a single line from a <tt>[BLOpts]</tt> block.
parseBLOption :: Parser BlogLiterately


-- | Uploading posts to the server and fetching posts from the server.
module Text.BlogLiterately.Post

-- | Prepare a post for uploading by creating something of the proper form
--   to be an argument to an XML-RPC call.
mkPost :: String -> String -> [String] -> [String] -> Bool -> [(String, Value)]

-- | Given a name and a list of values, create a named "array" field
--   suitable for inclusion in an XML-RPC struct.
mkArray :: XmlRpcType [a] => String -> [a] -> [(String, Value)]

-- | Given a configuration and a formatted post, upload it to the server.
postIt :: BlogLiterately -> String -> IO ()

-- | Get the URL for a given post.
getPostURL :: String -> String -> String -> String -> IO (Maybe String)

-- | Look at the last n posts and find the most recent whose title contains
--   the search term (case insensitive); return its permalink URL.
findTitle :: Int -> String -> String -> String -> String -> IO (Maybe String)


-- | Tools for putting together a pipeline transforming the source for a
--   post into a completely formatted HTML document.
module Text.BlogLiterately.Transform

-- | The standard set of transforms that are run by default (in order from
--   top to bottom):
--   
--   <ul>
--   <li><a>optionsXF</a>: extract options specified in <tt>[BLOpts]</tt>
--   blocks in the file</li>
--   <li><a>profileXF</a>: load the requested profile (if any)</li>
--   <li><a>passwordXF</a>: prompt the user for a password if needed</li>
--   <li><a>titleXF</a>: extract the title from a special title block</li>
--   <li><a>rawtexifyXF</a>: pass LaTeX through unchanged</li>
--   <li><a>wptexifyXF</a>: turn LaTeX into WordPress format if
--   requested</li>
--   <li><a>ghciXF</a>: run and typeset ghci sessions if requested</li>
--   <li><a>uploadImagesXF</a>: upload images if requested</li>
--   <li><a>centerImagesXF</a>: center images occurring in their own
--   paragraph</li>
--   <li><a>specialLinksXF</a>: replace special link types with URLs</li>
--   <li><a>highlightOptsXF</a>: load the requested highlighting style
--   file</li>
--   <li><a>highlightXF</a>: perform syntax highlighting</li>
--   <li><a>citationsXF</a>: process citations</li>
--   </ul>
standardTransforms :: [Transform]

-- | Extract blocks tagged with <tt>[BLOpts]</tt> and use their contents as
--   options.
optionsXF :: Transform

-- | Load options from a profile if one is specified.
profileXF :: Transform

-- | Read a user-supplied style file and add its contents to the
--   highlighting options.
highlightOptsXF :: Transform

-- | Prompt the user for a password if the <tt>blog</tt> field is set but
--   no password has been provided.
passwordXF :: Transform

-- | Potentially extract a title from the metadata block, and set it in the
--   options record.
titleXF :: Transform

-- | Pass LaTeX (inline or display) through unchanged (if the
--   <tt>rawlatex</tt> flag is set).
rawtexifyXF :: Transform

-- | Format embedded LaTeX for WordPress (if the <tt>wplatex</tt> flag is
--   set).
wptexifyXF :: Transform

-- | Format embedded <tt>ghci</tt> sessions (if the <tt>ghci</tt> flag is
--   set).
ghciXF :: Transform

-- | Upload embedded local images to the server (if the
--   <tt>uploadImages</tt> flag is set).
uploadImagesXF :: Transform

-- | Perform syntax highlighting on code blocks.
highlightXF :: Transform

-- | Center any images which occur in a paragraph by themselves. Inline
--   images are not affected.
centerImagesXF :: Transform

-- | Format citations.
citationsXF :: Transform

-- | Replace special links with appropriate URLs. Currently, the following
--   types of special links are supported:
--   
--   <ul>
--   <li><i><tt>lucky::<a>search</a></tt></i> The first Google result for
--   <tt><a>search</a></tt>.</li>
--   <li><i><tt>wiki::<a>title</a></tt></i> The Wikipedia page for
--   <tt><a>title</a></tt>. Note that the page is not checked for
--   existence.</li>
--   <li><i><tt>hackage::<a>pkg</a></tt></i> The Hackage page for
--   <tt><a>pkg</a></tt>.</li>
--   <li><i><tt>github::<a>user</a>/<a>repo</a></tt></i> The top page for
--   the given repo on github.</li>
--   <li><i><tt>github::<a>user</a><i><a>repo</a></i>#<a>nnn</a></tt></i>
--   Link to a particular issue.</li>
--   <li><i><tt>github::<a>user</a><i><a>repo</a></i>@<a>hash</a></tt></i>
--   Link to a particular commit.</li>
--   <li><i><tt>post::nnnn</tt></i> Link to the blog post with post ID
--   <tt>nnnn</tt>. Note that this form of special link is invoked when
--   <tt>nnnn</tt> consists of all digits, so it only works on blogs which
--   use numerical identifiers for post IDs (as Wordpress does).</li>
--   <li><i><tt>post::<a>search</a></tt></i> Link to the most recent blog
--   post (among the 20 most recent posts) containing
--   <tt><a>search</a></tt> in its title.</li>
--   </ul>
--   
--   For example, a post written in Markdown format containing
--   
--   <pre>
--   This is a post about the game of [Go](wiki::Go (game)).
--   
--   </pre>
--   
--   will be formatted in HTML as
--   
--   <pre>
--   <a>p</a>This is a post about the game of <a>href="https://en.wikipedia.org/wiki/Go%20(game)"</a>Go<a>/a</a>.<a>/p</a>
--   
--   </pre>
--   
--   You can also create a Transform with your own special link types,
--   using <a>mkSpecialLinksXF</a>, and I am happy to receive pull requests
--   adding new types of standard special links.
specialLinksXF :: Transform

-- | Create a transformation which looks for the given special links and
--   replaces them appropriately. You can use this function with your own
--   types of special links.
mkSpecialLinksXF :: [SpecialLink] -> Transform

-- | The standard special link types included in <a>specialLinksXF</a>:
--   <a>luckyLink</a>, <a>wikiLink</a>, <a>postLink</a>, <a>githubLink</a>,
--   and <a>hackageLink</a>.
standardSpecialLinks :: [SpecialLink]

-- | Turn <tt>lucky::<a>search</a></tt> into a link to the first Google
--   result for <tt><a>search</a></tt>.
luckyLink :: SpecialLink

-- | Given <tt>wiki::<a>title</a></tt>, generate a link to the Wikipedia
--   page for <tt><a>title</a></tt>. Note that the page is not checked for
--   existence.
wikiLink :: SpecialLink

-- | <tt>postLink</tt> handles two types of special links.
--   
--   <ul>
--   <li><i><tt>post::nnnn</tt></i> Link to the blog post with post ID
--   <tt>nnnn</tt>. Note that this form of special link is invoked when
--   <tt>nnnn</tt> consists of all digits, so it only works on blogs which
--   use numerical identifiers for post IDs (as Wordpress does).</li>
--   <li><i><tt>post::<a>search</a></tt></i> Link to the most recent blog
--   post (among the 20 most recent posts) containing
--   <tt><a>search</a></tt> in its title.</li>
--   </ul>
postLink :: SpecialLink

-- | A document transformation consists of two parts: an actual
--   transformation, expressed as a function over Pandoc documents, and a
--   condition specifying whether the transformation should actually be
--   applied.
--   
--   The transformation itself takes a <a>BlogLiterately</a> configuration
--   as an argument. You may of course ignore it if you do not need to know
--   anything about the configuration. The <tt>--xtra</tt> (or <tt>-x</tt>)
--   flag is also provided especially as a method of getting information
--   from the command-line to custom extensions. Arguments passed via
--   <tt>-x</tt> on the command line are available from the <a>xtra</a>
--   field of the <a>BlogLiterately</a> configuration.
--   
--   The transformation is then specified as a stateful computation over
--   both a <tt>BlogLiterately</tt> options record, and a <tt>Pandoc</tt>
--   document. It may also have effects in the <tt>IO</tt> monad.
--   
--   <ul>
--   <li>If you have a pure function of type @BlogLiterately -&gt;
--   Pandoc</li>
--   <li>&gt; Pandoc@, you can use the <a>pureTransform</a> function to
--   create a <a>Transform</a>.</li>
--   <li>If you have a function of type <tt>BlogLiterately -&gt; Pandoc
--   -&gt; IO Pandoc</tt>, you can use <a>ioTransform</a>.</li>
--   <li>Otherwise you can directly create something of type <tt>StateT
--   (BlogLiterately, Pandoc) IO ()</tt>.</li>
--   </ul>
--   
--   For examples, see the implementations of the standard transforms
--   below.
data Transform
Transform :: StateT (BlogLiterately, Pandoc) IO () -> (BlogLiterately -> Bool) -> Transform

-- | A document transformation, which can transform both the document and
--   the options and have effects in the IO monad. The options record can
--   be transformed because the document itself may contain information
--   which affects the options.
[getTransform] :: Transform -> StateT (BlogLiterately, Pandoc) IO ()

-- | A condition under which to run the transformation.
[xfCond] :: Transform -> BlogLiterately -> Bool

-- | Construct a transformation from a pure function.
pureTransform :: (BlogLiterately -> Pandoc -> Pandoc) -> (BlogLiterately -> Bool) -> Transform

-- | Construct a transformation from a function in the <tt>IO</tt> monad.
ioTransform :: (BlogLiterately -> Pandoc -> IO Pandoc) -> (BlogLiterately -> Bool) -> Transform

-- | Run a <a>Transform</a> (if its condition is met).
runTransform :: Transform -> StateT (BlogLiterately, Pandoc) IO ()

-- | Run a pipeline of <a>Transform</a>s.
runTransforms :: [Transform] -> BlogLiterately -> Pandoc -> IO (BlogLiterately, Pandoc)

-- | Transform a complete input document string to an HTML output string,
--   given a list of transformation passes.
xformDoc :: BlogLiterately -> [Transform] -> String -> IO (Either PandocError (BlogLiterately, String))

-- | Turn <tt>CRLF</tt> pairs into a single <tt>LF</tt>. This is necessary
--   since <a>readMarkdown</a> is picky about line endings.
fixLineEndings :: String -> String


-- | Functions for creating <tt>BlogLiterately</tt> executables. By
--   default, installing this library results in the installation of a
--   standard executable, called <tt>BlogLiterately</tt>, which corresponds
--   to <a>blogLiterately</a> from this module. However, you can create
--   your own custom executables with extra custom functionality using
--   <a>blogLiteratelyWith</a> or <a>blogLiteratelyCustom</a>. For example:
--   
--   <pre>
--   module Main where
--   import Text.BlogLiterately
--   
--   myCustomXF1 = pureTransform ...
--   myCustomXF2 = Transform ...
--   main = blogLiteratelyWith [myCustomXF1, myCustomXF2]
--   </pre>
--   
--   See <a>Text.BlogLiterately.Transform</a> for examples of transforms,
--   additional transforms which are not enabled by default, and help in
--   creating your own.
module Text.BlogLiterately.Run

-- | The default BlogLiterately application.
blogLiterately :: IO ()

-- | Like <a>blogLiterately</a>, but with the ability to specify additional
--   <a>Transform</a>s which will be applied <i>after</i> the standard
--   ones.
blogLiteratelyWith :: [Transform] -> IO ()

-- | Like <a>blogLiterately</a>, but with the ability to <i>replace</i> the
--   standard <a>Transform</a>s. Use this to implement custom interleaving
--   orders of the standard transforms and your own, to exclude some or all
--   of the standard transforms, etc.
blogLiteratelyCustom :: [Transform] -> IO ()


-- | This module is provided as a convenient wrapper which re-exports all
--   the other <tt>Text.BlogLiterately.*</tt> modules.
module Text.BlogLiterately
