content: {- |
  
  The basic task of this library is to parse text as commonmark.
  Usage example:
  
  > {-# LANGUAGE ScopedTypeVariables #-}
  > import Commonmark
  > import Data.Text.IO as TIO
  > import Data.Text.Lazy.IO as TLIO
  >
  > main = do
  >   res <- commonmark "stdin" <$> TIO.getContents
  >   case res of
  >     Left e                  -> error (show e)
  >     Right (html :: Html ()) -> TLIO.putStr $ renderHtml html
  
  The parser is highly polymorphic: in this example, we use
  the type annotation @'Html' ()@ to indicate that we want it
  to produce basic HTML without source location attributes.
  And we return a value in the IO monad.  But we could have used a different
  output format (e.g. @'Html' 'SourceRange'@ for HTML with source location
  attributes).  And we could have used the Identity monad to get a
  pure value. (The default parsers work the same way in any monad, but it is
  possible to define extensions that constrain the monad. For
  example, an extension for include files might only work in IO,
  or might have different behavior in IO and Identity.)
  
  Extensibility is emphasized throughout. To change the output
  for a given format, or support an alternate output format,
  one has only to define instances of 'IsBlock' and 'IsInline'
  for a new type.  (For an example of this kind of extension,
  see the @commonmark-pandoc@ package, which defines these
  instances for pandoc's native types.)
  
  Supporting a new syntactic element generally requires (a) adding
  a 'SyntaxSpec' for it and (b) defining new type classes.
  See the examples in the @commonmark-extensions@ package.
  Note that 'SyntaxSpec' is a Monoid, so one can extend
  'defaultSyntaxSpec' by specifying @myNewSyntaxSpec <> defaultSyntaxSpec@.
  
  -}
  
  module Commonmark
      ( module Commonmark.Tokens
      , module Commonmark.Types
      , module Commonmark.Syntax
      , module Commonmark.Parser
      , module Commonmark.SourceMap
      , module Commonmark.Html
      ) where
  
  import           Commonmark.Tokens
  import           Commonmark.Types
  import           Commonmark.Parser
  import           Commonmark.Syntax
  import           Commonmark.SourceMap
  import           Commonmark.Html
  
  