-{-# LANGUAGE ScopedTypeVariables, FlexibleInstances, GADTs #-}

-{-

-Copyright (C) 2006-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc

- Copyright : Copyright (C) 2006-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-This helper module exports the main writers, readers, and data

-structure definitions from the Pandoc libraries.

-

-A typical application will chain together a reader and a writer

-to convert strings from one format to another. For example, the

-following simple program will act as a filter converting markdown

-fragments to reStructuredText, using reference-style links instead of

-inline links:

-

-> module Main where

-> import Text.Pandoc

->

-> markdownToRST :: String -> Either PandocError String

-> markdownToRST =

-> writeRST def {writerReferenceLinks = True} . readMarkdown def

->

-> main = getContents >>= either error return markdownToRST >>= putStrLn

-

-Note: all of the readers assume that the input text has @'\n'@

-line endings. So if you get your input text from a web form,

-you should remove @'\r'@ characters using @filter (/='\r')@.

-

--}

-

-module Text.Pandoc

- (

- -- * Definitions

- module Text.Pandoc.Definition

- -- * Generics

- , module Text.Pandoc.Generic

- -- * Options

- , module Text.Pandoc.Options

- -- * Logging

- , module Text.Pandoc.Logging

- -- * Typeclass

- , PandocMonad

- , runIO

- , runPure

- , runIOorExplode

- , setVerbosity

- -- * Error handling

- , module Text.Pandoc.Error

- -- * Lists of readers and writers

- , readers

- -- , writers

- , writers

- -- * Readers: converting /to/ Pandoc format

- , Reader (..)

- , readDocx

- , readOdt

- , readMarkdown

- , readCommonMark

- , readMediaWiki

- , readRST

- , readOrg

- , readLaTeX

- , readHtml

- , readTextile

- , readDocBook

- , readOPML

- , readHaddock

- , readNative

- , readJSON

- , readTWiki

- , readTxt2Tags

- , readEPUB

- -- * Writers: converting /from/ Pandoc format

- , Writer(..)

- , writeNative

- , writeJSON

- , writeMarkdown

- , writePlain

- , writeRST

- , writeLaTeX

- , writeBeamer

- , writeConTeXt

- , writeTexinfo

- , writeHtml4

- , writeHtml4String

- , writeHtml5

- , writeHtml5String

- , writeRevealJs

- , writeS5

- , writeSlidy

- , writeSlideous

- , writeDZSlides

- , writeICML

- , writeDocbook4

- , writeDocbook5

- , writeOPML

- , writeOpenDocument

- , writeMan

- , writeMediaWiki

- , writeDokuWiki

- , writeZimWiki

- , writeTextile

- , writeRTF

- , writeODT

- , writeDocx

- , writeEPUB2

- , writeEPUB3

- , writeFB2

- , writeOrg

- , writeAsciiDoc

- , writeHaddock

- , writeCommonMark

- , writeCustom

- , writeTEI

- -- * Rendering templates and default templates

- , module Text.Pandoc.Templates

- -- * Miscellaneous

- , getReader

- , getWriter

- , getDefaultExtensions

- , pandocVersion

- ) where

-

-import Text.Pandoc.Definition

-import Text.Pandoc.Generic

-import Text.Pandoc.Readers.Markdown

-import Text.Pandoc.Readers.CommonMark

-import Text.Pandoc.Readers.MediaWiki

-import Text.Pandoc.Readers.RST

-import Text.Pandoc.Readers.Org

-import Text.Pandoc.Readers.DocBook

-import Text.Pandoc.Readers.OPML

-import Text.Pandoc.Readers.LaTeX

-import Text.Pandoc.Readers.HTML

-import Text.Pandoc.Readers.Textile

-import Text.Pandoc.Readers.Native

-import Text.Pandoc.Readers.Haddock

-import Text.Pandoc.Readers.TWiki

-import Text.Pandoc.Readers.Docx

-import Text.Pandoc.Readers.Odt

-import Text.Pandoc.Readers.Txt2Tags

-import Text.Pandoc.Readers.EPUB

-import Text.Pandoc.Writers.Native

-import Text.Pandoc.Writers.Markdown

-import Text.Pandoc.Writers.RST

-import Text.Pandoc.Writers.LaTeX

-import Text.Pandoc.Writers.ConTeXt

-import Text.Pandoc.Writers.Texinfo

-import Text.Pandoc.Writers.HTML

-import Text.Pandoc.Writers.ODT

-import Text.Pandoc.Writers.Docx

-import Text.Pandoc.Writers.EPUB

-import Text.Pandoc.Writers.FB2

-import Text.Pandoc.Writers.ICML

-import Text.Pandoc.Writers.Docbook

-import Text.Pandoc.Writers.OPML

-import Text.Pandoc.Writers.OpenDocument

-import Text.Pandoc.Writers.Man

-import Text.Pandoc.Writers.RTF

-import Text.Pandoc.Writers.MediaWiki

-import Text.Pandoc.Writers.DokuWiki

-import Text.Pandoc.Writers.ZimWiki

-import Text.Pandoc.Writers.Textile

-import Text.Pandoc.Writers.Org

-import Text.Pandoc.Writers.AsciiDoc

-import Text.Pandoc.Writers.Haddock

-import Text.Pandoc.Writers.CommonMark

-import Text.Pandoc.Writers.Custom

-import Text.Pandoc.Writers.TEI

-import Text.Pandoc.Templates

-import Text.Pandoc.Options

-import Text.Pandoc.Logging

-import Text.Pandoc.Shared (safeRead, mapLeft, pandocVersion)

-import Text.Pandoc.Error

-import Text.Pandoc.Class

-import Data.Aeson

-import qualified Data.ByteString.Lazy as BL

-import Data.List (intercalate)

-import Text.Parsec

-import Text.Parsec.Error

-import qualified Text.Pandoc.UTF8 as UTF8

-import Control.Monad.Except (throwError)

-

-parseFormatSpec :: String

- -> Either ParseError (String, Extensions -> Extensions)

-parseFormatSpec = parse formatSpec ""

- where formatSpec = do

- name <- formatName

- extMods <- many extMod

- return (name, \x -> foldl (flip ($)) x extMods)

- formatName = many1 $ noneOf "-+"

- extMod = do

- polarity <- oneOf "-+"

- name <- many $ noneOf "-+"

- ext <- case safeRead ("Ext_" ++ name) of

- Just n -> return n

- Nothing

- | name == "lhs" -> return Ext_literate_haskell

- | otherwise -> fail $ "Unknown extension: " ++ name

- return $ case polarity of

- '-' -> disableExtension ext

- _ -> enableExtension ext

-

-data Reader m = StringReader (ReaderOptions -> String -> m Pandoc)

- | ByteStringReader (ReaderOptions -> BL.ByteString -> m Pandoc)

-

--- | Association list of formats and readers.

-readers :: PandocMonad m => [(String, Reader m)]

-readers = [ ("native" , StringReader readNative)

- ,("json" , StringReader $ \o s ->

- case readJSON o s of

- Right doc -> return doc

- Left _ -> throwError $ PandocParseError "JSON parse error")

- ,("markdown" , StringReader readMarkdown)

- ,("markdown_strict" , StringReader readMarkdown)

- ,("markdown_phpextra" , StringReader readMarkdown)

- ,("markdown_github" , StringReader readMarkdown)

- ,("markdown_mmd", StringReader readMarkdown)

- ,("commonmark" , StringReader readCommonMark)

- ,("rst" , StringReader readRST)

- ,("mediawiki" , StringReader readMediaWiki)

- ,("docbook" , StringReader readDocBook)

- ,("opml" , StringReader readOPML)

- ,("org" , StringReader readOrg)

- ,("textile" , StringReader readTextile) -- TODO : textile+lhs

- ,("html" , StringReader readHtml)

- ,("latex" , StringReader readLaTeX)

- ,("haddock" , StringReader readHaddock)

- ,("twiki" , StringReader readTWiki)

- ,("docx" , ByteStringReader readDocx)

- ,("odt" , ByteStringReader readOdt)

- ,("t2t" , StringReader readTxt2Tags)

- ,("epub" , ByteStringReader readEPUB)

- ]

-

-data Writer m = StringWriter (WriterOptions -> Pandoc -> m String)

- | ByteStringWriter (WriterOptions -> Pandoc -> m BL.ByteString)

-

--- | Association list of formats and writers.

-writers :: PandocMonad m => [ ( String, Writer m) ]

-writers = [

- ("native" , StringWriter writeNative)

- ,("json" , StringWriter $ \o d -> return $ writeJSON o d)

- ,("docx" , ByteStringWriter writeDocx)

- ,("odt" , ByteStringWriter writeODT)

- ,("epub" , ByteStringWriter writeEPUB3)

- ,("epub2" , ByteStringWriter writeEPUB2)

- ,("epub3" , ByteStringWriter writeEPUB3)

- ,("fb2" , StringWriter writeFB2)

- ,("html" , StringWriter writeHtml5String)

- ,("html4" , StringWriter writeHtml4String)

- ,("html5" , StringWriter writeHtml5String)

- ,("icml" , StringWriter writeICML)

- ,("s5" , StringWriter writeS5)

- ,("slidy" , StringWriter writeSlidy)

- ,("slideous" , StringWriter writeSlideous)

- ,("dzslides" , StringWriter writeDZSlides)

- ,("revealjs" , StringWriter writeRevealJs)

- ,("docbook" , StringWriter writeDocbook5)

- ,("docbook4" , StringWriter writeDocbook4)

- ,("docbook5" , StringWriter writeDocbook5)

- ,("opml" , StringWriter writeOPML)

- ,("opendocument" , StringWriter writeOpenDocument)

- ,("latex" , StringWriter writeLaTeX)

- ,("beamer" , StringWriter writeBeamer)

- ,("context" , StringWriter writeConTeXt)

- ,("texinfo" , StringWriter writeTexinfo)

- ,("man" , StringWriter writeMan)

- ,("markdown" , StringWriter writeMarkdown)

- ,("markdown_strict" , StringWriter writeMarkdown)

- ,("markdown_phpextra" , StringWriter writeMarkdown)

- ,("markdown_github" , StringWriter writeMarkdown)

- ,("markdown_mmd" , StringWriter writeMarkdown)

- ,("plain" , StringWriter writePlain)

- ,("rst" , StringWriter writeRST)

- ,("mediawiki" , StringWriter writeMediaWiki)

- ,("dokuwiki" , StringWriter writeDokuWiki)

- ,("zimwiki" , StringWriter writeZimWiki)

- ,("textile" , StringWriter writeTextile)

- ,("rtf" , StringWriter writeRTF)

- ,("org" , StringWriter writeOrg)

- ,("asciidoc" , StringWriter writeAsciiDoc)

- ,("haddock" , StringWriter writeHaddock)

- ,("commonmark" , StringWriter writeCommonMark)

- ,("tei" , StringWriter writeTEI)

- ]

-

-getDefaultExtensions :: String -> Extensions

-getDefaultExtensions "markdown_strict" = strictExtensions

-getDefaultExtensions "markdown_phpextra" = phpMarkdownExtraExtensions

-getDefaultExtensions "markdown_mmd" = multimarkdownExtensions

-getDefaultExtensions "markdown_github" = githubMarkdownExtensions

-getDefaultExtensions "markdown" = pandocExtensions

-getDefaultExtensions "plain" = plainExtensions

-getDefaultExtensions "org" = extensionsFromList

- [Ext_citations,

- Ext_auto_identifiers]

-getDefaultExtensions "html" = extensionsFromList

- [Ext_auto_identifiers,

- Ext_native_divs,

- Ext_native_spans]

-getDefaultExtensions "html4" = getDefaultExtensions "html"

-getDefaultExtensions "html5" = getDefaultExtensions "html"

-getDefaultExtensions "epub" = extensionsFromList

- [Ext_raw_html,

- Ext_native_divs,

- Ext_native_spans,

- Ext_epub_html_exts]

-getDefaultExtensions "epub2" = getDefaultExtensions "epub"

-getDefaultExtensions "epub3" = getDefaultExtensions "epub"

-getDefaultExtensions "latex" = extensionsFromList

- [Ext_smart,

- Ext_auto_identifiers]

-getDefaultExtensions "context" = extensionsFromList

- [Ext_smart,

- Ext_auto_identifiers]

-getDefaultExtensions "textile" = extensionsFromList

- [Ext_old_dashes,

- Ext_smart,

- Ext_raw_html,

- Ext_auto_identifiers]

-getDefaultExtensions _ = extensionsFromList

- [Ext_auto_identifiers]

-

--- | Retrieve reader based on formatSpec (format+extensions).

-getReader :: PandocMonad m => String -> Either String (Reader m)

-getReader s =

- case parseFormatSpec s of

- Left e -> Left $ intercalate "\n" [m | Message m <- errorMessages e]

- Right (readerName, setExts) ->

- case lookup readerName readers of

- Nothing -> Left $ "Unknown reader: " ++ readerName

- Just (StringReader r) -> Right $ StringReader $ \o ->

- r o{ readerExtensions = setExts $

- getDefaultExtensions readerName }

- Just (ByteStringReader r) -> Right $ ByteStringReader $ \o ->

- r o{ readerExtensions = setExts $

- getDefaultExtensions readerName }

-

-getWriter :: PandocMonad m => String -> Either String (Writer m)

-getWriter s

- = case parseFormatSpec s of

- Left e -> Left $ intercalate "\n" [m | Message m <- errorMessages e]

- Right (writerName, setExts) ->

- case lookup writerName writers of

- Nothing -> Left $ "Unknown writer: " ++ writerName

- Just (StringWriter r) -> Right $ StringWriter $

- \o -> r o{ writerExtensions = setExts $

- getDefaultExtensions writerName }

- Just (ByteStringWriter r) -> Right $ ByteStringWriter $

- \o -> r o{ writerExtensions = setExts $

- getDefaultExtensions writerName }

-

-readJSON :: ReaderOptions -> String -> Either PandocError Pandoc

-readJSON _ = mapLeft PandocParseError . eitherDecode' . UTF8.fromStringLazy

-

-writeJSON :: WriterOptions -> Pandoc -> String

-writeJSON _ = UTF8.toStringLazy . encode

-{-# LANGUAGE CPP, TupleSections, ScopedTypeVariables, PatternGuards #-}

-{-

-Copyright (C) 2006-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.App

- Copyright : Copyright (C) 2006-2016 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 (

- convertWithOpts

- , Opt(..)

- , defaultOpts

- , parseOptions

- , options

- ) where

-import Text.Pandoc

-import Text.Pandoc.Builder (setMeta)

-import Text.Pandoc.PDF (makePDF)

-import Text.Pandoc.Walk (walk)

-import Text.Pandoc.Shared ( tabFilter, readDataFileUTF8,

- headerShift, err, openURL, safeRead,

- readDataFile )

-import Text.Pandoc.MediaBag ( mediaDirectory, extractMediaBag, MediaBag )

-import Text.Pandoc.XML ( toEntities )

-import Text.Pandoc.Highlighting (highlightingStyles)

-import Text.Pandoc.SelfContained ( makeSelfContained )

-import Text.Pandoc.Process (pipeProcess)

-import Skylighting ( Style, defaultSyntaxMap, Syntax(..) )

-import Text.Printf

-import System.Environment ( getEnvironment, getProgName, getArgs )

-import Control.Applicative ((<|>))

-import System.Exit ( ExitCode (..), exitSuccess )

-import System.FilePath

-import Data.Char ( toLower, toUpper )

-import Data.List ( intercalate, isPrefixOf, isSuffixOf, sort )

-import System.Directory ( getAppUserDataDirectory, findExecutable,

- doesFileExist, Permissions(..), getPermissions )

-import System.IO ( stdout, stderr )

-import System.IO.Error ( isDoesNotExistError )

-import qualified Control.Exception as E

-import Control.Exception.Extensible ( throwIO )

-import qualified Text.Pandoc.UTF8 as UTF8

-import Control.Monad

-import Control.Monad.Trans

-import Data.Maybe (fromMaybe, isNothing, isJust)

-import Data.Foldable (foldrM)

-import Network.URI (parseURI, isURI, URI(..))

-import qualified Data.ByteString.Lazy as B

-import qualified Data.ByteString as BS

-import qualified Data.Map as M

-import Data.Aeson (eitherDecode', encode)

-import Data.Yaml (decode)

-import qualified Data.Yaml as Yaml

-import qualified Data.Text as T

-import System.Console.GetOpt

-import Text.Pandoc.Class (withMediaBag, PandocIO, getLog)

-import Paths_pandoc (getDataDir)

-#ifndef _WINDOWS

-import System.Posix.Terminal (queryTerminal)

-import System.Posix.IO (stdOutput)

-#endif

-

-parseOptions :: [OptDescr (Opt -> IO Opt)] -> Opt -> IO Opt

-parseOptions options' defaults = do

- rawArgs <- map UTF8.decodeArg <$> getArgs

- prg <- getProgName

-

- let (actions, args, unrecognizedOpts, errors) =

- getOpt' Permute options' rawArgs

-

- let unknownOptionErrors = foldr handleUnrecognizedOption [] unrecognizedOpts

-

- unless (null errors && null unknownOptionErrors) $

- err 2 $ concat errors ++ unlines unknownOptionErrors ++

- ("Try " ++ prg ++ " --help for more information.")

-

- -- thread option data structure through all supplied option actions

- opts <- foldl (>>=) (return defaults) actions

- return (opts{ optInputFiles = args })

-

-convertWithOpts :: Opt -> IO ()

-convertWithOpts opts = do

- let args = optInputFiles opts

- let outputFile = optOutputFile opts

- let filters = optFilters opts

- let verbosity = optVerbosity opts

-

- when (optDumpArgs opts) $

- do UTF8.hPutStrLn stdout outputFile

- mapM_ (UTF8.hPutStrLn stdout) args

- exitSuccess

-

- epubStylesheet <- case optEpubStylesheet opts of

- Nothing -> return Nothing

- Just fp -> Just <$> UTF8.readFile fp

-

- epubMetadata <- case optEpubMetadata opts of

- Nothing -> return Nothing

- Just fp -> Just <$> UTF8.readFile fp

-

- let csscdn = "https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.6.0/katex.min.css"

- let mathMethod =

- case (optKaTeXJS opts, optKaTeXStylesheet opts) of

- (Nothing, _) -> optHTMLMathMethod opts

- (Just js, ss) -> KaTeX js (fromMaybe csscdn ss)

-

-

- -- --bibliography implies -F pandoc-citeproc for backwards compatibility:

- let needsCiteproc = isJust (lookup "bibliography" (optMetadata opts)) &&

- optCiteMethod opts `notElem` [Natbib, Biblatex] &&

- "pandoc-citeproc" `notElem` map takeBaseName filters

- let filters' = if needsCiteproc then "pandoc-citeproc" : filters

- else filters

-

- let sources = case args of

- [] -> ["-"]

- xs | optIgnoreArgs opts -> ["-"]

- | otherwise -> xs

-

- datadir <- case optDataDir opts of

- Nothing -> E.catch

- (Just <$> getAppUserDataDirectory "pandoc")

- (\e -> let _ = (e :: E.SomeException)

- in return Nothing)

- Just _ -> return $ optDataDir opts

-

- -- assign reader and writer based on options and filenames

- let readerName = case optReader opts of

- Nothing -> defaultReaderName

- (if any isURI sources

- then "html"

- else "markdown") sources

- Just x -> map toLower x

-

- let writerName = case optWriter opts of

- Nothing -> defaultWriterName outputFile

- Just x -> map toLower x

- let format = takeWhile (`notElem` ['+','-'])

- $ takeFileName writerName -- in case path to lua script

-

- let pdfOutput = map toLower (takeExtension outputFile) == ".pdf"

-

- let laTeXOutput = format `elem` ["latex", "beamer"]

- let conTeXtOutput = format == "context"

- let html5Output = format == "html5" || format == "html"

-

- -- disabling the custom writer for now

- writer <- if ".lua" `isSuffixOf` format

- -- note: use non-lowercased version writerName

- then error "custom writers disabled for now"

- else case getWriter writerName of

- Left e -> err 9 $

- if format == "pdf"

- then e ++

- "\nTo create a pdf with pandoc, use " ++

- "the latex or beamer writer and specify\n" ++

- "an output file with .pdf extension " ++

- "(pandoc -t latex -o filename.pdf)."

- else e

- Right w -> return (w :: Writer PandocIO)

-

- -- TODO: we have to get the input and the output into the state for

- -- the sake of the text2tags reader.

- reader <- case getReader readerName of

- Right r -> return (r :: Reader PandocIO)

- Left e -> err 7 e'

- where e' = case readerName of

- "pdf" -> e ++

- "\nPandoc can convert to PDF, but not from PDF."

- "doc" -> e ++

- "\nPandoc can convert from DOCX, but not from DOC.\nTry using Word to save your DOC file as DOCX, and convert that with pandoc."

- _ -> e

-

- let standalone = optStandalone opts || not (isTextFormat format) || pdfOutput

-

- templ <- case optTemplate opts of

- _ | not standalone -> return Nothing

- Nothing -> do

- deftemp <- getDefaultTemplate datadir format

- case deftemp of

- Left e -> throwIO e

- Right t -> return (Just t)

- Just tp -> do

- -- strip off extensions

- let tp' = case takeExtension tp of

- "" -> tp <.> format

- _ -> tp

- Just <$> E.catch (UTF8.readFile tp')

- (\e -> if isDoesNotExistError e

- then E.catch

- (readDataFileUTF8 datadir

- ("templates" </> tp'))

- (\e' -> let _ = (e' :: E.SomeException)

- in throwIO e')

- else throwIO e)

-

- let addStringAsVariable varname s vars = return $ (varname, s) : vars

-

- let addContentsAsVariable varname fp vars = do

- s <- UTF8.readFile fp

- return $ (varname, s) : vars

-

- -- note: this reverses the list constructed in option parsing,

- -- which in turn was reversed from the command-line order,

- -- so we end up with the correct order in the variable list:

- let withList _ [] vars = return vars

- withList f (x:xs) vars = f x vars >>= withList f xs

-

- variables <- return (optVariables opts)

- >>=

- withList (addContentsAsVariable "include-before")

- (optIncludeBeforeBody opts)

- >>=

- withList (addContentsAsVariable "include-after")

- (optIncludeAfterBody opts)

- >>=

- withList (addContentsAsVariable "header-includes")

- (optIncludeInHeader opts)

- >>=

- withList (addStringAsVariable "css") (optCss opts)

- >>=

- maybe return (addStringAsVariable "title-prefix") (optTitlePrefix opts)

- >>=

- maybe return (addStringAsVariable "epub-cover-image")

- (optEpubCoverImage opts)

- >>=

- (\vars -> case mathMethod of

- LaTeXMathML Nothing -> do

- s <- readDataFileUTF8 datadir "LaTeXMathML.js"

- return $ ("mathml-script", s) : vars

- _ -> return vars)

- >>=

- (\vars -> if format == "dzslides"

- then do

- dztempl <- readDataFileUTF8 datadir

- ("dzslides" </> "template.html")

- let dzline = "<!-- {{{{ dzslides core"

- let dzcore = unlines

- $ dropWhile (not . (dzline `isPrefixOf`))

- $ lines dztempl

- return $ ("dzslides-core", dzcore) : vars

- else return vars)

-

- let sourceURL = case sources of

- [] -> Nothing

- (x:_) -> case parseURI x of

- Just u

- | uriScheme u `elem` ["http:","https:"] ->

- Just $ show u{ uriQuery = "",

- uriFragment = "" }

- _ -> Nothing

-

- let readerOpts = def{ readerStandalone = standalone

- , readerColumns = optColumns opts

- , readerTabStop = optTabStop opts

- , readerIndentedCodeClasses = optIndentedCodeClasses opts

- , readerApplyMacros = not laTeXOutput

- , readerDefaultImageExtension =

- optDefaultImageExtension opts

- , readerTrackChanges = optTrackChanges opts

- }

-

- highlightStyle <- lookupHighlightStyle $ optHighlightStyle opts

-

- let writerOptions = def { writerTemplate = templ,

- writerVariables = variables,

- writerTabStop = optTabStop opts,

- writerTableOfContents = optTableOfContents opts,

- writerHTMLMathMethod = mathMethod,

- writerIncremental = optIncremental opts,

- writerCiteMethod = optCiteMethod opts,

- writerNumberSections = optNumberSections opts,

- writerNumberOffset = optNumberOffset opts,

- writerSectionDivs = optSectionDivs opts,

- writerReferenceLinks = optReferenceLinks opts,

- writerReferenceLocation = optReferenceLocation opts,

- writerDpi = optDpi opts,

- writerWrapText = optWrapText opts,

- writerColumns = optColumns opts,

- writerEmailObfuscation = optEmailObfuscation opts,

- writerIdentifierPrefix = optIdentifierPrefix opts,

- writerSourceURL = sourceURL,

- writerUserDataDir = datadir,

- writerHtmlQTags = optHtmlQTags opts,

- writerTopLevelDivision = optTopLevelDivision opts,

- writerListings = optListings opts,

- writerSlideLevel = optSlideLevel opts,

- writerHighlightStyle = highlightStyle,

- writerSetextHeaders = optSetextHeaders opts,

- writerEpubMetadata = epubMetadata,

- writerEpubStylesheet = epubStylesheet,

- writerEpubFonts = optEpubFonts opts,

- writerEpubChapterLevel = optEpubChapterLevel opts,

- writerTOCDepth = optTOCDepth opts,

- writerReferenceDoc = optReferenceDoc opts,

- writerLaTeXArgs = optLaTeXEngineArgs opts

- }

-

-

-#ifdef _WINDOWS

- let istty = True

-#else

- istty <- queryTerminal stdOutput

-#endif

- when (istty && not (isTextFormat format) && outputFile == "-") $

- err 5 $ "Cannot write " ++ format ++ " output to stdout.\n" ++

- "Specify an output file using the -o option."

-

-

- let transforms = case optBaseHeaderLevel opts of

- x | x > 1 -> [headerShift (x - 1)]

- | otherwise -> []

-

- let convertTabs = tabFilter (if optPreserveTabs opts || readerName == "t2t"

- then 0

- else optTabStop opts)

-

- readSources :: (Functor m, MonadIO m) => [FilePath] -> m String

- readSources srcs = convertTabs . intercalate "\n" <$>

- mapM readSource srcs

-

- let runIO' :: PandocIO a -> IO a

- runIO' f = do

- (res, reports) <- runIOorExplode $ do

- setVerbosity verbosity

- x <- f

- rs <- getLog

- return (x, rs)

- case optLogFile opts of

- Nothing -> return ()

- Just logfile -> B.writeFile logfile (encodeLogMessages reports)

- let isWarning msg = messageVerbosity msg == WARNING

- when (optFailIfWarnings opts && any isWarning reports) $

- err 3 "Failing because there were warnings."

- return res

-

- let sourceToDoc :: [FilePath] -> PandocIO (Pandoc, MediaBag)

- sourceToDoc sources' =

- case reader of

- StringReader r

- | optFileScope opts || readerName == "json" -> do

- pairs <- mapM

- (readSource >=> withMediaBag . r readerOpts) sources

- return (mconcat (map fst pairs), mconcat (map snd pairs))

- | otherwise ->

- readSources sources' >>= withMediaBag . r readerOpts

- ByteStringReader r -> do

- pairs <- mapM (readFile' >=>

- withMediaBag . r readerOpts) sources

- return (mconcat (map fst pairs), mconcat (map snd pairs))

-

- runIO' $ do

- (doc, media) <- sourceToDoc sources

- doc' <- (maybe return (extractMedia media) (optExtractMedia opts) >=>

- return . flip (foldr addMetadata) (optMetadata opts) >=>

- applyTransforms transforms >=>

- applyFilters datadir filters' [format]) doc

-

- case writer of

- -- StringWriter f -> f writerOptions doc' >>= writerFn outputFile

- ByteStringWriter f -> f writerOptions doc' >>= writeFnBinary outputFile

- StringWriter f

- | pdfOutput -> do

- -- make sure writer is latex or beamer or context or html5

- unless (laTeXOutput || conTeXtOutput || html5Output) $

- err 47 $ "cannot produce pdf output with " ++ format ++

- " writer"

-

- let pdfprog = case () of

- _ | conTeXtOutput -> "context"

- _ | html5Output -> "wkhtmltopdf"

- _ -> optLaTeXEngine opts

- -- check for pdf creating program

- mbPdfProg <- liftIO $ findExecutable pdfprog

- when (isNothing mbPdfProg) $

- err 41 $ pdfprog ++ " not found. " ++

- pdfprog ++ " is needed for pdf output."

-

- res <- makePDF pdfprog f writerOptions verbosity media doc'

- case res of

- Right pdf -> writeFnBinary outputFile pdf

- Left err' -> liftIO $ do

- B.hPutStr stderr err'

- B.hPut stderr $ B.pack [10]

- err 43 "Error producing PDF"

- | otherwise -> do

- let htmlFormat = format `elem`

- ["html","html4","html5","s5","slidy","slideous","dzslides","revealjs"]

- selfcontain = if optSelfContained opts && htmlFormat

- then makeSelfContained writerOptions media

- else return

- handleEntities = if htmlFormat && optAscii opts

- then toEntities

- else id

- output <- f writerOptions doc'

- selfcontain (output ++ ['\n' | not standalone]) >>=

- writerFn outputFile . handleEntities

-

-type Transform = Pandoc -> Pandoc

-

-isTextFormat :: String -> Bool

-isTextFormat s = s `notElem` ["odt","docx","epub","epub3"]

-

-externalFilter :: MonadIO m => FilePath -> [String] -> Pandoc -> m Pandoc

-externalFilter f args' d = liftIO $ do

- exists <- doesFileExist f

- isExecutable <- if exists

- then executable <$> getPermissions f

- else return True

- let (f', args'') = if exists

- then case map toLower (takeExtension f) of

- _ | isExecutable -> ("." </> f, args')

- ".py" -> ("python", f:args')

- ".hs" -> ("runhaskell", f:args')

- ".pl" -> ("perl", f:args')

- ".rb" -> ("ruby", f:args')

- ".php" -> ("php", f:args')

- ".js" -> ("node", f:args')

- _ -> (f, args')

- else (f, args')

- unless (exists && isExecutable) $ do

- mbExe <- findExecutable f'

- when (isNothing mbExe) $

- err 83 $ "Error running filter " ++ f ++ ":\n" ++

- "Could not find executable '" ++ f' ++ "'."

- env <- getEnvironment

- let env' = Just $ ("PANDOC_VERSION", pandocVersion) : env

- (exitcode, outbs) <- E.handle filterException $

- pipeProcess env' f' args'' $ encode d

- case exitcode of

- ExitSuccess -> return $ either error id $ eitherDecode' outbs

- ExitFailure ec -> err 83 $ "Error running filter " ++ f ++ "\n" ++

- "Filter returned error status " ++ show ec

- where filterException :: E.SomeException -> IO a

- filterException e = err 83 $ "Error running filter " ++ f ++ "\n" ++

- show e

-

--- | Data structure for command line options.

-data Opt = Opt

- { optTabStop :: Int -- ^ Number of spaces per tab

- , optPreserveTabs :: Bool -- ^ Preserve tabs instead of converting to spaces

- , optStandalone :: Bool -- ^ Include header, footer

- , optReader :: Maybe String -- ^ Reader format

- , optWriter :: Maybe String -- ^ Writer format

- , optTableOfContents :: Bool -- ^ Include table of contents

- , optBaseHeaderLevel :: Int -- ^ Base header level

- , optTemplate :: Maybe FilePath -- ^ Custom template

- , optVariables :: [(String,String)] -- ^ Template variables to set

- , optMetadata :: [(String, String)] -- ^ Metadata fields to set

- , optOutputFile :: FilePath -- ^ Name of output file

- , optInputFiles :: [FilePath] -- ^ Names of input files

- , optNumberSections :: Bool -- ^ Number sections in LaTeX

- , optNumberOffset :: [Int] -- ^ Starting number for sections

- , optSectionDivs :: Bool -- ^ Put sections in div tags in HTML

- , optIncremental :: Bool -- ^ Use incremental lists in Slidy/Slideous/S5

- , optSelfContained :: Bool -- ^ Make HTML accessible offline

- , optHtmlQTags :: Bool -- ^ Use <q> tags in HTML

- , optHighlightStyle :: Maybe String -- ^ Style to use for highlighted code

- , optTopLevelDivision :: TopLevelDivision -- ^ Type of the top-level divisions

- , optHTMLMathMethod :: HTMLMathMethod -- ^ Method to print HTML math

- , optReferenceDoc :: Maybe FilePath -- ^ Path of reference doc

- , optEpubStylesheet :: Maybe FilePath -- ^ EPUB stylesheet

- , optEpubMetadata :: Maybe FilePath -- ^ EPUB metadata

- , optEpubFonts :: [FilePath] -- ^ EPUB fonts to embed

- , optEpubChapterLevel :: Int -- ^ Header level at which to split chapters

- , optEpubCoverImage :: Maybe FilePath -- ^ Cover image for epub

- , optTOCDepth :: Int -- ^ Number of levels to include in TOC

- , optDumpArgs :: Bool -- ^ Output command-line arguments

- , optIgnoreArgs :: Bool -- ^ Ignore command-line arguments

- , optVerbosity :: Verbosity -- ^ Verbosity of diagnostic output

- , optLogFile :: Maybe FilePath -- ^ File to write JSON log output

- , optFailIfWarnings :: Bool -- ^ Fail on warnings

- , optReferenceLinks :: Bool -- ^ Use reference links in writing markdown, rst

- , optReferenceLocation :: ReferenceLocation -- ^ location for footnotes and link references in markdown output

- , optDpi :: Int -- ^ Dpi

- , optWrapText :: WrapOption -- ^ Options for wrapping text

- , optColumns :: Int -- ^ Line length in characters

- , optFilters :: [FilePath] -- ^ Filters to apply

- , optEmailObfuscation :: ObfuscationMethod

- , optIdentifierPrefix :: String

- , optIndentedCodeClasses :: [String] -- ^ Default classes for indented code blocks

- , optDataDir :: Maybe FilePath

- , optCiteMethod :: CiteMethod -- ^ Method to output cites

- , optListings :: Bool -- ^ Use listings package for code blocks

- , optLaTeXEngine :: String -- ^ Program to use for latex -> pdf

- , optLaTeXEngineArgs :: [String] -- ^ Flags to pass to the latex-engine

- , optSlideLevel :: Maybe Int -- ^ Header level that creates slides

- , optSetextHeaders :: Bool -- ^ Use atx headers for markdown level 1-2

- , optAscii :: Bool -- ^ Use ascii characters only in html

- , optDefaultImageExtension :: String -- ^ Default image extension

- , optExtractMedia :: Maybe FilePath -- ^ Path to extract embedded media

- , optTrackChanges :: TrackChanges -- ^ Accept or reject MS Word track-changes.

- , optFileScope :: Bool -- ^ Parse input files before combining

- , optKaTeXStylesheet :: Maybe String -- ^ Path to stylesheet for KaTeX

- , optKaTeXJS :: Maybe String -- ^ Path to js file for KaTeX

- , optTitlePrefix :: Maybe String -- ^ Prefix for title

- , optCss :: [FilePath] -- ^ CSS files to link to

- , optIncludeBeforeBody :: [FilePath] -- ^ Files to include before

- , optIncludeAfterBody :: [FilePath] -- ^ Files to include after body

- , optIncludeInHeader :: [FilePath] -- ^ Files to include in header

- }

-

--- | Defaults for command-line options.

-defaultOpts :: Opt

-defaultOpts = Opt

- { optTabStop = 4

- , optPreserveTabs = False

- , optStandalone = False

- , optReader = Nothing

- , optWriter = Nothing

- , optTableOfContents = False

- , optBaseHeaderLevel = 1

- , optTemplate = Nothing

- , optVariables = []

- , optMetadata = []

- , optOutputFile = "-" -- "-" means stdout

- , optInputFiles = []

- , optNumberSections = False

- , optNumberOffset = [0,0,0,0,0,0]

- , optSectionDivs = False

- , optIncremental = False

- , optSelfContained = False

- , optHtmlQTags = False

- , optHighlightStyle = Just "pygments"

- , optTopLevelDivision = TopLevelDefault

- , optHTMLMathMethod = PlainMath

- , optReferenceDoc = Nothing

- , optEpubStylesheet = Nothing

- , optEpubMetadata = Nothing

- , optEpubFonts = []

- , optEpubChapterLevel = 1

- , optEpubCoverImage = Nothing

- , optTOCDepth = 3

- , optDumpArgs = False

- , optIgnoreArgs = False

- , optVerbosity = WARNING

- , optLogFile = Nothing

- , optFailIfWarnings = False

- , optReferenceLinks = False

- , optReferenceLocation = EndOfDocument

- , optDpi = 96

- , optWrapText = WrapAuto

- , optColumns = 72

- , optFilters = []

- , optEmailObfuscation = NoObfuscation

- , optIdentifierPrefix = ""

- , optIndentedCodeClasses = []

- , optDataDir = Nothing

- , optCiteMethod = Citeproc

- , optListings = False

- , optLaTeXEngine = "pdflatex"

- , optLaTeXEngineArgs = []

- , optSlideLevel = Nothing

- , optSetextHeaders = True

- , optAscii = False

- , optDefaultImageExtension = ""

- , optExtractMedia = Nothing

- , optTrackChanges = AcceptChanges

- , optFileScope = False

- , optKaTeXStylesheet = Nothing

- , optKaTeXJS = Nothing

- , optTitlePrefix = Nothing

- , optCss = []

- , optIncludeBeforeBody = []

- , optIncludeAfterBody = []

- , optIncludeInHeader = []

- }

-

-addMetadata :: (String, String) -> Pandoc -> Pandoc

-addMetadata (k, v) (Pandoc meta bs) = Pandoc meta' bs

- where meta' = case lookupMeta k meta of

- Nothing -> setMeta k v' meta

- Just (MetaList xs) ->

- setMeta k (MetaList (xs ++ [v'])) meta

- Just x -> setMeta k (MetaList [x, v']) meta

- v' = readMetaValue v

-

-readMetaValue :: String -> MetaValue

-readMetaValue s = case decode (UTF8.fromString s) of

- Just (Yaml.String t) -> MetaString $ T.unpack t

- Just (Yaml.Bool b) -> MetaBool b

- _ -> MetaString s

-

--- Determine default reader based on source file extensions

-defaultReaderName :: String -> [FilePath] -> String

-defaultReaderName fallback [] = fallback

-defaultReaderName fallback (x:xs) =

- case takeExtension (map toLower x) of

- ".xhtml" -> "html"

- ".html" -> "html"

- ".htm" -> "html"

- ".md" -> "markdown"

- ".markdown" -> "markdown"

- ".tex" -> "latex"

- ".latex" -> "latex"

- ".ltx" -> "latex"

- ".rst" -> "rst"

- ".org" -> "org"

- ".lhs" -> "markdown+lhs"

- ".db" -> "docbook"

- ".opml" -> "opml"

- ".wiki" -> "mediawiki"

- ".dokuwiki" -> "dokuwiki"

- ".textile" -> "textile"

- ".native" -> "native"

- ".json" -> "json"

- ".docx" -> "docx"

- ".t2t" -> "t2t"

- ".epub" -> "epub"

- ".odt" -> "odt"

- ".pdf" -> "pdf" -- so we get an "unknown reader" error

- ".doc" -> "doc" -- so we get an "unknown reader" error

- _ -> defaultReaderName fallback xs

-

--- Determine default writer based on output file extension

-defaultWriterName :: FilePath -> String

-defaultWriterName "-" = "html" -- no output file

-defaultWriterName x =

- case takeExtension (map toLower x) of

- "" -> "markdown" -- empty extension

- ".tex" -> "latex"

- ".latex" -> "latex"

- ".ltx" -> "latex"

- ".context" -> "context"

- ".ctx" -> "context"

- ".rtf" -> "rtf"

- ".rst" -> "rst"

- ".s5" -> "s5"

- ".native" -> "native"

- ".json" -> "json"

- ".txt" -> "markdown"

- ".text" -> "markdown"

- ".md" -> "markdown"

- ".markdown" -> "markdown"

- ".textile" -> "textile"

- ".lhs" -> "markdown+lhs"

- ".texi" -> "texinfo"

- ".texinfo" -> "texinfo"

- ".db" -> "docbook"

- ".odt" -> "odt"

- ".docx" -> "docx"

- ".epub" -> "epub"

- ".org" -> "org"

- ".asciidoc" -> "asciidoc"

- ".adoc" -> "asciidoc"

- ".pdf" -> "latex"

- ".fb2" -> "fb2"

- ".opml" -> "opml"

- ".icml" -> "icml"

- ".tei.xml" -> "tei"

- ".tei" -> "tei"

- ['.',y] | y `elem` ['1'..'9'] -> "man"

- _ -> "html"

-

--- Transformations of a Pandoc document post-parsing:

-

-extractMedia :: MonadIO m => MediaBag -> FilePath -> Pandoc -> m Pandoc

-extractMedia media dir d =

- case [fp | (fp, _, _) <- mediaDirectory media] of

- [] -> return d

- fps -> do

- extractMediaBag True dir media

- return $ walk (adjustImagePath dir fps) d

-

-adjustImagePath :: FilePath -> [FilePath] -> Inline -> Inline

-adjustImagePath dir paths (Image attr lab (src, tit))

- | src `elem` paths = Image attr lab (dir ++ "/" ++ src, tit)

-adjustImagePath _ _ x = x

-

-applyTransforms :: Monad m => [Transform] -> Pandoc -> m Pandoc

-applyTransforms transforms d = return $ foldr ($) d transforms

-

- -- First we check to see if a filter is found. If not, and if it's

- -- not an absolute path, we check to see whether it's in `userdir/filters`.

- -- If not, we leave it unchanged.

-expandFilterPath :: MonadIO m => Maybe FilePath -> FilePath -> m FilePath

-expandFilterPath mbDatadir fp = liftIO $ do

- fpExists <- doesFileExist fp

- if fpExists

- then return fp

- else case mbDatadir of

- Just datadir | isRelative fp -> do

- let filterPath = (datadir </> "filters" </> fp)

- filterPathExists <- doesFileExist filterPath

- if filterPathExists

- then return filterPath

- else return fp

- _ -> return fp

-

-applyFilters :: MonadIO m

- => Maybe FilePath -> [FilePath] -> [String] -> Pandoc -> m Pandoc

-applyFilters mbDatadir filters args d = do

- expandedFilters <- mapM (expandFilterPath mbDatadir) filters

- foldrM ($) d $ map (flip externalFilter args) expandedFilters

-

-readSource :: MonadIO m => FilePath -> m String

-readSource "-" = liftIO UTF8.getContents

-readSource src = case parseURI src of

- Just u | uriScheme u `elem` ["http:","https:"] ->

- readURI src

- | uriScheme u == "file:" ->

- liftIO $ UTF8.readFile (uriPath u)

- _ -> liftIO $ UTF8.readFile src

-

-readURI :: MonadIO m => FilePath -> m String

-readURI src = do

- res <- liftIO $ openURL src

- case res of

- Left e -> liftIO $ throwIO e

- Right (bs,_) -> return $ UTF8.toString bs

-

-readFile' :: MonadIO m => FilePath -> m B.ByteString

-readFile' "-" = liftIO $ B.getContents

-readFile' f = liftIO $ B.readFile f

-

-writeFnBinary :: MonadIO m => FilePath -> B.ByteString -> m ()

-writeFnBinary "-" = liftIO . B.putStr

-writeFnBinary f = liftIO . B.writeFile (UTF8.encodePath f)

-

-writerFn :: MonadIO m => FilePath -> String -> m ()

-writerFn "-" = liftIO . UTF8.putStr

-writerFn f = liftIO . UTF8.writeFile f

-

-lookupHighlightStyle :: Maybe String -> IO (Maybe Style)

-lookupHighlightStyle Nothing = return Nothing

-lookupHighlightStyle (Just s) =

- case lookup (map toLower s) highlightingStyles of

- Just sty -> return (Just sty)

- Nothing -> err 68 $ "Unknown highlight-style " ++ s

-

--- | A list of functions, each transforming the options data structure

--- in response to a command-line option.

-options :: [OptDescr (Opt -> IO Opt)]

-options =

- [ Option "fr" ["from","read"]

- (ReqArg

- (\arg opt -> return opt { optReader = Just arg })

- "FORMAT")

- ""

-

- , Option "tw" ["to","write"]

- (ReqArg

- (\arg opt -> return opt { optWriter = Just arg })

- "FORMAT")

- ""

-

- , Option "o" ["output"]

- (ReqArg

- (\arg opt -> return opt { optOutputFile = arg })

- "FILENAME")

- "" -- "Name of output file"

-

- , Option "" ["data-dir"]

- (ReqArg

- (\arg opt -> return opt { optDataDir = Just arg })

- "DIRECTORY") -- "Directory containing pandoc data files."

- ""

-

- , Option "" ["base-header-level"]

- (ReqArg

- (\arg opt ->

- case safeRead arg of

- Just t | t > 0 && t < 6 -> do

- return opt{ optBaseHeaderLevel = t }

- _ -> err 19

- "base-header-level must be 1-5")

- "NUMBER")

- "" -- "Headers base level"

-

- , Option "" ["indented-code-classes"]

- (ReqArg

- (\arg opt -> return opt { optIndentedCodeClasses = words $

- map (\c -> if c == ',' then ' ' else c) arg })

- "STRING")

- "" -- "Classes (whitespace- or comma-separated) to use for indented code-blocks"

-

- , Option "F" ["filter"]

- (ReqArg

- (\arg opt -> return opt { optFilters = arg : optFilters opt })

- "PROGRAM")

- "" -- "External JSON filter"

-

- , Option "p" ["preserve-tabs"]

- (NoArg

- (\opt -> return opt { optPreserveTabs = True }))

- "" -- "Preserve tabs instead of converting to spaces"

-

- , Option "" ["tab-stop"]

- (ReqArg

- (\arg opt ->

- case safeRead arg of

- Just t | t > 0 -> return opt { optTabStop = t }

- _ -> err 31

- "tab-stop must be a number greater than 0")

- "NUMBER")

- "" -- "Tab stop (default 4)"

-

- , Option "" ["track-changes"]

- (ReqArg

- (\arg opt -> do

- action <- case arg of

- "accept" -> return AcceptChanges

- "reject" -> return RejectChanges

- "all" -> return AllChanges

- _ -> err 6

- ("Unknown option for track-changes: " ++ arg)

- return opt { optTrackChanges = action })

- "accept|reject|all")

- "" -- "Accepting or reject MS Word track-changes.""

-

- , Option "" ["file-scope"]

- (NoArg

- (\opt -> return opt { optFileScope = True }))

- "" -- "Parse input files before combining"

-

- , Option "" ["extract-media"]

- (ReqArg

- (\arg opt ->

- return opt { optExtractMedia = Just arg })

- "PATH")

- "" -- "Directory to which to extract embedded media"

-

- , Option "s" ["standalone"]

- (NoArg

- (\opt -> return opt { optStandalone = True }))

- "" -- "Include needed header and footer on output"

-

- , Option "" ["template"]

- (ReqArg

- (\arg opt ->

- return opt{ optTemplate = Just arg,

- optStandalone = True })

- "FILENAME")

- "" -- "Use custom template"

-

- , Option "M" ["metadata"]

- (ReqArg

- (\arg opt -> do

- let (key, val) = splitField arg

- return opt{ optMetadata = (key, val) : optMetadata opt })

- "KEY[:VALUE]")

- ""

-

- , Option "V" ["variable"]

- (ReqArg

- (\arg opt -> do

- let (key, val) = splitField arg

- return opt{ optVariables = (key, val) : optVariables opt })

- "KEY[:VALUE]")

- ""

-

- , Option "D" ["print-default-template"]

- (ReqArg

- (\arg _ -> do

- templ <- getDefaultTemplate Nothing arg

- case templ of

- Right t -> UTF8.hPutStr stdout t

- Left e -> error $ show e

- exitSuccess)

- "FORMAT")

- "" -- "Print default template for FORMAT"

-

- , Option "" ["print-default-data-file"]

- (ReqArg

- (\arg _ -> do

- readDataFile Nothing arg >>= BS.hPutStr stdout

- exitSuccess)

- "FILE")

- "" -- "Print default data file"

-

- , Option "" ["dpi"]

- (ReqArg

- (\arg opt ->

- case safeRead arg of

- Just t | t > 0 -> return opt { optDpi = t }

- _ -> err 31

- "dpi must be a number greater than 0")

- "NUMBER")

- "" -- "Dpi (default 96)"

-

- , Option "" ["wrap"]

- (ReqArg

- (\arg opt ->

- case safeRead ("Wrap" ++ uppercaseFirstLetter arg) of

- Just o -> return opt { optWrapText = o }

- Nothing -> err 77 "--wrap must be auto, none, or preserve")

- "auto|none|preserve")

- "" -- "Option for wrapping text in output"

-

- , Option "" ["columns"]

- (ReqArg

- (\arg opt ->

- case safeRead arg of

- Just t | t > 0 -> return opt { optColumns = t }

- _ -> err 33

- "columns must be a number greater than 0")

- "NUMBER")

- "" -- "Length of line in characters"

-

- , Option "" ["toc", "table-of-contents"]

- (NoArg

- (\opt -> return opt { optTableOfContents = True }))

- "" -- "Include table of contents"

-

- , Option "" ["toc-depth"]

- (ReqArg

- (\arg opt ->

- case safeRead arg of

- Just t | t >= 1 && t <= 6 ->

- return opt { optTOCDepth = t }

- _ -> err 57

- "TOC level must be a number between 1 and 6")

- "NUMBER")

- "" -- "Number of levels to include in TOC"

-

- , Option "" ["no-highlight"]

- (NoArg

- (\opt -> return opt { optHighlightStyle = Nothing }))

- "" -- "Don't highlight source code"

-

- , Option "" ["highlight-style"]

- (ReqArg

- (\arg opt -> return opt{ optHighlightStyle = Just arg })

- "STYLE")

- "" -- "Style for highlighted code"

-

- , Option "H" ["include-in-header"]

- (ReqArg

- (\arg opt -> return opt{ optIncludeInHeader =

- arg : optIncludeInHeader opt,

- optStandalone = True })

- "FILENAME")

- "" -- "File to include at end of header (implies -s)"

-

- , Option "B" ["include-before-body"]

- (ReqArg

- (\arg opt -> return opt{ optIncludeBeforeBody =

- arg : optIncludeBeforeBody opt,

- optStandalone = True })

- "FILENAME")

- "" -- "File to include before document body"

-

- , Option "A" ["include-after-body"]

- (ReqArg

- (\arg opt -> return opt{ optIncludeAfterBody =

- arg : optIncludeAfterBody opt,

- optStandalone = True })

- "FILENAME")

- "" -- "File to include after document body"

-

- , Option "" ["self-contained"]

- (NoArg

- (\opt -> return opt { optSelfContained = True,

- optStandalone = True }))

- "" -- "Make slide shows include all the needed js and css"

-

- , Option "" ["html-q-tags"]

- (NoArg

- (\opt ->

- return opt { optHtmlQTags = True }))

- "" -- "Use <q> tags for quotes in HTML"

-

- , Option "" ["ascii"]

- (NoArg

- (\opt -> return opt { optAscii = True }))

- "" -- "Use ascii characters only in HTML output"

-

- , Option "" ["reference-links"]

- (NoArg

- (\opt -> return opt { optReferenceLinks = True } ))

- "" -- "Use reference links in parsing HTML"

-

- , Option "" ["reference-location"]

- (ReqArg

- (\arg opt -> do

- action <- case arg of

- "block" -> return EndOfBlock

- "section" -> return EndOfSection

- "document" -> return EndOfDocument

- _ -> err 6

- ("Unknown option for reference-location: " ++ arg)

- return opt { optReferenceLocation = action })

- "block|section|document")

- "" -- "Accepting or reject MS Word track-changes.""

-

- , Option "" ["atx-headers"]

- (NoArg

- (\opt -> return opt { optSetextHeaders = False } ))

- "" -- "Use atx-style headers for markdown"

-

- , Option "" ["top-level-division"]

- (ReqArg

- (\arg opt -> do

- let tldName = "TopLevel" ++ uppercaseFirstLetter arg

- case safeRead tldName of

- Just tlDiv -> return opt { optTopLevelDivision = tlDiv }

- _ -> err 76 ("Top-level division must be " ++

- "section, chapter, part, or default"))

- "section|chapter|part")

- "" -- "Use top-level division type in LaTeX, ConTeXt, DocBook"

-

- , Option "N" ["number-sections"]

- (NoArg

- (\opt -> return opt { optNumberSections = True }))

- "" -- "Number sections in LaTeX"

-

- , Option "" ["number-offset"]

- (ReqArg

- (\arg opt ->

- case safeRead ('[':arg ++ "]") of

- Just ns -> return opt { optNumberOffset = ns,

- optNumberSections = True }

- _ -> err 57 "could not parse number-offset")

- "NUMBERS")

- "" -- "Starting number for sections, subsections, etc."

-

- , Option "" ["listings"]

- (NoArg

- (\opt -> return opt { optListings = True }))

- "" -- "Use listings package for LaTeX code blocks"

-

- , Option "i" ["incremental"]

- (NoArg

- (\opt -> return opt { optIncremental = True }))

- "" -- "Make list items display incrementally in Slidy/Slideous/S5"

-

- , Option "" ["slide-level"]

- (ReqArg

- (\arg opt ->

- case safeRead arg of

- Just t | t >= 1 && t <= 6 ->

- return opt { optSlideLevel = Just t }

- _ -> err 39

- "slide level must be a number between 1 and 6")

- "NUMBER")

- "" -- "Force header level for slides"

-

- , Option "" ["section-divs"]

- (NoArg

- (\opt -> return opt { optSectionDivs = True }))

- "" -- "Put sections in div tags in HTML"

-

- , Option "" ["default-image-extension"]

- (ReqArg

- (\arg opt -> return opt { optDefaultImageExtension = arg })

- "extension")

- "" -- "Default extension for extensionless images"

-

- , Option "" ["email-obfuscation"]

- (ReqArg

- (\arg opt -> do

- method <- case arg of

- "references" -> return ReferenceObfuscation

- "javascript" -> return JavascriptObfuscation

- "none" -> return NoObfuscation

- _ -> err 6

- ("Unknown obfuscation method: " ++ arg)

- return opt { optEmailObfuscation = method })

- "none|javascript|references")

- "" -- "Method for obfuscating email in HTML"

-

- , Option "" ["id-prefix"]

- (ReqArg

- (\arg opt -> return opt { optIdentifierPrefix = arg })

- "STRING")

- "" -- "Prefix to add to automatically generated HTML identifiers"

-

- , Option "T" ["title-prefix"]

- (ReqArg

- (\arg opt -> do

- let newvars = ("title-prefix", arg) : optVariables opt

- return opt { optVariables = newvars,

- optStandalone = True })

- "STRING")

- "" -- "String to prefix to HTML window title"

-

- , Option "c" ["css"]

- (ReqArg

- (\arg opt -> return opt{ optCss = arg : optCss opt })

- -- add new link to end, so it is included in proper order

- "URL")

- "" -- "Link to CSS style sheet"

-

- , Option "" ["reference-doc"]

- (ReqArg

- (\arg opt ->

- return opt { optReferenceDoc = Just arg })

- "FILENAME")

- "" -- "Path of custom reference doc"

-

- , Option "" ["epub-stylesheet"]

- (ReqArg

- (\arg opt -> return opt { optEpubStylesheet = Just arg })

- "FILENAME")

- "" -- "Path of epub.css"

-

- , Option "" ["epub-cover-image"]

- (ReqArg

- (\arg opt ->

- return opt { optVariables =

- ("epub-cover-image", arg) : optVariables opt })

- "FILENAME")

- "" -- "Path of epub cover image"

-

- , Option "" ["epub-metadata"]

- (ReqArg

- (\arg opt -> return opt { optEpubMetadata = Just arg })

- "FILENAME")

- "" -- "Path of epub metadata file"

-

- , Option "" ["epub-embed-font"]

- (ReqArg

- (\arg opt ->

- return opt{ optEpubFonts = arg : optEpubFonts opt })

- "FILE")

- "" -- "Directory of fonts to embed"

-

- , Option "" ["epub-chapter-level"]

- (ReqArg

- (\arg opt ->

- case safeRead arg of

- Just t | t >= 1 && t <= 6 ->

- return opt { optEpubChapterLevel = t }

- _ -> err 59

- "chapter level must be a number between 1 and 6")

- "NUMBER")

- "" -- "Header level at which to split chapters in EPUB"

-

- , Option "" ["latex-engine"]

- (ReqArg

- (\arg opt -> do

- let b = takeBaseName arg

- if b `elem` ["pdflatex", "lualatex", "xelatex"]

- then return opt { optLaTeXEngine = arg }

- else err 45 "latex-engine must be pdflatex, lualatex, or xelatex.")

- "PROGRAM")

- "" -- "Name of latex program to use in generating PDF"

-

- , Option "" ["latex-engine-opt"]

- (ReqArg

- (\arg opt -> do

- let oldArgs = optLaTeXEngineArgs opt

- return opt { optLaTeXEngineArgs = arg : oldArgs })

- "STRING")

- "" -- "Flags to pass to the LaTeX engine, all instances of this option are accumulated and used"

-

- , Option "" ["bibliography"]

- (ReqArg

- (\arg opt -> return opt{ optMetadata =

- ("bibliography", arg) : optMetadata opt })

- "FILE")

- ""

-

- , Option "" ["csl"]

- (ReqArg

- (\arg opt ->

- return opt{ optMetadata =

- ("csl", arg) : optMetadata opt })

- "FILE")

- ""

-

- , Option "" ["citation-abbreviations"]

- (ReqArg

- (\arg opt ->

- return opt{ optMetadata =

- ("citation-abbreviations", arg): optMetadata opt })

- "FILE")

- ""

-

- , Option "" ["natbib"]

- (NoArg

- (\opt -> return opt { optCiteMethod = Natbib }))

- "" -- "Use natbib cite commands in LaTeX output"

-

- , Option "" ["biblatex"]

- (NoArg

- (\opt -> return opt { optCiteMethod = Biblatex }))

- "" -- "Use biblatex cite commands in LaTeX output"

-

- , Option "m" ["latexmathml", "asciimathml"]

- (OptArg

- (\arg opt ->

- return opt { optHTMLMathMethod = LaTeXMathML arg })

- "URL")

- "" -- "Use LaTeXMathML script in html output"

-

- , Option "" ["mathml"]

- (NoArg

- (\opt ->

- return opt { optHTMLMathMethod = MathML }))

- "" -- "Use mathml for HTML math"

-

- , Option "" ["mimetex"]

- (OptArg

- (\arg opt -> do

- let url' = case arg of

- Just u -> u ++ "?"

- Nothing -> "/cgi-bin/mimetex.cgi?"

- return opt { optHTMLMathMethod = WebTeX url' })

- "URL")

- "" -- "Use mimetex for HTML math"

-

- , Option "" ["webtex"]

- (OptArg

- (\arg opt -> do

- let url' = fromMaybe "https://latex.codecogs.com/png.latex?" arg

- return opt { optHTMLMathMethod = WebTeX url' })

- "URL")

- "" -- "Use web service for HTML math"

-

- , Option "" ["jsmath"]

- (OptArg

- (\arg opt -> return opt { optHTMLMathMethod = JsMath arg})

- "URL")

- "" -- "Use jsMath for HTML math"

-

- , Option "" ["mathjax"]

- (OptArg

- (\arg opt -> do

- let url' = fromMaybe "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_CHTML-full" arg

- return opt { optHTMLMathMethod = MathJax url'})

- "URL")

- "" -- "Use MathJax for HTML math"

- , Option "" ["katex"]

- (OptArg

- (\arg opt ->

- return opt

- { optKaTeXJS =

- arg <|> Just "https://cdnjs.cloudflare.com/ajax/libs/KaTeX/0.6.0/katex.min.js"})

- "URL")

- "" -- Use KaTeX for HTML Math

-

- , Option "" ["katex-stylesheet"]

- (ReqArg

- (\arg opt ->

- return opt { optKaTeXStylesheet = Just arg })

- "URL")

- "" -- Set the KaTeX Stylesheet location

-

- , Option "" ["gladtex"]

- (NoArg

- (\opt -> return opt { optHTMLMathMethod = GladTeX }))

- "" -- "Use gladtex for HTML math"

-

- , Option "" ["trace"]

- (NoArg

- (\opt -> return opt { optVerbosity = DEBUG }))

- "" -- "Turn on diagnostic tracing in readers."

-

- , Option "" ["dump-args"]

- (NoArg

- (\opt -> return opt { optDumpArgs = True }))

- "" -- "Print output filename and arguments to stdout."

-

- , Option "" ["ignore-args"]

- (NoArg

- (\opt -> return opt { optIgnoreArgs = True }))

- "" -- "Ignore command-line arguments."

-

- , Option "" ["verbose"]

- (NoArg

- (\opt -> return opt { optVerbosity = INFO }))

- "" -- "Verbose diagnostic output."

-

- , Option "" ["quiet"]

- (NoArg

- (\opt -> return opt { optVerbosity = ERROR }))

- "" -- "Suppress warnings."

-

- , Option "" ["fail-if-warnings"]

- (NoArg

- (\opt -> return opt { optFailIfWarnings = True }))

- "" -- "Exit with error status if there were warnings."

-

- , Option "" ["log"]

- (ReqArg

- (\arg opt -> return opt{ optLogFile = Just arg })

- "FILE")

- "" -- "Log messages in JSON format to this file."

-

- , Option "" ["bash-completion"]

- (NoArg

- (\_ -> do

- ddir <- getDataDir

- tpl <- readDataFileUTF8 Nothing "bash_completion.tpl"

- let optnames (Option shorts longs _ _) =

- map (\c -> ['-',c]) shorts ++

- map ("--" ++) longs

- let allopts = unwords (concatMap optnames options)

- UTF8.hPutStrLn stdout $ printf tpl allopts

- (unwords readers'names)

- (unwords writers'names)

- (unwords $ map fst highlightingStyles)

- ddir

- exitSuccess ))

- "" -- "Print bash completion script"

-

- , Option "" ["list-input-formats"]

- (NoArg

- (\_ -> do

- mapM_ (UTF8.hPutStrLn stdout) readers'names

- exitSuccess ))

- ""

-

- , Option "" ["list-output-formats"]

- (NoArg

- (\_ -> do

- mapM_ (UTF8.hPutStrLn stdout) writers'names

- exitSuccess ))

- ""

-

- , Option "" ["list-extensions"]

- (NoArg

- (\_ -> do

- let showExt x = drop 4 (show x) ++

- if extensionEnabled x pandocExtensions

- then " +"

- else " -"

- mapM_ (UTF8.hPutStrLn stdout . showExt)

- ([minBound..maxBound] :: [Extension])

- exitSuccess ))

- ""

-

- , Option "" ["list-highlight-languages"]

- (NoArg

- (\_ -> do

- let langs = [ T.unpack (T.toLower (sShortname s))

- | s <- M.elems defaultSyntaxMap

- , sShortname s `notElem`

- [T.pack "Alert", T.pack "Alert_indent"]

- ]

- mapM_ (UTF8.hPutStrLn stdout) langs

- exitSuccess ))

- ""

-

- , Option "" ["list-highlight-styles"]

- (NoArg

- (\_ -> do

- mapM_ (UTF8.hPutStrLn stdout) $

- map fst highlightingStyles

- exitSuccess ))

- ""

-

- , Option "v" ["version"]

- (NoArg

- (\_ -> do

- prg <- getProgName

- defaultDatadir <- E.catch

- (getAppUserDataDirectory "pandoc")

- (\e -> let _ = (e :: E.SomeException)

- in return "")

- UTF8.hPutStrLn stdout (prg ++ " " ++ pandocVersion ++

- compileInfo ++ "\nDefault user data directory: " ++

- defaultDatadir ++ copyrightMessage)

- exitSuccess ))

- "" -- "Print version"

-

- , Option "h" ["help"]

- (NoArg

- (\_ -> do

- prg <- getProgName

- UTF8.hPutStr stdout (usageMessage prg options)

- exitSuccess ))

- "" -- "Show help"

-

- ]

-

--- Returns usage message

-usageMessage :: String -> [OptDescr (Opt -> IO Opt)] -> String

-usageMessage programName = usageInfo (programName ++ " [OPTIONS] [FILES]")

-

-copyrightMessage :: String

-copyrightMessage = intercalate "\n" [

- "",

- "Copyright (C) 2006-2017 John MacFarlane",

- "Web: http://pandoc.org",

- "This is free software; see the source for copying conditions.",

- "There is no warranty, not even for merchantability or fitness",

- "for a particular purpose." ]

-

-compileInfo :: String

-compileInfo =

- "\nCompiled with pandoc-types " ++ VERSION_pandoc_types ++ ", texmath " ++

- VERSION_texmath ++ ", skylighting " ++ VERSION_skylighting

-

-handleUnrecognizedOption :: String -> [String] -> [String]

-handleUnrecognizedOption "--smart" =

- (("--smart/-S has been removed. Use +smart or -smart extension instead.\n" ++

- "For example: pandoc -f markdown+smart -t markdown-smart.") :)

-handleUnrecognizedOption "-S" = handleUnrecognizedOption "--smart"

-handleUnrecognizedOption "--old-dashes" =

- ("--old-dashes has been removed. Use +old_dashes extension instead." :)

-handleUnrecognizedOption "--no-wrap" =

- ("--no-wrap has been removed. Use --wrap=none instead." :)

-handleUnrecognizedOption "--chapters" =

- ("--chapters has been removed. Use --top-level-division=chapter instead." :)

-handleUnrecognizedOption "--reference-docx" =

- ("--reference-docx has been removed. Use --reference-doc instead." :)

-handleUnrecognizedOption "--reference-odt" =

- ("--reference-odt has been removed. Use --reference-doc instead." :)

-handleUnrecognizedOption "--parse-raw" =

- (("--parse-raw/-R has been removed. Use +raw_html or +raw_tex extension.\n") :)

-handleUnrecognizedOption "-R" = handleUnrecognizedOption "--parse-raw"

-handleUnrecognizedOption x =

- (("Unknown option " ++ x ++ ".") :)

-

-uppercaseFirstLetter :: String -> String

-uppercaseFirstLetter (c:cs) = toUpper c : cs

-uppercaseFirstLetter [] = []

-

-readers'names :: [String]

-readers'names = sort (map fst (readers :: [(String, Reader PandocIO)]))

-

-writers'names :: [String]

-writers'names = sort (map fst (writers :: [(String, Writer PandocIO)]))

-

-splitField :: String -> (String, String)

-splitField s =

- case break (`elem` ":=") s of

- (k,_:v) -> (k,v)

- (k,[]) -> (k,"true")

-

-{-

-Copyright (C) 2013-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.Asciify

- Copyright : Copyright (C) 2013-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Function to convert accented latin letters to their unaccented

-ascii equivalents (used in constructing HTML identifiers).

--}

-module Text.Pandoc.Asciify (toAsciiChar)

-where

-import qualified Data.Map as M

-import Data.Char (isAscii)

-

-toAsciiChar :: Char -> Maybe Char

-toAsciiChar c | isAscii c = Just c

- | otherwise = M.lookup c asciiMap

-

-asciiMap :: M.Map Char Char

-asciiMap = M.fromList

- [('\192','A')

- ,('\193','A')

- ,('\194','A')

- ,('\195','A')

- ,('\196','A')

- ,('\197','A')

- ,('\199','C')

- ,('\200','E')

- ,('\201','E')

- ,('\202','E')

- ,('\203','E')

- ,('\204','I')

- ,('\205','I')

- ,('\206','I')

- ,('\207','I')

- ,('\209','N')

- ,('\210','O')

- ,('\211','O')

- ,('\212','O')

- ,('\213','O')

- ,('\214','O')

- ,('\217','U')

- ,('\218','U')

- ,('\219','U')

- ,('\220','U')

- ,('\221','Y')

- ,('\224','a')

- ,('\225','a')

- ,('\226','a')

- ,('\227','a')

- ,('\228','a')

- ,('\229','a')

- ,('\231','c')

- ,('\232','e')

- ,('\233','e')

- ,('\234','e')

- ,('\235','e')

- ,('\236','i')

- ,('\237','i')

- ,('\238','i')

- ,('\239','i')

- ,('\241','n')

- ,('\242','o')

- ,('\243','o')

- ,('\244','o')

- ,('\245','o')

- ,('\246','o')

- ,('\249','u')

- ,('\250','u')

- ,('\251','u')

- ,('\252','u')

- ,('\253','y')

- ,('\255','y')

- ,('\256','A')

- ,('\257','a')

- ,('\258','A')

- ,('\259','a')

- ,('\260','A')

- ,('\261','a')

- ,('\262','C')

- ,('\263','c')

- ,('\264','C')

- ,('\265','c')

- ,('\266','C')

- ,('\267','c')

- ,('\268','C')

- ,('\269','c')

- ,('\270','D')

- ,('\271','d')

- ,('\274','E')

- ,('\275','e')

- ,('\276','E')

- ,('\277','e')

- ,('\278','E')

- ,('\279','e')

- ,('\280','E')

- ,('\281','e')

- ,('\282','E')

- ,('\283','e')

- ,('\284','G')

- ,('\285','g')

- ,('\286','G')

- ,('\287','g')

- ,('\288','G')

- ,('\289','g')

- ,('\290','G')

- ,('\291','g')

- ,('\292','H')

- ,('\293','h')

- ,('\296','I')

- ,('\297','i')

- ,('\298','I')

- ,('\299','i')

- ,('\300','I')

- ,('\301','i')

- ,('\302','I')

- ,('\303','i')

- ,('\304','I')

- ,('\308','J')

- ,('\309','j')

- ,('\310','K')

- ,('\311','k')

- ,('\313','L')

- ,('\314','l')

- ,('\315','L')

- ,('\316','l')

- ,('\317','L')

- ,('\318','l')

- ,('\323','N')

- ,('\324','n')

- ,('\325','N')

- ,('\326','n')

- ,('\327','N')

- ,('\328','n')

- ,('\332','O')

- ,('\333','o')

- ,('\334','O')

- ,('\335','o')

- ,('\336','O')

- ,('\337','o')

- ,('\340','R')

- ,('\341','r')

- ,('\342','R')

- ,('\343','r')

- ,('\344','R')

- ,('\345','r')

- ,('\346','S')

- ,('\347','s')

- ,('\348','S')

- ,('\349','s')

- ,('\350','S')

- ,('\351','s')

- ,('\352','S')

- ,('\353','s')

- ,('\354','T')

- ,('\355','t')

- ,('\356','T')

- ,('\357','t')

- ,('\360','U')

- ,('\361','u')

- ,('\362','U')

- ,('\363','u')

- ,('\364','U')

- ,('\365','u')

- ,('\366','U')

- ,('\367','u')

- ,('\368','U')

- ,('\369','u')

- ,('\370','U')

- ,('\371','u')

- ,('\372','W')

- ,('\373','w')

- ,('\374','Y')

- ,('\375','y')

- ,('\376','Y')

- ,('\377','Z')

- ,('\378','z')

- ,('\379','Z')

- ,('\380','z')

- ,('\381','Z')

- ,('\382','z')

- ,('\416','O')

- ,('\417','o')

- ,('\431','U')

- ,('\432','u')

- ,('\461','A')

- ,('\462','a')

- ,('\463','I')

- ,('\464','i')

- ,('\465','O')

- ,('\466','o')

- ,('\467','U')

- ,('\468','u')

- ,('\486','G')

- ,('\487','g')

- ,('\488','K')

- ,('\489','k')

- ,('\490','O')

- ,('\491','o')

- ,('\496','j')

- ,('\500','G')

- ,('\501','g')

- ,('\504','N')

- ,('\505','n')

- ,('\512','A')

- ,('\513','a')

- ,('\514','A')

- ,('\515','a')

- ,('\516','E')

- ,('\517','e')

- ,('\518','E')

- ,('\519','e')

- ,('\520','I')

- ,('\521','i')

- ,('\522','I')

- ,('\523','i')

- ,('\524','O')

- ,('\525','o')

- ,('\526','O')

- ,('\527','o')

- ,('\528','R')

- ,('\529','r')

- ,('\530','R')

- ,('\531','r')

- ,('\532','U')

- ,('\533','u')

- ,('\534','U')

- ,('\535','u')

- ,('\536','S')

- ,('\537','s')

- ,('\538','T')

- ,('\539','t')

- ,('\542','H')

- ,('\543','h')

- ,('\550','A')

- ,('\551','a')

- ,('\552','E')

- ,('\553','e')

- ,('\558','O')

- ,('\559','o')

- ,('\562','Y')

- ,('\563','y')

- ,('\894',';')

- ,('\7680','A')

- ,('\7681','a')

- ,('\7682','B')

- ,('\7683','b')

- ,('\7684','B')

- ,('\7685','b')

- ,('\7686','B')

- ,('\7687','b')

- ,('\7690','D')

- ,('\7691','d')

- ,('\7692','D')

- ,('\7693','d')

- ,('\7694','D')

- ,('\7695','d')

- ,('\7696','D')

- ,('\7697','d')

- ,('\7698','D')

- ,('\7699','d')

- ,('\7704','E')

- ,('\7705','e')

- ,('\7706','E')

- ,('\7707','e')

- ,('\7710','F')

- ,('\7711','f')

- ,('\7712','G')

- ,('\7713','g')

- ,('\7714','H')

- ,('\7715','h')

- ,('\7716','H')

- ,('\7717','h')

- ,('\7718','H')

- ,('\7719','h')

- ,('\7720','H')

- ,('\7721','h')

- ,('\7722','H')

- ,('\7723','h')

- ,('\7724','I')

- ,('\7725','i')

- ,('\7728','K')

- ,('\7729','k')

- ,('\7730','K')

- ,('\7731','k')

- ,('\7732','K')

- ,('\7733','k')

- ,('\7734','L')

- ,('\7735','l')

- ,('\7738','L')

- ,('\7739','l')

- ,('\7740','L')

- ,('\7741','l')

- ,('\7742','M')

- ,('\7743','m')

- ,('\7744','M')

- ,('\7745','m')

- ,('\7746','M')

- ,('\7747','m')

- ,('\7748','N')

- ,('\7749','n')

- ,('\7750','N')

- ,('\7751','n')

- ,('\7752','N')

- ,('\7753','n')

- ,('\7754','N')

- ,('\7755','n')

- ,('\7764','P')

- ,('\7765','p')

- ,('\7766','P')

- ,('\7767','p')

- ,('\7768','R')

- ,('\7769','r')

- ,('\7770','R')

- ,('\7771','r')

- ,('\7774','R')

- ,('\7775','r')

- ,('\7776','S')

- ,('\7777','s')

- ,('\7778','S')

- ,('\7779','s')

- ,('\7786','T')

- ,('\7787','t')

- ,('\7788','T')

- ,('\7789','t')

- ,('\7790','T')

- ,('\7791','t')

- ,('\7792','T')

- ,('\7793','t')

- ,('\7794','U')

- ,('\7795','u')

- ,('\7796','U')

- ,('\7797','u')

- ,('\7798','U')

- ,('\7799','u')

- ,('\7804','V')

- ,('\7805','v')

- ,('\7806','V')

- ,('\7807','v')

- ,('\7808','W')

- ,('\7809','w')

- ,('\7810','W')

- ,('\7811','w')

- ,('\7812','W')

- ,('\7813','w')

- ,('\7814','W')

- ,('\7815','w')

- ,('\7816','W')

- ,('\7817','w')

- ,('\7818','X')

- ,('\7819','x')

- ,('\7820','X')

- ,('\7821','x')

- ,('\7822','Y')

- ,('\7823','y')

- ,('\7824','Z')

- ,('\7825','z')

- ,('\7826','Z')

- ,('\7827','z')

- ,('\7828','Z')

- ,('\7829','z')

- ,('\7830','h')

- ,('\7831','t')

- ,('\7832','w')

- ,('\7833','y')

- ,('\7840','A')

- ,('\7841','a')

- ,('\7842','A')

- ,('\7843','a')

- ,('\7864','E')

- ,('\7865','e')

- ,('\7866','E')

- ,('\7867','e')

- ,('\7868','E')

- ,('\7869','e')

- ,('\7880','I')

- ,('\7881','i')

- ,('\7882','I')

- ,('\7883','i')

- ,('\7884','O')

- ,('\7885','o')

- ,('\7886','O')

- ,('\7887','o')

- ,('\7908','U')

- ,('\7909','u')

- ,('\7910','U')

- ,('\7911','u')

- ,('\7922','Y')

- ,('\7923','y')

- ,('\7924','Y')

- ,('\7925','y')

- ,('\7926','Y')

- ,('\7927','y')

- ,('\7928','Y')

- ,('\7929','y')

- ,('\8175','`')

- ,('\8490','K')

- ,('\8800','=')

- ,('\8814','<')

- ,('\8815','>')

- ]

-module Text.Pandoc.CSS ( foldOrElse

- , pickStyleAttrProps

- , pickStylesToKVs

- )

-where

-

-import Text.Pandoc.Shared (trim)

-import Text.Parsec

-import Text.Parsec.String

-

-ruleParser :: Parser (String, String)

-ruleParser = do

- p <- many1 (noneOf ":") <* char ':'

- v <- many1 (noneOf ":;") <* (optional $ char ';') <* spaces

- return (trim p, trim v)

-

-styleAttrParser :: Parser [(String, String)]

-styleAttrParser = many1 ruleParser

-

-orElse :: Eq a => a -> a -> a -> a

-orElse v x y = if v == x then y else x

-

-foldOrElse :: Eq a => a -> [a] -> a

-foldOrElse v xs = foldr (orElse v) v xs

-

-eitherToMaybe :: Either a b -> Maybe b

-eitherToMaybe (Right x) = Just x

-eitherToMaybe _ = Nothing

-

--- | takes a list of keys/properties and a CSS string and

--- returns the corresponding key-value-pairs.

-pickStylesToKVs :: [String] -> String -> [(String, String)]

-pickStylesToKVs props styleAttr =

- case parse styleAttrParser "" styleAttr of

- Left _ -> []

- Right styles -> filter (\s -> fst s `elem` props) styles

-

--- | takes a list of key/property synonyms and a CSS string and maybe

--- returns the value of the first match (in order of the supplied list)

-pickStyleAttrProps :: [String] -> String -> Maybe String

-pickStyleAttrProps lookupProps styleAttr = do

- styles <- eitherToMaybe $ parse styleAttrParser "" styleAttr

- foldOrElse Nothing $ map (flip lookup styles) lookupProps

-{-# LANGUAGE DeriveFunctor, DeriveDataTypeable, TypeSynonymInstances,

-FlexibleInstances, GeneralizedNewtypeDeriving, FlexibleContexts #-}

-

-{-

-Copyright (C) 2016 Jesse Rosenthal <jrosenthal@jhu.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.Class

- Copyright : Copyright (C) 2016 Jesse Rosenthal

- License : GNU GPL, version 2 or above

-

- Maintainer : Jesse Rosenthal <jrosenthal@jhu.edu>

- Stability : alpha

- Portability : portable

-

-Typeclass for pandoc readers and writers, allowing both IO and pure instances.

--}

-

-module Text.Pandoc.Class ( PandocMonad(..)

- , CommonState(..)

- , PureState(..)

- , getPureState

- , getsPureState

- , putPureState

- , modifyPureState

- , getPOSIXTime

- , getZonedTime

- , readFileFromDirs

- , report

- , getLog

- , setVerbosity

- , getMediaBag

- , setMediaBag

- , insertMedia

- , fetchItem

- , getInputFiles

- , getOutputFile

- , PandocIO(..)

- , PandocPure(..)

- , FileTree(..)

- , FileInfo(..)

- , runIO

- , runIOorExplode

- , runPure

- , withMediaBag

- ) where

-

-import Prelude hiding (readFile)

-import System.Random (StdGen, next, mkStdGen)

-import qualified System.Random as IO (newStdGen)

-import Codec.Archive.Zip (Archive, fromArchive, emptyArchive)

-import Data.Unique (hashUnique)

-import qualified Data.Unique as IO (newUnique)

-import qualified Text.Pandoc.Shared as IO ( readDataFile

- , openURL )

-import qualified Text.Pandoc.UTF8 as UTF8

-import Text.Pandoc.Compat.Time (UTCTime)

-import Text.Pandoc.Logging

-import Text.Parsec (ParsecT)

-import qualified Text.Pandoc.Compat.Time as IO (getCurrentTime)

-import Text.Pandoc.MIME (MimeType, getMimeType)

-import Data.Time.Clock.POSIX ( utcTimeToPOSIXSeconds

- , posixSecondsToUTCTime

- , POSIXTime )

-import Data.Time.LocalTime (TimeZone, ZonedTime, utcToZonedTime, utc)

-import Network.URI ( escapeURIString, nonStrictRelativeTo,

- unEscapeString, parseURIReference, isAllowedInURI,

- parseURI, URI(..) )

-import qualified Data.Time.LocalTime as IO (getCurrentTimeZone)

-import Text.Pandoc.MediaBag (MediaBag, lookupMedia)

-import qualified Text.Pandoc.MediaBag as MB

-import qualified Data.ByteString as B

-import qualified Data.ByteString.Lazy as BL

-import qualified System.Environment as IO (lookupEnv)

-import System.FilePath.Glob (match, compile)

-import System.FilePath ((</>), takeExtension, dropExtension)

-import qualified System.FilePath.Glob as IO (glob)

-import qualified System.Directory as IO (getModificationTime)

-import Control.Monad as M (fail)

-import Control.Monad.Reader (ReaderT)

-import Control.Monad.State

-import Control.Monad.Except

-import Control.Monad.Writer (WriterT)

-import Control.Monad.RWS (RWST)

-import Data.Word (Word8)

-import Data.Default

-import System.IO.Error

-import System.IO (stderr)

-import qualified Data.Map as M

-import Text.Pandoc.Error

-import Text.Printf (printf)

-

-class (Functor m, Applicative m, Monad m, MonadError PandocError m)

- => PandocMonad m where

- lookupEnv :: String -> m (Maybe String)

- getCurrentTime :: m UTCTime

- getCurrentTimeZone :: m TimeZone

- newStdGen :: m StdGen

- newUniqueHash :: m Int

- openURL :: String -> m (B.ByteString, Maybe MimeType)

- readFileLazy :: FilePath -> m BL.ByteString

- readFileStrict :: FilePath -> m B.ByteString

- readDataFile :: Maybe FilePath

- -> FilePath

- -> m B.ByteString

- glob :: String -> m [FilePath]

- getModificationTime :: FilePath -> m UTCTime

- getCommonState :: m CommonState

- putCommonState :: CommonState -> m ()

-

- getsCommonState :: (CommonState -> a) -> m a

- getsCommonState f = f <$> getCommonState

-

- modifyCommonState :: (CommonState -> CommonState) -> m ()

- modifyCommonState f = getCommonState >>= putCommonState . f

-

- logOutput :: LogMessage -> m ()

-

--- Functions defined for all PandocMonad instances

-

-setVerbosity :: PandocMonad m => Verbosity -> m ()

-setVerbosity verbosity =

- modifyCommonState $ \st -> st{ stVerbosity = verbosity }

-

-getLog :: PandocMonad m => m [LogMessage]

-getLog = reverse <$> getsCommonState stLog

-

-report :: PandocMonad m => LogMessage -> m ()

-report msg = do

- verbosity <- getsCommonState stVerbosity

- let level = messageVerbosity msg

- when (level <= verbosity) $ do

- logOutput msg

- unless (level == DEBUG) $

- modifyCommonState $ \st -> st{ stLog = msg : stLog st }

-

-setMediaBag :: PandocMonad m => MediaBag -> m ()

-setMediaBag mb = modifyCommonState $ \st -> st{stMediaBag = mb}

-

-getMediaBag :: PandocMonad m => m MediaBag

-getMediaBag = getsCommonState stMediaBag

-

-insertMedia :: PandocMonad m => FilePath -> Maybe MimeType -> BL.ByteString -> m ()

-insertMedia fp mime bs = do

- mb <- getsCommonState stMediaBag

- let mb' = MB.insertMedia fp mime bs mb

- modifyCommonState $ \st -> st{stMediaBag = mb' }

-

-getInputFiles :: PandocMonad m => m (Maybe [FilePath])

-getInputFiles = getsCommonState stInputFiles

-

-getOutputFile :: PandocMonad m => m (Maybe FilePath)

-getOutputFile = getsCommonState stOutputFile

-

-getPOSIXTime :: (PandocMonad m) => m POSIXTime

-getPOSIXTime = utcTimeToPOSIXSeconds <$> getCurrentTime

-

-getZonedTime :: (PandocMonad m) => m ZonedTime

-getZonedTime = do

- t <- getCurrentTime

- tz <- getCurrentTimeZone

- return $ utcToZonedTime tz t

-

--- | Read file, checking in any number of directories.

-readFileFromDirs :: PandocMonad m => [FilePath] -> FilePath -> m (Maybe String)

-readFileFromDirs [] _ = return Nothing

-readFileFromDirs (d:ds) f = catchError

- ((Just . UTF8.toStringLazy) <$> readFileLazy (d </> f))

- (\_ -> readFileFromDirs ds f)

-

---

-

-data CommonState = CommonState { stLog :: [LogMessage]

- , stMediaBag :: MediaBag

- , stInputFiles :: Maybe [FilePath]

- , stOutputFile :: Maybe FilePath

- , stVerbosity :: Verbosity

- }

-

-instance Default CommonState where

- def = CommonState { stLog = []

- , stMediaBag = mempty

- , stInputFiles = Nothing

- , stOutputFile = Nothing

- , stVerbosity = WARNING

- }

-

-runIO :: PandocIO a -> IO (Either PandocError a)

-runIO ma = flip evalStateT def $ runExceptT $ unPandocIO ma

-

-withMediaBag :: PandocMonad m => m a -> m (a, MediaBag)

-withMediaBag ma = ((,)) <$> ma <*> getMediaBag

-

-runIOorExplode :: PandocIO a -> IO a

-runIOorExplode ma = runIO ma >>= handleError

-

-newtype PandocIO a = PandocIO {

- unPandocIO :: ExceptT PandocError (StateT CommonState IO) a

- } deriving ( MonadIO

- , Functor

- , Applicative

- , Monad

- , MonadError PandocError

- )

-

-instance PandocMonad PandocIO where

- lookupEnv = liftIO . IO.lookupEnv

- getCurrentTime = liftIO IO.getCurrentTime

- getCurrentTimeZone = liftIO IO.getCurrentTimeZone

- newStdGen = liftIO IO.newStdGen

- newUniqueHash = hashUnique <$> (liftIO IO.newUnique)

- openURL u = do

- eitherRes <- liftIO $ (tryIOError $ IO.openURL u)

- case eitherRes of

- Right (Right res) -> return res

- Right (Left _) -> throwError $ PandocFileReadError u

- Left _ -> throwError $ PandocFileReadError u

- readFileLazy s = do

- eitherBS <- liftIO (tryIOError $ BL.readFile s)

- case eitherBS of

- Right bs -> return bs

- Left _ -> throwError $ PandocFileReadError s

- readFileStrict s = do

- eitherBS <- liftIO (tryIOError $ B.readFile s)

- case eitherBS of

- Right bs -> return bs

- Left _ -> throwError $ PandocFileReadError s

- -- TODO: Make this more sensitive to the different sorts of failure

- readDataFile mfp fname = do

- eitherBS <- liftIO (tryIOError $ IO.readDataFile mfp fname)

- case eitherBS of

- Right bs -> return bs

- Left _ -> throwError $ PandocFileReadError fname

- glob = liftIO . IO.glob

- getModificationTime fp = do

- eitherMtime <- liftIO (tryIOError $ IO.getModificationTime fp)

- case eitherMtime of

- Right mtime -> return mtime

- Left _ -> throwError $ PandocFileReadError fp

- getCommonState = PandocIO $ lift get

- putCommonState x = PandocIO $ lift $ put x

- logOutput msg =

- liftIO $ UTF8.hPutStrLn stderr $ printf "%-7s %s"

- (show (messageVerbosity msg)) (showLogMessage msg)

-

--- | Specialized version of parseURIReference that disallows

--- single-letter schemes. Reason: these are usually windows absolute

--- paths.

-parseURIReference' :: String -> Maybe URI

-parseURIReference' s =

- case parseURIReference s of

- Just u

- | length (uriScheme u) > 2 -> Just u

- | null (uriScheme u) -> Just u -- protocol-relative

- _ -> Nothing

-

--- | Fetch an image or other item from the local filesystem or the net.

--- Returns raw content and maybe mime type.

-fetchItem :: PandocMonad m

- => Maybe String

- -> String

- -> m (B.ByteString, Maybe MimeType)

-fetchItem sourceURL s = do

- mediabag <- getMediaBag

- case lookupMedia s mediabag of

- Just (mime, bs) -> return $ (BL.toStrict bs, Just mime)

- Nothing -> downloadOrRead sourceURL s

-

-downloadOrRead :: PandocMonad m

- => Maybe String

- -> String

- -> m (B.ByteString, Maybe MimeType)

-downloadOrRead sourceURL s = do

- case (sourceURL >>= parseURIReference' .

- ensureEscaped, ensureEscaped s) of

- (Just u, s') -> -- try fetching from relative path at source

- case parseURIReference' s' of

- Just u' -> openURL $ show $ u' `nonStrictRelativeTo` u

- Nothing -> openURL s' -- will throw error

- (Nothing, s'@('/':'/':_)) -> -- protocol-relative URI

- case parseURIReference' s' of

- Just u' -> openURL $ show $ u' `nonStrictRelativeTo` httpcolon

- Nothing -> openURL s' -- will throw error

- (Nothing, s') ->

- case parseURI s' of -- requires absolute URI

- -- We don't want to treat C:/ as a scheme:

- Just u' | length (uriScheme u') > 2 -> openURL (show u')

- Just u' | uriScheme u' == "file:" ->

- readLocalFile $ dropWhile (=='/') (uriPath u')

- _ -> readLocalFile fp -- get from local file system

- where readLocalFile f = do

- cont <- readFileStrict f

- return (cont, mime)

- httpcolon = URI{ uriScheme = "http:",

- uriAuthority = Nothing,

- uriPath = "",

- uriQuery = "",

- uriFragment = "" }

- dropFragmentAndQuery = takeWhile (\c -> c /= '?' && c /= '#')

- fp = unEscapeString $ dropFragmentAndQuery s

- mime = case takeExtension fp of

- ".gz" -> getMimeType $ dropExtension fp

- ".svgz" -> getMimeType $ dropExtension fp ++ ".svg"

- x -> getMimeType x

- ensureEscaped = escapeURIString isAllowedInURI . map convertSlash

- convertSlash '\\' = '/'

- convertSlash x = x

-

-data PureState = PureState { stStdGen :: StdGen

- , stWord8Store :: [Word8] -- should be

- -- inifinite,

- -- i.e. [1..]

- , stUniqStore :: [Int] -- should be

- -- inifinite and

- -- contain every

- -- element at most

- -- once, e.g. [1..]

- , stEnv :: [(String, String)]

- , stTime :: UTCTime

- , stTimeZone :: TimeZone

- , stReferenceDocx :: Archive

- , stReferenceODT :: Archive

- , stFiles :: FileTree

- , stUserDataDir :: FileTree

- , stCabalDataDir :: FileTree

- , stFontFiles :: [FilePath]

- }

-

-instance Default PureState where

- def = PureState { stStdGen = mkStdGen 1848

- , stWord8Store = [1..]

- , stUniqStore = [1..]

- , stEnv = [("USER", "pandoc-user")]

- , stTime = posixSecondsToUTCTime 0

- , stTimeZone = utc

- , stReferenceDocx = emptyArchive

- , stReferenceODT = emptyArchive

- , stFiles = mempty

- , stUserDataDir = mempty

- , stCabalDataDir = mempty

- , stFontFiles = []

- }

-

-

-getPureState :: PandocPure PureState

-getPureState = PandocPure $ lift $ lift $ get

-

-getsPureState :: (PureState -> a) -> PandocPure a

-getsPureState f = f <$> getPureState

-

-putPureState :: PureState -> PandocPure ()

-putPureState ps= PandocPure $ lift $ lift $ put ps

-

-modifyPureState :: (PureState -> PureState) -> PandocPure ()

-modifyPureState f = PandocPure $ lift $ lift $ modify f

-

-

-data FileInfo = FileInfo { infoFileMTime :: UTCTime

- , infoFileContents :: B.ByteString

- }

-

-newtype FileTree = FileTree {unFileTree :: M.Map FilePath FileInfo}

- deriving (Monoid)

-

-getFileInfo :: FilePath -> FileTree -> Maybe FileInfo

-getFileInfo fp tree = M.lookup fp $ unFileTree tree

-

-

-newtype PandocPure a = PandocPure {

- unPandocPure :: ExceptT PandocError

- (StateT CommonState (State PureState)) a

- } deriving ( Functor

- , Applicative

- , Monad

- , MonadError PandocError

- )

-

-runPure :: PandocPure a -> Either PandocError a

-runPure x = flip evalState def $

- flip evalStateT def $

- runExceptT $

- unPandocPure x

-

-instance PandocMonad PandocPure where

- lookupEnv s = do

- env <- getsPureState stEnv

- return (lookup s env)

-

- getCurrentTime = getsPureState stTime

-

- getCurrentTimeZone = getsPureState stTimeZone

-

- newStdGen = do

- g <- getsPureState stStdGen

- let (_, nxtGen) = next g

- modifyPureState $ \st -> st { stStdGen = nxtGen }

- return g

-

- newUniqueHash = do

- uniqs <- getsPureState stUniqStore

- case uniqs of

- u : us -> do

- modifyPureState $ \st -> st { stUniqStore = us }

- return u

- _ -> M.fail "uniq store ran out of elements"

- openURL _ = throwError $ PandocSomeError "Cannot open URL in PandocPure"

- readFileLazy fp = do

- fps <- getsPureState stFiles

- case infoFileContents <$> getFileInfo fp fps of

- Just bs -> return (BL.fromStrict bs)

- Nothing -> throwError $ PandocFileReadError fp

- readFileStrict fp = do

- fps <- getsPureState stFiles

- case infoFileContents <$> getFileInfo fp fps of

- Just bs -> return bs

- Nothing -> throwError $ PandocFileReadError fp

- readDataFile Nothing "reference.docx" = do

- (B.concat . BL.toChunks . fromArchive) <$> getsPureState stReferenceDocx

- readDataFile Nothing "reference.odt" = do

- (B.concat . BL.toChunks . fromArchive) <$> getsPureState stReferenceODT

- readDataFile Nothing fname = do

- let fname' = if fname == "MANUAL.txt" then fname else "data" </> fname

- readFileStrict fname'

- readDataFile (Just userDir) fname = do

- userDirFiles <- getsPureState stUserDataDir

- case infoFileContents <$> (getFileInfo (userDir </> fname) userDirFiles) of

- Just bs -> return bs

- Nothing -> readDataFile Nothing fname

-

- glob s = do

- fontFiles <- getsPureState stFontFiles

- return (filter (match (compile s)) fontFiles)

-

- getModificationTime fp = do

- fps <- getsPureState stFiles

- case infoFileMTime <$> (getFileInfo fp fps) of

- Just tm -> return tm

- Nothing -> throwError $ PandocFileReadError fp

-

- getCommonState = PandocPure $ lift $ get

- putCommonState x = PandocPure $ lift $ put x

-

- logOutput _msg = return ()

-

-instance PandocMonad m => PandocMonad (ParsecT s st m) where

- lookupEnv = lift . lookupEnv

- getCurrentTime = lift getCurrentTime

- getCurrentTimeZone = lift getCurrentTimeZone

- newStdGen = lift newStdGen

- newUniqueHash = lift newUniqueHash

- openURL = lift . openURL

- readFileLazy = lift . readFileLazy

- readFileStrict = lift . readFileStrict

- readDataFile mbuserdir = lift . readDataFile mbuserdir

- glob = lift . glob

- getModificationTime = lift . getModificationTime

- getCommonState = lift getCommonState

- putCommonState = lift . putCommonState

- logOutput = lift . logOutput

-

-instance PandocMonad m => PandocMonad (ReaderT r m) where

- lookupEnv = lift . lookupEnv

- getCurrentTime = lift getCurrentTime

- getCurrentTimeZone = lift getCurrentTimeZone

- newStdGen = lift newStdGen

- newUniqueHash = lift newUniqueHash

- openURL = lift . openURL

- readFileLazy = lift . readFileLazy

- readFileStrict = lift . readFileStrict

- readDataFile mbuserdir = lift . readDataFile mbuserdir

- glob = lift . glob

- getModificationTime = lift . getModificationTime

- getCommonState = lift getCommonState

- putCommonState = lift . putCommonState

- logOutput = lift . logOutput

-

-instance (PandocMonad m, Monoid w) => PandocMonad (WriterT w m) where

- lookupEnv = lift . lookupEnv

- getCurrentTime = lift getCurrentTime

- getCurrentTimeZone = lift getCurrentTimeZone

- newStdGen = lift newStdGen

- newUniqueHash = lift newUniqueHash

- openURL = lift . openURL

- readFileLazy = lift . readFileLazy

- readFileStrict = lift . readFileStrict

- readDataFile mbuserdir = lift . readDataFile mbuserdir

- glob = lift . glob

- getModificationTime = lift . getModificationTime

- getCommonState = lift getCommonState

- putCommonState = lift . putCommonState

- logOutput = lift . logOutput

-

-instance (PandocMonad m, Monoid w) => PandocMonad (RWST r w st m) where

- lookupEnv = lift . lookupEnv

- getCurrentTime = lift getCurrentTime

- getCurrentTimeZone = lift getCurrentTimeZone

- newStdGen = lift newStdGen

- newUniqueHash = lift newUniqueHash

- openURL = lift . openURL

- readFileLazy = lift . readFileLazy

- readFileStrict = lift . readFileStrict

- readDataFile mbuserdir = lift . readDataFile mbuserdir

- glob = lift . glob

- getModificationTime = lift . getModificationTime

- getCommonState = lift getCommonState

- putCommonState = lift . putCommonState

- logOutput = lift . logOutput

-

-instance PandocMonad m => PandocMonad (StateT st m) where

- lookupEnv = lift . lookupEnv

- getCurrentTime = lift getCurrentTime

- getCurrentTimeZone = lift getCurrentTimeZone

- newStdGen = lift newStdGen

- newUniqueHash = lift newUniqueHash

- openURL = lift . openURL

- readFileLazy = lift . readFileLazy

- readFileStrict = lift . readFileStrict

- readDataFile mbuserdir = lift . readDataFile mbuserdir

- glob = lift . glob

- getModificationTime = lift . getModificationTime

- getCommonState = lift getCommonState

- putCommonState = lift . putCommonState

- logOutput = lift . logOutput

-

-{-# LANGUAGE CPP #-}

-

-{-

-This compatibility module is needed because, in time 1.5, the

-`defaultTimeLocale` function was moved from System.Locale (in the

-old-locale library) into Data.Time.

-

-We support both behaviors because time 1.4 is a boot library for GHC

-7.8. time 1.5 is a boot library for GHC 7.10.

-

-When support is dropped for GHC 7.8, this module may be obsoleted.

--}

-

-#if MIN_VERSION_time(1,5,0)

-module Text.Pandoc.Compat.Time (

- module Data.Time

-)

-where

-import Data.Time

-

-#else

-module Text.Pandoc.Compat.Time (

- module Data.Time,

- defaultTimeLocale

-)

-where

-import Data.Time

-import System.Locale ( defaultTimeLocale )

-

-#endif

-{-# LANGUAGE OverloadedStrings #-}

--- to be processed using hsb2hs

-module Text.Pandoc.Data (dataFiles) where

-import qualified Data.ByteString as B

-import System.FilePath (splitDirectories)

-import qualified System.FilePath.Posix as Posix

-

--- We ensure that the data files are stored using Posix

--- path separators (/), even on Windows.

-dataFiles :: [(FilePath, B.ByteString)]

-dataFiles = map (\(fp, contents) ->

- (Posix.joinPath (splitDirectories fp), contents)) dataFiles'

-

-dataFiles' :: [(FilePath, B.ByteString)]

-dataFiles' = ("MANUAL.txt", %blob "MANUAL.txt") : %blobs "data"

-{-

-Copyright (C) 2015 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.Emoji

- Copyright : Copyright (C) 2015 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Emoji symbol lookup from canonical string identifier.

--}

-module Text.Pandoc.Emoji ( emojis ) where

-import qualified Data.Map as M

-

-emojis :: M.Map String String

-emojis = M.fromList

- [("+1","\128077")

- ,("-1","\128078")

- ,("100","\128175")

- ,("1234","\128290")

- ,("8ball","\127921")

- ,("a","\127344\65039")

- ,("ab","\127374")

- ,("abc","\128292")

- ,("abcd","\128289")

- ,("accept","\127569")

- ,("aerial_tramway","\128673")

- ,("airplane","\9992\65039")

- ,("alarm_clock","\9200")

- ,("alien","\128125")

- ,("ambulance","\128657")

- ,("anchor","\9875")

- ,("angel","\128124")

- ,("anger","\128162")

- ,("angry","\128544")

- ,("anguished","\128551")

- ,("ant","\128028")

- ,("apple","\127822")

- ,("aquarius","\9810")

- ,("aries","\9800")

- ,("arrow_backward","\9664\65039")

- ,("arrow_double_down","\9196")

- ,("arrow_double_up","\9195")

- ,("arrow_down","\11015\65039")

- ,("arrow_down_small","\128317")

- ,("arrow_forward","\9654\65039")

- ,("arrow_heading_down","\10549\65039")

- ,("arrow_heading_up","\10548\65039")

- ,("arrow_left","\11013\65039")

- ,("arrow_lower_left","\8601\65039")

- ,("arrow_lower_right","\8600\65039")

- ,("arrow_right","\10145\65039")

- ,("arrow_right_hook","\8618\65039")

- ,("arrow_up","\11014\65039")

- ,("arrow_up_down","\8597\65039")

- ,("arrow_up_small","\128316")

- ,("arrow_upper_left","\8598\65039")

- ,("arrow_upper_right","\8599\65039")

- ,("arrows_clockwise","\128259")

- ,("arrows_counterclockwise","\128260")

- ,("art","\127912")

- ,("articulated_lorry","\128667")

- ,("astonished","\128562")

- ,("athletic_shoe","\128095")

- ,("atm","\127975")

- ,("b","\127345\65039")

- ,("baby","\128118")

- ,("baby_bottle","\127868")

- ,("baby_chick","\128036")

- ,("baby_symbol","\128700")

- ,("back","\128281")

- ,("baggage_claim","\128708")

- ,("balloon","\127880")

- ,("ballot_box_with_check","\9745\65039")

- ,("bamboo","\127885")

- ,("banana","\127820")

- ,("bangbang","\8252\65039")

- ,("bank","\127974")

- ,("bar_chart","\128202")

- ,("barber","\128136")

- ,("baseball","\9918\65039")

- ,("basketball","\127936")

- ,("bath","\128704")

- ,("bathtub","\128705")

- ,("battery","\128267")

- ,("bear","\128059")

- ,("bee","\128029")

- ,("beer","\127866")

- ,("beers","\127867")

- ,("beetle","\128030")

- ,("beginner","\128304")

- ,("bell","\128276")

- ,("bento","\127857")

- ,("bicyclist","\128692")

- ,("bike","\128690")

- ,("bikini","\128089")

- ,("bird","\128038")

- ,("birthday","\127874")

- ,("black_circle","\9899")

- ,("black_joker","\127183")

- ,("black_large_square","\11035")

- ,("black_medium_small_square","\9726")

- ,("black_medium_square","\9724\65039")

- ,("black_nib","\10002\65039")

- ,("black_small_square","\9642\65039")

- ,("black_square_button","\128306")

- ,("blossom","\127804")

- ,("blowfish","\128033")

- ,("blue_book","\128216")

- ,("blue_car","\128665")

- ,("blue_heart","\128153")

- ,("blush","\128522")

- ,("boar","\128023")

- ,("boat","\9973")

- ,("bomb","\128163")

- ,("book","\128214")

- ,("bookmark","\128278")

- ,("bookmark_tabs","\128209")

- ,("books","\128218")

- ,("boom","\128165")

- ,("boot","\128098")

- ,("bouquet","\128144")

- ,("bow","\128583")

- ,("bowling","\127923")

- ,("boy","\128102")

- ,("bread","\127838")

- ,("bride_with_veil","\128112")

- ,("bridge_at_night","\127753")

- ,("briefcase","\128188")

- ,("broken_heart","\128148")

- ,("bug","\128027")

- ,("bulb","\128161")

- ,("bullettrain_front","\128645")

- ,("bullettrain_side","\128644")

- ,("bus","\128652")

- ,("busstop","\128655")

- ,("bust_in_silhouette","\128100")

- ,("busts_in_silhouette","\128101")

- ,("cactus","\127797")

- ,("cake","\127856")

- ,("calendar","\128198")

- ,("calling","\128242")

- ,("camel","\128043")

- ,("camera","\128247")

- ,("cancer","\9803")

- ,("candy","\127852")

- ,("capital_abcd","\128288")

- ,("capricorn","\9809")

- ,("car","\128663")

- ,("card_index","\128199")

- ,("carousel_horse","\127904")

- ,("cat","\128049")

- ,("cat2","\128008")

- ,("cd","\128191")

- ,("chart","\128185")

- ,("chart_with_downwards_trend","\128201")

- ,("chart_with_upwards_trend","\128200")

- ,("checkered_flag","\127937")

- ,("cherries","\127826")

- ,("cherry_blossom","\127800")

- ,("chestnut","\127792")

- ,("chicken","\128020")

- ,("children_crossing","\128696")

- ,("chocolate_bar","\127851")

- ,("christmas_tree","\127876")

- ,("church","\9962")

- ,("cinema","\127910")

- ,("circus_tent","\127914")

- ,("city_sunrise","\127751")

- ,("city_sunset","\127750")

- ,("cl","\127377")

- ,("clap","\128079")

- ,("clapper","\127916")

- ,("clipboard","\128203")

- ,("clock1","\128336")

- ,("clock10","\128345")

- ,("clock1030","\128357")

- ,("clock11","\128346")

- ,("clock1130","\128358")

- ,("clock12","\128347")

- ,("clock1230","\128359")

- ,("clock130","\128348")

- ,("clock2","\128337")

- ,("clock230","\128349")

- ,("clock3","\128338")

- ,("clock330","\128350")

- ,("clock4","\128339")

- ,("clock430","\128351")

- ,("clock5","\128340")

- ,("clock530","\128352")

- ,("clock6","\128341")

- ,("clock630","\128353")

- ,("clock7","\128342")

- ,("clock730","\128354")

- ,("clock8","\128343")

- ,("clock830","\128355")

- ,("clock9","\128344")

- ,("clock930","\128356")

- ,("closed_book","\128213")

- ,("closed_lock_with_key","\128272")

- ,("closed_umbrella","\127746")

- ,("cloud","\9729\65039")

- ,("clubs","\9827\65039")

- ,("cn","\127464\127475")

- ,("cocktail","\127864")

- ,("coffee","\9749")

- ,("cold_sweat","\128560")

- ,("collision","\128165")

- ,("computer","\128187")

- ,("confetti_ball","\127882")

- ,("confounded","\128534")

- ,("confused","\128533")

- ,("congratulations","\12951\65039")

- ,("construction","\128679")

- ,("construction_worker","\128119")

- ,("convenience_store","\127978")

- ,("cookie","\127850")

- ,("cool","\127378")

- ,("cop","\128110")

- ,("copyright","\169\65039")

- ,("corn","\127805")

- ,("couple","\128107")

- ,("couple_with_heart","\128145")

- ,("couplekiss","\128143")

- ,("cow","\128046")

- ,("cow2","\128004")

- ,("credit_card","\128179")

- ,("crescent_moon","\127769")

- ,("crocodile","\128010")

- ,("crossed_flags","\127884")

- ,("crown","\128081")

- ,("cry","\128546")

- ,("crying_cat_face","\128575")

- ,("crystal_ball","\128302")

- ,("cupid","\128152")

- ,("curly_loop","\10160")

- ,("currency_exchange","\128177")

- ,("curry","\127835")

- ,("custard","\127854")

- ,("customs","\128707")

- ,("cyclone","\127744")

- ,("dancer","\128131")

- ,("dancers","\128111")

- ,("dango","\127841")

- ,("dart","\127919")

- ,("dash","\128168")

- ,("date","\128197")

- ,("de","\127465\127466")

- ,("deciduous_tree","\127795")

- ,("department_store","\127980")

- ,("diamond_shape_with_a_dot_inside","\128160")

- ,("diamonds","\9830\65039")

- ,("disappointed","\128542")

- ,("disappointed_relieved","\128549")

- ,("dizzy","\128171")

- ,("dizzy_face","\128565")

- ,("do_not_litter","\128687")

- ,("dog","\128054")

- ,("dog2","\128021")

- ,("dollar","\128181")

- ,("dolls","\127886")

- ,("dolphin","\128044")

- ,("door","\128682")

- ,("doughnut","\127849")

- ,("dragon","\128009")

- ,("dragon_face","\128050")

- ,("dress","\128087")

- ,("dromedary_camel","\128042")

- ,("droplet","\128167")

- ,("dvd","\128192")

- ,("e-mail","\128231")

- ,("ear","\128066")

- ,("ear_of_rice","\127806")

- ,("earth_africa","\127757")

- ,("earth_americas","\127758")

- ,("earth_asia","\127759")

- ,("egg","\127859")

- ,("eggplant","\127814")

- ,("eight","8\65039\8419")

- ,("eight_pointed_black_star","\10036\65039")

- ,("eight_spoked_asterisk","\10035\65039")

- ,("electric_plug","\128268")

- ,("elephant","\128024")

- ,("email","\9993\65039")

- ,("end","\128282")

- ,("envelope","\9993\65039")

- ,("envelope_with_arrow","\128233")

- ,("es","\127466\127480")

- ,("euro","\128182")

- ,("european_castle","\127984")

- ,("european_post_office","\127972")

- ,("evergreen_tree","\127794")

- ,("exclamation","\10071")

- ,("expressionless","\128529")

- ,("eyeglasses","\128083")

- ,("eyes","\128064")

- ,("facepunch","\128074")

- ,("factory","\127981")

- ,("fallen_leaf","\127810")

- ,("family","\128106")

- ,("fast_forward","\9193")

- ,("fax","\128224")

- ,("fearful","\128552")

- ,("feet","\128062")

- ,("ferris_wheel","\127905")

- ,("file_folder","\128193")

- ,("fire","\128293")

- ,("fire_engine","\128658")

- ,("fireworks","\127878")

- ,("first_quarter_moon","\127763")

- ,("first_quarter_moon_with_face","\127771")

- ,("fish","\128031")

- ,("fish_cake","\127845")

- ,("fishing_pole_and_fish","\127907")

- ,("fist","\9994")

- ,("five","5\65039\8419")

- ,("flags","\127887")

- ,("flashlight","\128294")

- ,("flipper","\128044")

- ,("floppy_disk","\128190")

- ,("flower_playing_cards","\127924")

- ,("flushed","\128563")

- ,("foggy","\127745")

- ,("football","\127944")

- ,("footprints","\128099")

- ,("fork_and_knife","\127860")

- ,("fountain","\9970")

- ,("four","4\65039\8419")

- ,("four_leaf_clover","\127808")

- ,("fr","\127467\127479")

- ,("free","\127379")

- ,("fried_shrimp","\127844")

- ,("fries","\127839")

- ,("frog","\128056")

- ,("frowning","\128550")

- ,("fuelpump","\9981")

- ,("full_moon","\127765")

- ,("full_moon_with_face","\127773")

- ,("game_die","\127922")

- ,("gb","\127468\127463")

- ,("gem","\128142")

- ,("gemini","\9802")

- ,("ghost","\128123")

- ,("gift","\127873")

- ,("gift_heart","\128157")

- ,("girl","\128103")

- ,("globe_with_meridians","\127760")

- ,("goat","\128016")

- ,("golf","\9971")

- ,("grapes","\127815")

- ,("green_apple","\127823")

- ,("green_book","\128215")

- ,("green_heart","\128154")

- ,("grey_exclamation","\10069")

- ,("grey_question","\10068")

- ,("grimacing","\128556")

- ,("grin","\128513")

- ,("grinning","\128512")

- ,("guardsman","\128130")

- ,("guitar","\127928")

- ,("gun","\128299")

- ,("haircut","\128135")

- ,("hamburger","\127828")

- ,("hammer","\128296")

- ,("hamster","\128057")

- ,("hand","\9995")

- ,("handbag","\128092")

- ,("hankey","\128169")

- ,("hash","#\65039\8419")

- ,("hatched_chick","\128037")

- ,("hatching_chick","\128035")

- ,("headphones","\127911")

- ,("hear_no_evil","\128585")

- ,("heart","\10084\65039")

- ,("heart_decoration","\128159")

- ,("heart_eyes","\128525")

- ,("heart_eyes_cat","\128571")

- ,("heartbeat","\128147")

- ,("heartpulse","\128151")

- ,("hearts","\9829\65039")

- ,("heavy_check_mark","\10004\65039")

- ,("heavy_division_sign","\10135")

- ,("heavy_dollar_sign","\128178")

- ,("heavy_exclamation_mark","\10071")

- ,("heavy_minus_sign","\10134")

- ,("heavy_multiplication_x","\10006\65039")

- ,("heavy_plus_sign","\10133")

- ,("helicopter","\128641")

- ,("herb","\127807")

- ,("hibiscus","\127802")

- ,("high_brightness","\128262")

- ,("high_heel","\128096")

- ,("hocho","\128298")

- ,("honey_pot","\127855")

- ,("honeybee","\128029")

- ,("horse","\128052")

- ,("horse_racing","\127943")

- ,("hospital","\127973")

- ,("hotel","\127976")

- ,("hotsprings","\9832\65039")

- ,("hourglass","\8987")

- ,("hourglass_flowing_sand","\9203")

- ,("house","\127968")

- ,("house_with_garden","\127969")

- ,("hushed","\128559")

- ,("ice_cream","\127848")

- ,("icecream","\127846")

- ,("id","\127380")

- ,("ideograph_advantage","\127568")

- ,("imp","\128127")

- ,("inbox_tray","\128229")

- ,("incoming_envelope","\128232")

- ,("information_desk_person","\128129")

- ,("information_source","\8505\65039")

- ,("innocent","\128519")

- ,("interrobang","\8265\65039")

- ,("iphone","\128241")

- ,("it","\127470\127481")

- ,("izakaya_lantern","\127982")

- ,("jack_o_lantern","\127875")

- ,("japan","\128510")

- ,("japanese_castle","\127983")

- ,("japanese_goblin","\128122")

- ,("japanese_ogre","\128121")

- ,("jeans","\128086")

- ,("joy","\128514")

- ,("joy_cat","\128569")

- ,("jp","\127471\127477")

- ,("key","\128273")

- ,("keycap_ten","\128287")

- ,("kimono","\128088")

- ,("kiss","\128139")

- ,("kissing","\128535")

- ,("kissing_cat","\128573")

- ,("kissing_closed_eyes","\128538")

- ,("kissing_heart","\128536")

- ,("kissing_smiling_eyes","\128537")

- ,("knife","\128298")

- ,("koala","\128040")

- ,("koko","\127489")

- ,("kr","\127472\127479")

- ,("lantern","\127982")

- ,("large_blue_circle","\128309")

- ,("large_blue_diamond","\128311")

- ,("large_orange_diamond","\128310")

- ,("last_quarter_moon","\127767")

- ,("last_quarter_moon_with_face","\127772")

- ,("laughing","\128518")

- ,("leaves","\127811")

- ,("ledger","\128210")

- ,("left_luggage","\128709")

- ,("left_right_arrow","\8596\65039")

- ,("leftwards_arrow_with_hook","\8617\65039")

- ,("lemon","\127819")

- ,("leo","\9804")

- ,("leopard","\128006")

- ,("libra","\9806")

- ,("light_rail","\128648")

- ,("link","\128279")

- ,("lips","\128068")

- ,("lipstick","\128132")

- ,("lock","\128274")

- ,("lock_with_ink_pen","\128271")

- ,("lollipop","\127853")

- ,("loop","\10175")

- ,("loud_sound","\128266")

- ,("loudspeaker","\128226")

- ,("love_hotel","\127977")

- ,("love_letter","\128140")

- ,("low_brightness","\128261")

- ,("m","\9410\65039")

- ,("mag","\128269")

- ,("mag_right","\128270")

- ,("mahjong","\126980")

- ,("mailbox","\128235")

- ,("mailbox_closed","\128234")

- ,("mailbox_with_mail","\128236")

- ,("mailbox_with_no_mail","\128237")

- ,("man","\128104")

- ,("man_with_gua_pi_mao","\128114")

- ,("man_with_turban","\128115")

- ,("mans_shoe","\128094")

- ,("maple_leaf","\127809")

- ,("mask","\128567")

- ,("massage","\128134")

- ,("meat_on_bone","\127830")

- ,("mega","\128227")

- ,("melon","\127816")

- ,("memo","\128221")

- ,("mens","\128697")

- ,("metro","\128647")

- ,("microphone","\127908")

- ,("microscope","\128300")

- ,("milky_way","\127756")

- ,("minibus","\128656")

- ,("minidisc","\128189")

- ,("mobile_phone_off","\128244")

- ,("money_with_wings","\128184")

- ,("moneybag","\128176")

- ,("monkey","\128018")

- ,("monkey_face","\128053")

- ,("monorail","\128669")

- ,("moon","\127764")

- ,("mortar_board","\127891")

- ,("mount_fuji","\128507")

- ,("mountain_bicyclist","\128693")

- ,("mountain_cableway","\128672")

- ,("mountain_railway","\128670")

- ,("mouse","\128045")

- ,("mouse2","\128001")

- ,("movie_camera","\127909")

- ,("moyai","\128511")

- ,("muscle","\128170")

- ,("mushroom","\127812")

- ,("musical_keyboard","\127929")

- ,("musical_note","\127925")

- ,("musical_score","\127932")

- ,("mute","\128263")

- ,("nail_care","\128133")

- ,("name_badge","\128219")

- ,("necktie","\128084")

- ,("negative_squared_cross_mark","\10062")

- ,("neutral_face","\128528")

- ,("new","\127381")

- ,("new_moon","\127761")

- ,("new_moon_with_face","\127770")

- ,("newspaper","\128240")

- ,("ng","\127382")

- ,("night_with_stars","\127747")

- ,("nine","9\65039\8419")

- ,("no_bell","\128277")

- ,("no_bicycles","\128691")

- ,("no_entry","\9940")

- ,("no_entry_sign","\128683")

- ,("no_good","\128581")

- ,("no_mobile_phones","\128245")

- ,("no_mouth","\128566")

- ,("no_pedestrians","\128695")

- ,("no_smoking","\128685")

- ,("non-potable_water","\128689")

- ,("nose","\128067")

- ,("notebook","\128211")

- ,("notebook_with_decorative_cover","\128212")

- ,("notes","\127926")

- ,("nut_and_bolt","\128297")

- ,("o","\11093")

- ,("o2","\127358\65039")

- ,("ocean","\127754")

- ,("octopus","\128025")

- ,("oden","\127842")

- ,("office","\127970")

- ,("ok","\127383")

- ,("ok_hand","\128076")

- ,("ok_woman","\128582")

- ,("older_man","\128116")

- ,("older_woman","\128117")

- ,("on","\128283")

- ,("oncoming_automobile","\128664")

- ,("oncoming_bus","\128653")

- ,("oncoming_police_car","\128660")

- ,("oncoming_taxi","\128662")

- ,("one","1\65039\8419")

- ,("open_book","\128214")

- ,("open_file_folder","\128194")

- ,("open_hands","\128080")

- ,("open_mouth","\128558")

- ,("ophiuchus","\9934")

- ,("orange_book","\128217")

- ,("outbox_tray","\128228")

- ,("ox","\128002")

- ,("package","\128230")

- ,("page_facing_up","\128196")

- ,("page_with_curl","\128195")

- ,("pager","\128223")

- ,("palm_tree","\127796")

- ,("panda_face","\128060")

- ,("paperclip","\128206")

- ,("parking","\127359\65039")

- ,("part_alternation_mark","\12349\65039")

- ,("partly_sunny","\9925")

- ,("passport_control","\128706")

- ,("paw_prints","\128062")

- ,("peach","\127825")

- ,("pear","\127824")

- ,("pencil","\128221")

- ,("pencil2","\9999\65039")

- ,("penguin","\128039")

- ,("pensive","\128532")

- ,("performing_arts","\127917")

- ,("persevere","\128547")

- ,("person_frowning","\128589")

- ,("person_with_blond_hair","\128113")

- ,("person_with_pouting_face","\128590")

- ,("phone","\9742\65039")

- ,("pig","\128055")

- ,("pig2","\128022")

- ,("pig_nose","\128061")

- ,("pill","\128138")

- ,("pineapple","\127821")

- ,("pisces","\9811")

- ,("pizza","\127829")

- ,("point_down","\128071")

- ,("point_left","\128072")

- ,("point_right","\128073")

- ,("point_up","\9757\65039")

- ,("point_up_2","\128070")

- ,("police_car","\128659")

- ,("poodle","\128041")

- ,("poop","\128169")

- ,("post_office","\127971")

- ,("postal_horn","\128239")

- ,("postbox","\128238")

- ,("potable_water","\128688")

- ,("pouch","\128093")

- ,("poultry_leg","\127831")

- ,("pound","\128183")

- ,("pouting_cat","\128574")

- ,("pray","\128591")

- ,("princess","\128120")

- ,("punch","\128074")

- ,("purple_heart","\128156")

- ,("purse","\128091")

- ,("pushpin","\128204")

- ,("put_litter_in_its_place","\128686")

- ,("question","\10067")

- ,("rabbit","\128048")

- ,("rabbit2","\128007")

- ,("racehorse","\128014")

- ,("radio","\128251")

- ,("radio_button","\128280")

- ,("rage","\128545")

- ,("railway_car","\128643")

- ,("rainbow","\127752")

- ,("raised_hand","\9995")

- ,("raised_hands","\128588")

- ,("raising_hand","\128587")

- ,("ram","\128015")

- ,("ramen","\127836")

- ,("rat","\128000")

- ,("recycle","\9851\65039")

- ,("red_car","\128663")

- ,("red_circle","\128308")

- ,("registered","\174\65039")

- ,("relaxed","\9786\65039")

- ,("relieved","\128524")

- ,("repeat","\128257")

- ,("repeat_one","\128258")

- ,("restroom","\128699")

- ,("revolving_hearts","\128158")

- ,("rewind","\9194")

- ,("ribbon","\127872")

- ,("rice","\127834")

- ,("rice_ball","\127833")

- ,("rice_cracker","\127832")

- ,("rice_scene","\127889")

- ,("ring","\128141")

- ,("rocket","\128640")

- ,("roller_coaster","\127906")

- ,("rooster","\128019")

- ,("rose","\127801")

- ,("rotating_light","\128680")

- ,("round_pushpin","\128205")

- ,("rowboat","\128675")

- ,("ru","\127479\127482")

- ,("rugby_football","\127945")

- ,("runner","\127939")

- ,("running","\127939")

- ,("running_shirt_with_sash","\127933")

- ,("sa","\127490\65039")

- ,("sagittarius","\9808")

- ,("sailboat","\9973")

- ,("sake","\127862")

- ,("sandal","\128097")

- ,("santa","\127877")

- ,("satellite","\128225")

- ,("satisfied","\128518")

- ,("saxophone","\127927")

- ,("school","\127979")

- ,("school_satchel","\127890")

- ,("scissors","\9986\65039")

- ,("scorpius","\9807")

- ,("scream","\128561")

- ,("scream_cat","\128576")

- ,("scroll","\128220")

- ,("seat","\128186")

- ,("secret","\12953\65039")

- ,("see_no_evil","\128584")

- ,("seedling","\127793")

- ,("seven","7\65039\8419")

- ,("shaved_ice","\127847")

- ,("sheep","\128017")

- ,("shell","\128026")

- ,("ship","\128674")

- ,("shirt","\128085")

- ,("shit","\128169")

- ,("shoe","\128094")

- ,("shower","\128703")

- ,("signal_strength","\128246")

- ,("six","6\65039\8419")

- ,("six_pointed_star","\128303")

- ,("ski","\127935")

- ,("skull","\128128")

- ,("sleeping","\128564")

- ,("sleepy","\128554")

- ,("slot_machine","\127920")

- ,("small_blue_diamond","\128313")

- ,("small_orange_diamond","\128312")

- ,("small_red_triangle","\128314")

- ,("small_red_triangle_down","\128315")

- ,("smile","\128516")

- ,("smile_cat","\128568")

- ,("smiley","\128515")

- ,("smiley_cat","\128570")

- ,("smiling_imp","\128520")

- ,("smirk","\128527")

- ,("smirk_cat","\128572")

- ,("smoking","\128684")

- ,("snail","\128012")

- ,("snake","\128013")

- ,("snowboarder","\127938")

- ,("snowflake","\10052\65039")

- ,("snowman","\9924")

- ,("sob","\128557")

- ,("soccer","\9917")

- ,("soon","\128284")

- ,("sos","\127384")

- ,("sound","\128265")

- ,("space_invader","\128126")

- ,("spades","\9824\65039")

- ,("spaghetti","\127837")

- ,("sparkle","\10055\65039")

- ,("sparkler","\127879")

- ,("sparkles","\10024")

- ,("sparkling_heart","\128150")

- ,("speak_no_evil","\128586")

- ,("speaker","\128264")

- ,("speech_balloon","\128172")

- ,("speedboat","\128676")

- ,("star","\11088")

- ,("star2","\127775")

- ,("stars","\127776")

- ,("station","\128649")

- ,("statue_of_liberty","\128509")

- ,("steam_locomotive","\128642")

- ,("stew","\127858")

- ,("straight_ruler","\128207")

- ,("strawberry","\127827")

- ,("stuck_out_tongue","\128539")

- ,("stuck_out_tongue_closed_eyes","\128541")

- ,("stuck_out_tongue_winking_eye","\128540")

- ,("sun_with_face","\127774")

- ,("sunflower","\127803")

- ,("sunglasses","\128526")

- ,("sunny","\9728\65039")

- ,("sunrise","\127749")

- ,("sunrise_over_mountains","\127748")

- ,("surfer","\127940")

- ,("sushi","\127843")

- ,("suspension_railway","\128671")

- ,("sweat","\128531")

- ,("sweat_drops","\128166")

- ,("sweat_smile","\128517")

- ,("sweet_potato","\127840")

- ,("swimmer","\127946")

- ,("symbols","\128291")

- ,("syringe","\128137")

- ,("tada","\127881")

- ,("tanabata_tree","\127883")

- ,("tangerine","\127818")

- ,("taurus","\9801")

- ,("taxi","\128661")

- ,("tea","\127861")

- ,("telephone","\9742\65039")

- ,("telephone_receiver","\128222")

- ,("telescope","\128301")

- ,("tennis","\127934")

- ,("tent","\9978")

- ,("thought_balloon","\128173")

- ,("three","3\65039\8419")

- ,("thumbsdown","\128078")

- ,("thumbsup","\128077")

- ,("ticket","\127915")

- ,("tiger","\128047")

- ,("tiger2","\128005")

- ,("tired_face","\128555")

- ,("tm","\8482\65039")

- ,("toilet","\128701")

- ,("tokyo_tower","\128508")

- ,("tomato","\127813")

- ,("tongue","\128069")

- ,("top","\128285")

- ,("tophat","\127913")

- ,("tractor","\128668")

- ,("traffic_light","\128677")

- ,("train","\128651")

- ,("train2","\128646")

- ,("tram","\128650")

- ,("triangular_flag_on_post","\128681")

- ,("triangular_ruler","\128208")

- ,("trident","\128305")

- ,("triumph","\128548")

- ,("trolleybus","\128654")

- ,("trophy","\127942")

- ,("tropical_drink","\127865")

- ,("tropical_fish","\128032")

- ,("truck","\128666")

- ,("trumpet","\127930")

- ,("tshirt","\128085")

- ,("tulip","\127799")

- ,("turtle","\128034")

- ,("tv","\128250")

- ,("twisted_rightwards_arrows","\128256")

- ,("two","2\65039\8419")

- ,("two_hearts","\128149")

- ,("two_men_holding_hands","\128108")

- ,("two_women_holding_hands","\128109")

- ,("u5272","\127545")

- ,("u5408","\127540")

- ,("u55b6","\127546")

- ,("u6307","\127535")

- ,("u6708","\127543\65039")

- ,("u6709","\127542")

- ,("u6e80","\127541")

- ,("u7121","\127514")

- ,("u7533","\127544")

- ,("u7981","\127538")

- ,("u7a7a","\127539")

- ,("uk","\127468\127463")

- ,("umbrella","\9748")

- ,("unamused","\128530")

- ,("underage","\128286")

- ,("unlock","\128275")

- ,("up","\127385")

- ,("us","\127482\127480")

- ,("v","\9996\65039")

- ,("vertical_traffic_light","\128678")

- ,("vhs","\128252")

- ,("vibration_mode","\128243")

- ,("video_camera","\128249")

- ,("video_game","\127918")

- ,("violin","\127931")

- ,("virgo","\9805")

- ,("volcano","\127755")

- ,("vs","\127386")

- ,("walking","\128694")

- ,("waning_crescent_moon","\127768")

- ,("waning_gibbous_moon","\127766")

- ,("warning","\9888\65039")

- ,("watch","\8986")

- ,("water_buffalo","\128003")

- ,("watermelon","\127817")

- ,("wave","\128075")

- ,("wavy_dash","\12336\65039")

- ,("waxing_crescent_moon","\127762")

- ,("waxing_gibbous_moon","\127764")

- ,("wc","\128702")

- ,("weary","\128553")

- ,("wedding","\128146")

- ,("whale","\128051")

- ,("whale2","\128011")

- ,("wheelchair","\9855")

- ,("white_check_mark","\9989")

- ,("white_circle","\9898")

- ,("white_flower","\128174")

- ,("white_large_square","\11036")

- ,("white_medium_small_square","\9725")

- ,("white_medium_square","\9723\65039")

- ,("white_small_square","\9643\65039")

- ,("white_square_button","\128307")

- ,("wind_chime","\127888")

- ,("wine_glass","\127863")

- ,("wink","\128521")

- ,("wolf","\128058")

- ,("woman","\128105")

- ,("womans_clothes","\128090")

- ,("womans_hat","\128082")

- ,("womens","\128698")

- ,("worried","\128543")

- ,("wrench","\128295")

- ,("x","\10060")

- ,("yellow_heart","\128155")

- ,("yen","\128180")

- ,("yum","\128523")

- ,("zap","\9889")

- ,("zero","0\65039\8419")

- ,("zzz","\128164")

- ]

-

-{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}

-{-

-Copyright (C) 2006-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-{- |

- Module : Text.Pandoc.Error

- Copyright : Copyright (C) 2006-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-This module provides a standard way to deal with possible errors encounted

-during parsing.

-

--}

-module Text.Pandoc.Error (

- PandocError(..),

- handleError) where

-

-import Text.Parsec.Error

-import Text.Parsec.Pos hiding (Line)

-import Data.Generics (Typeable)

-import GHC.Generics (Generic)

-import Control.Exception (Exception)

-import Text.Pandoc.Shared (err)

-

-type Input = String

-

-data PandocError = PandocFileReadError FilePath

- | PandocShouldNeverHappenError String

- | PandocSomeError String

- | PandocParseError String

- | PandocParsecError Input ParseError

- | PandocMakePDFError String

- deriving (Show, Typeable, Generic)

-

-instance Exception PandocError

-

--- | Handle PandocError by exiting with an error message.

-handleError :: Either PandocError a -> IO a

-handleError (Right r) = return r

-handleError (Left e) =

- case e of

- PandocFileReadError fp -> err 61 $ "problem reading " ++ fp

- PandocShouldNeverHappenError s -> err 62 s

- PandocSomeError s -> err 63 s

- PandocParseError s -> err 64 s

- PandocParsecError input err' ->

- let errPos = errorPos err'

- errLine = sourceLine errPos

- errColumn = sourceColumn errPos

- ls = lines input ++ [""]

- errorInFile = if length ls > errLine - 1

- then concat ["\n", (ls !! (errLine - 1))

- ,"\n", replicate (errColumn - 1) ' '

- ,"^"]

- else ""

- in err 65 $ "\nError at " ++ show err' ++ errorInFile

- PandocMakePDFError s -> err 65 s

-

-{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}

-{-

-Copyright (C) 2012-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.Extensions

- Copyright : Copyright (C) 2012-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Data structures and functions for representing markup extensions.

--}

-module Text.Pandoc.Extensions ( Extension(..)

- , Extensions

- , emptyExtensions

- , extensionsFromList

- , extensionEnabled

- , enableExtension

- , disableExtension

- , pandocExtensions

- , plainExtensions

- , strictExtensions

- , phpMarkdownExtraExtensions

- , githubMarkdownExtensions

- , multimarkdownExtensions )

-where

-import Data.Bits (testBit, setBit, clearBit)

-import Data.Data (Data)

-import Data.Typeable (Typeable)

-import GHC.Generics (Generic)

-

-newtype Extensions = Extensions Integer

- deriving (Show, Read, Eq, Ord, Data, Typeable, Generic)

-

-extensionsFromList :: [Extension] -> Extensions

-extensionsFromList = foldr enableExtension emptyExtensions

-

-emptyExtensions :: Extensions

-emptyExtensions = Extensions 0

-

-extensionEnabled :: Extension -> Extensions -> Bool

-extensionEnabled x (Extensions exts) = testBit exts (fromEnum x)

-

-enableExtension :: Extension -> Extensions -> Extensions

-enableExtension x (Extensions exts) = Extensions (setBit exts (fromEnum x))

-

-disableExtension :: Extension -> Extensions -> Extensions

-disableExtension x (Extensions exts) = Extensions (clearBit exts (fromEnum x))

-

--- | Individually selectable syntax extensions.

-data Extension =

- Ext_footnotes -- ^ Pandoc/PHP/MMD style footnotes

- | Ext_inline_notes -- ^ Pandoc-style inline notes

- | Ext_pandoc_title_block -- ^ Pandoc title block

- | Ext_yaml_metadata_block -- ^ YAML metadata block

- | Ext_mmd_title_block -- ^ Multimarkdown metadata block

- | Ext_table_captions -- ^ Pandoc-style table captions

- | Ext_implicit_figures -- ^ A paragraph with just an image is a figure

- | Ext_simple_tables -- ^ Pandoc-style simple tables

- | Ext_multiline_tables -- ^ Pandoc-style multiline tables

- | Ext_grid_tables -- ^ Grid tables (pandoc, reST)

- | Ext_pipe_tables -- ^ Pipe tables (as in PHP markdown extra)

- | Ext_citations -- ^ Pandoc/citeproc citations

- | Ext_raw_tex -- ^ Allow raw TeX (other than math)

- | Ext_raw_html -- ^ Allow raw HTML

- | Ext_tex_math_dollars -- ^ TeX math between $..$ or $$..$$

- | Ext_tex_math_single_backslash -- ^ TeX math btw \(..\) \[..\]

- | Ext_tex_math_double_backslash -- ^ TeX math btw \\(..\\) \\[..\\]

- | Ext_latex_macros -- ^ Parse LaTeX macro definitions (for math only)

- | Ext_fenced_code_blocks -- ^ Parse fenced code blocks

- | Ext_fenced_code_attributes -- ^ Allow attributes on fenced code blocks

- | Ext_backtick_code_blocks -- ^ GitHub style ``` code blocks

- | Ext_inline_code_attributes -- ^ Allow attributes on inline code

- | Ext_markdown_in_html_blocks -- ^ Interpret as markdown inside HTML blocks

- | Ext_native_divs -- ^ Use Div blocks for contents of <div> tags

- | Ext_native_spans -- ^ Use Span inlines for contents of <span>

- | Ext_bracketed_spans -- ^ Bracketed spans with attributes

- | Ext_markdown_attribute -- ^ Interpret text inside HTML as markdown

- -- iff container has attribute 'markdown'

- | Ext_escaped_line_breaks -- ^ Treat a backslash at EOL as linebreak

- | Ext_link_attributes -- ^ link and image attributes

- | Ext_mmd_link_attributes -- ^ MMD style reference link attributes

- | Ext_autolink_bare_uris -- ^ Make all absolute URIs into links

- | Ext_fancy_lists -- ^ Enable fancy list numbers and delimiters

- | Ext_lists_without_preceding_blankline -- ^ Allow lists without preceding blank

- | Ext_startnum -- ^ Make start number of ordered list significant

- | Ext_definition_lists -- ^ Definition lists as in pandoc, mmd, php

- | Ext_compact_definition_lists -- ^ Definition lists without

- -- space between items, and disallow laziness

- | Ext_example_lists -- ^ Markdown-style numbered examples

- | Ext_all_symbols_escapable -- ^ Make all non-alphanumerics escapable

- | Ext_angle_brackets_escapable -- ^ Make < and > escapable

- | Ext_intraword_underscores -- ^ Treat underscore inside word as literal

- | Ext_blank_before_blockquote -- ^ Require blank line before a blockquote

- | Ext_blank_before_header -- ^ Require blank line before a header

- | Ext_strikeout -- ^ Strikeout using ~~this~~ syntax

- | Ext_superscript -- ^ Superscript using ^this^ syntax

- | Ext_subscript -- ^ Subscript using ~this~ syntax

- | Ext_hard_line_breaks -- ^ All newlines become hard line breaks

- | Ext_ignore_line_breaks -- ^ Newlines in paragraphs are ignored

- | Ext_east_asian_line_breaks -- ^ Newlines in paragraphs are ignored between

- -- East Asian wide characters

- | Ext_literate_haskell -- ^ Enable literate Haskell conventions

- | Ext_abbreviations -- ^ PHP markdown extra abbreviation definitions

- | Ext_emoji -- ^ Support emoji like :smile:

- | Ext_auto_identifiers -- ^ Automatic identifiers for headers

- | Ext_ascii_identifiers -- ^ ascii-only identifiers for headers

- | Ext_header_attributes -- ^ Explicit header attributes {#id .class k=v}

- | Ext_mmd_header_identifiers -- ^ Multimarkdown style header identifiers [myid]

- | Ext_implicit_header_references -- ^ Implicit reference links for headers

- | Ext_line_blocks -- ^ RST style line blocks

- | Ext_epub_html_exts -- ^ Recognise the EPUB extended version of HTML

- | Ext_shortcut_reference_links -- ^ Shortcut reference links

- | Ext_smart -- ^ "Smart" quotes, apostrophes, ellipses, dashes

- | Ext_old_dashes -- ^ -- = em, - before number = en

- deriving (Show, Read, Enum, Eq, Ord, Bounded, Data, Typeable, Generic)

-

-pandocExtensions :: Extensions

-pandocExtensions = extensionsFromList

- [ Ext_footnotes

- , Ext_inline_notes

- , Ext_pandoc_title_block

- , Ext_yaml_metadata_block

- , Ext_table_captions

- , Ext_implicit_figures

- , Ext_simple_tables

- , Ext_multiline_tables

- , Ext_grid_tables

- , Ext_pipe_tables

- , Ext_citations

- , Ext_raw_tex

- , Ext_raw_html

- , Ext_tex_math_dollars

- , Ext_latex_macros

- , Ext_fenced_code_blocks

- , Ext_fenced_code_attributes

- , Ext_backtick_code_blocks

- , Ext_inline_code_attributes

- , Ext_markdown_in_html_blocks

- , Ext_native_divs

- , Ext_native_spans

- , Ext_bracketed_spans

- , Ext_escaped_line_breaks

- , Ext_fancy_lists

- , Ext_startnum

- , Ext_definition_lists

- , Ext_example_lists

- , Ext_all_symbols_escapable

- , Ext_intraword_underscores

- , Ext_blank_before_blockquote

- , Ext_blank_before_header

- , Ext_strikeout

- , Ext_superscript

- , Ext_subscript

- , Ext_auto_identifiers

- , Ext_header_attributes

- , Ext_link_attributes

- , Ext_implicit_header_references

- , Ext_line_blocks

- , Ext_shortcut_reference_links

- , Ext_smart

- ]

-

-plainExtensions :: Extensions

-plainExtensions = extensionsFromList

- [ Ext_table_captions

- , Ext_implicit_figures

- , Ext_simple_tables

- , Ext_multiline_tables

- , Ext_grid_tables

- , Ext_latex_macros

- , Ext_fancy_lists

- , Ext_startnum

- , Ext_definition_lists

- , Ext_example_lists

- , Ext_intraword_underscores

- , Ext_blank_before_blockquote

- , Ext_blank_before_header

- , Ext_strikeout

- ]

-

-phpMarkdownExtraExtensions :: Extensions

-phpMarkdownExtraExtensions = extensionsFromList

- [ Ext_footnotes

- , Ext_pipe_tables

- , Ext_raw_html

- , Ext_markdown_attribute

- , Ext_fenced_code_blocks

- , Ext_definition_lists

- , Ext_intraword_underscores

- , Ext_header_attributes

- , Ext_link_attributes

- , Ext_abbreviations

- , Ext_shortcut_reference_links

- ]

-

-githubMarkdownExtensions :: Extensions

-githubMarkdownExtensions = extensionsFromList

- [ Ext_angle_brackets_escapable

- , Ext_pipe_tables

- , Ext_raw_html

- , Ext_fenced_code_blocks

- , Ext_auto_identifiers

- , Ext_ascii_identifiers

- , Ext_backtick_code_blocks

- , Ext_autolink_bare_uris

- , Ext_intraword_underscores

- , Ext_strikeout

- , Ext_hard_line_breaks

- , Ext_emoji

- , Ext_lists_without_preceding_blankline

- , Ext_shortcut_reference_links

- ]

-

-multimarkdownExtensions :: Extensions

-multimarkdownExtensions = extensionsFromList

- [ Ext_pipe_tables

- , Ext_raw_html

- , Ext_markdown_attribute

- , Ext_mmd_link_attributes

- -- , Ext_raw_tex

- -- Note: MMD's raw TeX syntax requires raw TeX to be

- -- enclosed in HTML comment

- , Ext_tex_math_double_backslash

- , Ext_intraword_underscores

- , Ext_mmd_title_block

- , Ext_footnotes

- , Ext_definition_lists

- , Ext_all_symbols_escapable

- , Ext_implicit_header_references

- , Ext_auto_identifiers

- , Ext_mmd_header_identifiers

- , Ext_implicit_figures

- -- Note: MMD's syntax for superscripts and subscripts

- -- is a bit more permissive than pandoc's, allowing

- -- e^2 and a~1 instead of e^2^ and a~1~, so even with

- -- these options we don't have full support for MMD

- -- superscripts and subscripts, but there's no reason

- -- not to include these:

- , Ext_superscript

- , Ext_subscript

- ]

-

-strictExtensions :: Extensions

-strictExtensions = extensionsFromList

- [ Ext_raw_html

- , Ext_shortcut_reference_links

- ]

-

-{-

-Copyright (C) 2008-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.Highlighting

- Copyright : Copyright (C) 2008-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Exports functions for syntax highlighting.

--}

-

-module Text.Pandoc.Highlighting ( highlightingStyles

- , languages

- , languagesByExtension

- , highlight

- , formatLaTeXInline

- , formatLaTeXBlock

- , styleToLaTeX

- , formatHtmlInline

- , formatHtmlBlock

- , styleToCss

- , pygments

- , espresso

- , zenburn

- , tango

- , kate

- , monochrome

- , haddock

- , Style

- , fromListingsLanguage

- , toListingsLanguage

- ) where

-import Text.Pandoc.Definition

-import Text.Pandoc.Shared (safeRead)

-import Skylighting

-import Data.Maybe (fromMaybe)

-import Data.Char (toLower)

-import qualified Data.Map as M

-import Control.Monad

-import qualified Data.Text as T

-

-highlightingStyles :: [(String, Style)]

-highlightingStyles =

- [("pygments", pygments),

- ("tango", tango),

- ("espresso", espresso),

- ("zenburn", zenburn),

- ("kate", kate),

- ("monochrome", monochrome),

- ("breezedark", breezeDark),

- ("haddock", haddock)]

-

-languages :: [String]

-languages = [T.unpack (T.toLower (sName s)) | s <- M.elems defaultSyntaxMap]

-

-languagesByExtension :: String -> [String]

-languagesByExtension ext =

- [T.unpack (T.toLower (sName s)) | s <- syntaxesByExtension defaultSyntaxMap ext]

-

-highlight :: (FormatOptions -> [SourceLine] -> a) -- ^ Formatter

- -> Attr -- ^ Attributes of the CodeBlock

- -> String -- ^ Raw contents of the CodeBlock

- -> Maybe a -- ^ Maybe the formatted result

-highlight formatter (_, classes, keyvals) rawCode =

- let firstNum = fromMaybe 1 (safeRead (fromMaybe "1" $ lookup "startFrom" keyvals))

- fmtOpts = defaultFormatOpts{

- startNumber = firstNum,

- numberLines = any (`elem`

- ["number","numberLines", "number-lines"]) classes }

- tokenizeOpts = TokenizerConfig{ syntaxMap = defaultSyntaxMap

- , traceOutput = False }

- classes' = map T.pack classes

- rawCode' = T.pack rawCode

- in case msum (map (\l -> lookupSyntax l defaultSyntaxMap) classes') of

- Nothing

- | numberLines fmtOpts -> Just

- $ formatter fmtOpts{ codeClasses = [],

- containerClasses = classes' }

- $ map (\ln -> [(NormalTok, ln)]) $ T.lines rawCode'

- | otherwise -> Nothing

- Just syntax ->

- case tokenize tokenizeOpts syntax rawCode' of

- Right slines -> Just $

- formatter fmtOpts{ codeClasses =

- [T.toLower (sShortname syntax)],

- containerClasses = classes' } slines

- Left _ -> Nothing

-

--- Functions for correlating latex listings package's language names

--- with skylighting language names:

-

-langToListingsMap :: M.Map String String

-langToListingsMap = M.fromList langsList

-

-listingsToLangMap :: M.Map String String

-listingsToLangMap = M.fromList $ map switch langsList

- where switch (a,b) = (b,a)

-

-langsList :: [(String, String)]

-langsList =

- [("abap","ABAP"),

- ("acm","ACM"),

- ("acmscript","ACMscript"),

- ("acsl","ACSL"),

- ("ada","Ada"),

- ("algol","Algol"),

- ("ant","Ant"),

- ("assembler","Assembler"),

- ("gnuassembler","Assembler"),

- ("awk","Awk"),

- ("bash","bash"),

- ("monobasic","Basic"),

- ("purebasic","Basic"),

- ("c","C"),

- ("cpp","C++"),

- ("c++","C++"),

- ("ocaml","Caml"),

- ("cil","CIL"),

- ("clean","Clean"),

- ("cobol","Cobol"),

- ("comal80","Comal80"),

- ("command.com","command.com"),

- ("comsol","Comsol"),

- ("csh","csh"),

- ("delphi","Delphi"),

- ("elan","Elan"),

- ("erlang","erlang"),

- ("euphoria","Euphoria"),

- ("fortran","Fortran"),

- ("gap","GAP"),

- ("gcl","GCL"),

- ("gnuplot","Gnuplot"),

- ("hansl","hansl"),

- ("haskell","Haskell"),

- ("html","HTML"),

- ("idl","IDL"),

- ("inform","inform"),

- ("java","Java"),

- ("jvmis","JVMIS"),

- ("ksh","ksh"),

- ("lingo","Lingo"),

- ("lisp","Lisp"),

- ("commonlisp","Lisp"),

- ("llvm","LLVM"),

- ("logo","Logo"),

- ("lua","Lua"),

- ("make","make"),

- ("makefile","make"),

- ("mathematica","Mathematica"),

- ("matlab","Matlab"),

- ("mercury","Mercury"),

- ("metapost","MetaPost"),

- ("miranda","Miranda"),

- ("mizar","Mizar"),

- ("ml","ML"),

- ("modula2","Modula-2"),

- ("mupad","MuPAD"),

- ("nastran","NASTRAN"),

- ("oberon2","Oberon-2"),

- ("ocl","OCL"),

- ("octave","Octave"),

- ("oz","Oz"),

- ("pascal","Pascal"),

- ("perl","Perl"),

- ("php","PHP"),

- ("pli","PL/I"),

- ("plasm","Plasm"),

- ("postscript","PostScript"),

- ("pov","POV"),

- ("prolog","Prolog"),

- ("promela","Promela"),

- ("pstricks","PSTricks"),

- ("python","Python"),

- ("r","R"),

- ("reduce","Reduce"),

- ("rexx","Rexx"),

- ("rsl","RSL"),

- ("ruby","Ruby"),

- ("s","S"),

- ("sas","SAS"),

- ("scala","Scala"),

- ("scilab","Scilab"),

- ("sh","sh"),

- ("shelxl","SHELXL"),

- ("simula","Simula"),

- ("sparql","SPARQL"),

- ("sql","SQL"),

- ("tcl","tcl"),

- ("tex","TeX"),

- ("latex","TeX"),

- ("vbscript","VBScript"),

- ("verilog","Verilog"),

- ("vhdl","VHDL"),

- ("vrml","VRML"),

- ("xml","XML"),

- ("xslt","XSLT")]

-

--- | Determine listings language name from skylighting language name.

-toListingsLanguage :: String -> Maybe String

-toListingsLanguage lang = M.lookup (map toLower lang) langToListingsMap

-

--- | Determine skylighting language name from listings language name.

-fromListingsLanguage :: String -> Maybe String

-fromListingsLanguage lang = M.lookup lang listingsToLangMap

-{-# LANGUAGE OverloadedStrings, ScopedTypeVariables, CPP #-}

-{-# OPTIONS_GHC -fno-warn-type-defaults #-}

-{-

- Copyright (C) 2011-2016 John MacFarlane <jgm@berkeley.edu>

-

- This program is free software; you can redistribute it and/or modify

- it under the terms of the GNU General Public License as published by

- the Free Software Foundation; either version 2 of the License, or

- (at your option) any later version.

-

- This program is distributed in the hope that it will be useful, but WITHOUT

- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for

- more details.

-

- You should have received a copy of the GNU General Public License along

- with this program; if not, write to the Free Software Foundation, Inc., 59

- Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

-Module : Text.Pandoc.ImageSize

-Copyright : Copyright (C) 2011-2016 John MacFarlane

-License : GNU GPL, version 2 or above

-

-Maintainer : John MacFarlane <jgm@berkeley.edu>

-Stability : alpha

-Portability : portable

-

-Functions for determining the size of a PNG, JPEG, or GIF image.

--}

-module Text.Pandoc.ImageSize ( ImageType(..)

- , imageType

- , imageSize

- , sizeInPixels

- , sizeInPoints

- , desiredSizeInPoints

- , Dimension(..)

- , Direction(..)

- , dimension

- , inInch

- , inPoints

- , numUnit

- , showInInch

- , showInPixel

- , showFl

- ) where

-import Data.ByteString (ByteString, unpack)

-import qualified Data.ByteString.Char8 as B

-import qualified Data.ByteString.Lazy as BL

-import Data.Char (isDigit)

-import Control.Monad

-import Data.Bits

-import Data.Binary

-import Data.Binary.Get

-import Text.Pandoc.Shared (safeRead)

-import Data.Default (Default)

-import Numeric (showFFloat)

-import Text.Pandoc.Definition

-import Text.Pandoc.Options

-import qualified Data.Map as M

-import Control.Monad.Except

-import Data.Maybe (fromMaybe)

-

--- quick and dirty functions to get image sizes

--- algorithms borrowed from wwwis.pl

-

-data ImageType = Png | Gif | Jpeg | Pdf | Eps deriving Show

-data Direction = Width | Height

-instance Show Direction where

- show Width = "width"

- show Height = "height"

-

-data Dimension = Pixel Integer

- | Centimeter Double

- | Inch Double

- | Percent Double

-instance Show Dimension where

- show (Pixel a) = show a ++ "px"

- show (Centimeter a) = showFl a ++ "cm"

- show (Inch a) = showFl a ++ "in"

- show (Percent a) = show a ++ "%"

-

-data ImageSize = ImageSize{

- pxX :: Integer

- , pxY :: Integer

- , dpiX :: Integer

- , dpiY :: Integer

- } deriving (Read, Show, Eq)

-instance Default ImageSize where

- def = ImageSize 300 200 72 72

-

-showFl :: (RealFloat a) => a -> String

-showFl a = showFFloat (Just 5) a ""

-

-imageType :: ByteString -> Maybe ImageType

-imageType img = case B.take 4 img of

- "\x89\x50\x4e\x47" -> return Png

- "\x47\x49\x46\x38" -> return Gif

- "\xff\xd8\xff\xe0" -> return Jpeg -- JFIF

- "\xff\xd8\xff\xe1" -> return Jpeg -- Exif

- "%PDF" -> return Pdf

- "%!PS"

- | (B.take 4 $ B.drop 1 $ B.dropWhile (/=' ') img) == "EPSF"

- -> return Eps

- _ -> mzero

-

-imageSize :: ByteString -> Either String ImageSize

-imageSize img =

- case imageType img of

- Just Png -> mbToEither "could not determine PNG size" $ pngSize img

- Just Gif -> mbToEither "could not determine GIF size" $ gifSize img

- Just Jpeg -> jpegSize img

- Just Eps -> mbToEither "could not determine EPS size" $ epsSize img

- Just Pdf -> Left "could not determine PDF size" -- TODO

- Nothing -> Left "could not determine image type"

- where mbToEither msg Nothing = Left msg

- mbToEither _ (Just x) = Right x

-

-defaultSize :: (Integer, Integer)

-defaultSize = (72, 72)

-

-sizeInPixels :: ImageSize -> (Integer, Integer)

-sizeInPixels s = (pxX s, pxY s)

-

--- | Calculate (height, width) in points using the image file's dpi metadata,

--- using 72 Points == 1 Inch.

-sizeInPoints :: ImageSize -> (Double, Double)

-sizeInPoints s = (pxXf * 72 / dpiXf, pxYf * 72 / dpiYf)

- where

- pxXf = fromIntegral $ pxX s

- pxYf = fromIntegral $ pxY s

- dpiXf = fromIntegral $ dpiX s

- dpiYf = fromIntegral $ dpiY s

-

--- | Calculate (height, width) in points, considering the desired dimensions in the

--- attribute, while falling back on the image file's dpi metadata if no dimensions

--- are specified in the attribute (or only dimensions in percentages).

-desiredSizeInPoints :: WriterOptions -> Attr -> ImageSize -> (Double, Double)

-desiredSizeInPoints opts attr s =

- case (getDim Width, getDim Height) of

- (Just w, Just h) -> (w, h)

- (Just w, Nothing) -> (w, w / ratio)

- (Nothing, Just h) -> (h * ratio, h)

- (Nothing, Nothing) -> sizeInPoints s

- where

- ratio = fromIntegral (pxX s) / fromIntegral (pxY s)

- getDim dir = case (dimension dir attr) of

- Just (Percent _) -> Nothing

- Just dim -> Just $ inPoints opts dim

- Nothing -> Nothing

-

-inPoints :: WriterOptions -> Dimension -> Double

-inPoints opts dim = 72 * inInch opts dim

-

-inInch :: WriterOptions -> Dimension -> Double

-inInch opts dim =

- case dim of

- (Pixel a) -> fromIntegral a / (fromIntegral $ writerDpi opts)

- (Centimeter a) -> a * 0.3937007874

- (Inch a) -> a

- (Percent _) -> 0

-

--- | Convert a Dimension to a String denoting its equivalent in inches, for example "2.00000".

--- Note: Dimensions in percentages are converted to the empty string.

-showInInch :: WriterOptions -> Dimension -> String

-showInInch _ (Percent _) = ""

-showInInch opts dim = showFl $ inInch opts dim

-

--- | Convert a Dimension to a String denoting its equivalent in pixels, for example "600".

--- Note: Dimensions in percentages are converted to the empty string.

-showInPixel :: WriterOptions -> Dimension -> String

-showInPixel opts dim =

- case dim of

- (Pixel a) -> show a

- (Centimeter a) -> show (floor $ dpi * a * 0.3937007874 :: Int)

- (Inch a) -> show (floor $ dpi * a :: Int)

- (Percent _) -> ""

- where

- dpi = fromIntegral $ writerDpi opts

-

--- | Maybe split a string into a leading number and trailing unit, e.g. "3cm" to Just (3.0, "cm")

-numUnit :: String -> Maybe (Double, String)

-numUnit s =

- let (nums, unit) = span (\c -> isDigit c || ('.'==c)) s

- in case safeRead nums of

- Just n -> Just (n, unit)

- Nothing -> Nothing

-

--- | Read a Dimension from an Attr attribute.

--- `dimension Width attr` might return `Just (Pixel 3)` or for example `Just (Centimeter 2.0)`, etc.

-dimension :: Direction -> Attr -> Maybe Dimension

-dimension dir (_, _, kvs) =

- case dir of

- Width -> extractDim "width"

- Height -> extractDim "height"

- where

- extractDim key =

- case lookup key kvs of

- Just str ->

- case numUnit str of

- Just (num, unit) -> toDim num unit

- Nothing -> Nothing

- Nothing -> Nothing

- toDim a "cm" = Just $ Centimeter a

- toDim a "mm" = Just $ Centimeter (a / 10)

- toDim a "in" = Just $ Inch a

- toDim a "inch" = Just $ Inch a

- toDim a "%" = Just $ Percent a

- toDim a "px" = Just $ Pixel (floor a::Integer)

- toDim a "" = Just $ Pixel (floor a::Integer)

- toDim _ _ = Nothing

-

-epsSize :: ByteString -> Maybe ImageSize

-epsSize img = do

- let ls = takeWhile ("%" `B.isPrefixOf`) $ B.lines img

- let ls' = dropWhile (not . ("%%BoundingBox:" `B.isPrefixOf`)) ls

- case ls' of

- [] -> mzero

- (x:_) -> case B.words x of

- (_:_:_:ux:uy:[]) -> do

- ux' <- safeRead $ B.unpack ux

- uy' <- safeRead $ B.unpack uy

- return ImageSize{

- pxX = ux'

- , pxY = uy'

- , dpiX = 72

- , dpiY = 72 }

- _ -> mzero

-

-pngSize :: ByteString -> Maybe ImageSize

-pngSize img = do

- let (h, rest) = B.splitAt 8 img

- guard $ h == "\x8a\x4d\x4e\x47\x0d\x0a\x1a\x0a" ||

- h == "\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"

- let (i, rest') = B.splitAt 4 $ B.drop 4 rest

- guard $ i == "MHDR" || i == "IHDR"

- let (sizes, rest'') = B.splitAt 8 rest'

- (x,y) <- case map fromIntegral $ unpack $ sizes of

- ([w1,w2,w3,w4,h1,h2,h3,h4] :: [Integer]) -> return

- ((shift w1 24) + (shift w2 16) + (shift w3 8) + w4,

- (shift h1 24) + (shift h2 16) + (shift h3 8) + h4)

- _ -> Nothing -- "PNG parse error"

- let (dpix, dpiy) = findpHYs rest''

- return $ ImageSize { pxX = x, pxY = y, dpiX = dpix, dpiY = dpiy }

-

-findpHYs :: ByteString -> (Integer, Integer)

-findpHYs x =

- if B.null x || "IDAT" `B.isPrefixOf` x

- then (72,72) -- default, no pHYs

- else if "pHYs" `B.isPrefixOf` x

- then let [x1,x2,x3,x4,y1,y2,y3,y4,u] = map fromIntegral

- $ unpack $ B.take 9 $ B.drop 4 x

- factor = if u == 1 -- dots per meter

- then \z -> z * 254 `div` 10000

- else const 72

- in ( factor $ (shift x1 24) + (shift x2 16) + (shift x3 8) + x4,

- factor $ (shift y1 24) + (shift y2 16) + (shift y3 8) + y4 )

- else findpHYs $ B.drop 1 x -- read another byte

-

-gifSize :: ByteString -> Maybe ImageSize

-gifSize img = do

- let (h, rest) = B.splitAt 6 img

- guard $ h == "GIF87a" || h == "GIF89a"

- case map fromIntegral $ unpack $ B.take 4 rest of

- [w2,w1,h2,h1] -> return ImageSize {

- pxX = shift w1 8 + w2,

- pxY = shift h1 8 + h2,

- dpiX = 72,

- dpiY = 72

- }

- _ -> Nothing -- "GIF parse error"

-

-jpegSize :: ByteString -> Either String ImageSize

-jpegSize img =

- let (hdr, rest) = B.splitAt 4 img

- in if B.length rest < 14

- then Left "unable to determine JPEG size"

- else case hdr of

- "\xff\xd8\xff\xe0" -> jfifSize rest

- "\xff\xd8\xff\xe1" -> exifSize rest

- _ -> Left "unable to determine JPEG size"

-

-jfifSize :: ByteString -> Either String ImageSize

-jfifSize rest =

- let [dpiDensity,dpix1,dpix2,dpiy1,dpiy2] = map fromIntegral

- $ unpack $ B.take 5 $ B.drop 9 $ rest

- factor = case dpiDensity of

- 1 -> id

- 2 -> \x -> (x * 254 `div` 10)

- _ -> const 72

- dpix = factor (shift dpix1 8 + dpix2)

- dpiy = factor (shift dpiy1 8 + dpiy2)

- in case findJfifSize rest of

- Left msg -> Left msg

- Right (w,h) -> Right $ ImageSize { pxX = w

- , pxY = h

- , dpiX = dpix

- , dpiY = dpiy }

-

-findJfifSize :: ByteString -> Either String (Integer,Integer)

-findJfifSize bs =

- let bs' = B.dropWhile (=='\xff') $ B.dropWhile (/='\xff') bs

- in case B.uncons bs' of

- Just (c,bs'') | c >= '\xc0' && c <= '\xc3' ->

- case map fromIntegral $ unpack $ B.take 4 $ B.drop 3 bs'' of

- [h1,h2,w1,w2] -> Right (shift w1 8 + w2, shift h1 8 + h2)

- _ -> Left "JFIF parse error"

- Just (_,bs'') ->

- case map fromIntegral $ unpack $ B.take 2 bs'' of

- [c1,c2] ->

- let len = shift c1 8 + c2

- -- skip variables

- in findJfifSize $ B.drop len bs''

- _ -> Left "JFIF parse error"

- Nothing -> Left "Did not find JFIF length record"

-

-runGet' :: Get (Either String a) -> BL.ByteString -> Either String a

-runGet' p bl =

-#if MIN_VERSION_binary(0,7,0)

- case runGetOrFail p bl of

- Left (_,_,msg) -> Left msg

- Right (_,_,x) -> x

-#else

- runGet p bl

-#endif

-

-

-exifSize :: ByteString -> Either String ImageSize

-exifSize bs = runGet' header $ bl

- where bl = BL.fromChunks [bs]

- header = runExceptT $ exifHeader bl

--- NOTE: It would be nicer to do

--- runGet ((Just <$> exifHeader) <|> return Nothing)

--- which would prevent pandoc from raising an error when an exif header can't

--- be parsed. But we only get an Alternative instance for Get in binary 0.6,

--- and binary 0.5 ships with ghc 7.6.

-

-exifHeader :: BL.ByteString -> ExceptT String Get ImageSize

-exifHeader hdr = do

- _app1DataSize <- lift getWord16be

- exifHdr <- lift getWord32be

- unless (exifHdr == 0x45786966) $ throwError "Did not find exif header"

- zeros <- lift getWord16be

- unless (zeros == 0) $ throwError "Expected zeros after exif header"

- -- beginning of tiff header -- we read whole thing to use

- -- in getting data from offsets:

- let tiffHeader = BL.drop 8 hdr

- byteAlign <- lift getWord16be

- let bigEndian = byteAlign == 0x4d4d

- let (getWord16, getWord32, getWord64) =

- if bigEndian

- then (getWord16be, getWord32be, getWord64be)

- else (getWord16le, getWord32le, getWord64le)

- let getRational = do

- num <- getWord32

- den <- getWord32

- return $ fromIntegral num / fromIntegral den

- tagmark <- lift getWord16

- unless (tagmark == 0x002a) $ throwError "Failed alignment sanity check"

- ifdOffset <- lift getWord32

- lift $ skip (fromIntegral ifdOffset - 8) -- skip to IDF

- numentries <- lift getWord16

- let ifdEntry :: ExceptT String Get (TagType, DataFormat)

- ifdEntry = do

- tag <- fromMaybe UnknownTagType . flip M.lookup tagTypeTable

- <$> lift getWord16

- dataFormat <- lift getWord16

- numComponents <- lift getWord32

- (fmt, bytesPerComponent) <-

- case dataFormat of

- 1 -> return (UnsignedByte <$> getWord8, 1)

- 2 -> return (AsciiString <$>

- getLazyByteString

- (fromIntegral numComponents), 1)

- 3 -> return (UnsignedShort <$> getWord16, 2)

- 4 -> return (UnsignedLong <$> getWord32, 4)

- 5 -> return (UnsignedRational <$> getRational, 8)

- 6 -> return (SignedByte <$> getWord8, 1)

- 7 -> return (Undefined <$> getLazyByteString

- (fromIntegral numComponents), 1)

- 8 -> return (SignedShort <$> getWord16, 2)

- 9 -> return (SignedLong <$> getWord32, 4)

- 10 -> return (SignedRational <$> getRational, 8)

- 11 -> return (SingleFloat <$> getWord32 {- TODO -}, 4)

- 12 -> return (DoubleFloat <$> getWord64 {- TODO -}, 8)

- _ -> throwError $ "Unknown data format " ++ show dataFormat

- let totalBytes = fromIntegral $ numComponents * bytesPerComponent

- payload <- if totalBytes <= 4 -- data is right here

- then lift $ fmt <* skip (4 - totalBytes)

- else do -- get data from offset

- offs <- lift getWord32

- let bytesAtOffset =

- BL.take (fromIntegral totalBytes)

- $ BL.drop (fromIntegral offs) tiffHeader

- case runGet' (Right <$> fmt) bytesAtOffset of

- Left msg -> throwError msg

- Right x -> return x

- return (tag, payload)

- entries <- sequence $ replicate (fromIntegral numentries) ifdEntry

- subentries <- case lookup ExifOffset entries of

- Just (UnsignedLong offset') -> do

- pos <- lift bytesRead

- lift $ skip (fromIntegral offset' - (fromIntegral pos - 8))

- numsubentries <- lift getWord16

- sequence $

- replicate (fromIntegral numsubentries) ifdEntry

- _ -> return []

- let allentries = entries ++ subentries

- (wdth, hght) <- case (lookup ExifImageWidth allentries,

- lookup ExifImageHeight allentries) of

- (Just (UnsignedLong w), Just (UnsignedLong h)) ->

- return (fromIntegral w, fromIntegral h)

- _ -> return defaultSize

- -- we return a default width and height when

- -- the exif header doesn't contain these

- let resfactor = case lookup ResolutionUnit allentries of

- Just (UnsignedShort 1) -> (100 / 254)

- _ -> 1

- let xres = maybe 72 (\(UnsignedRational x) -> floor $ x * resfactor)

- $ lookup XResolution allentries

- let yres = maybe 72 (\(UnsignedRational x) -> floor $ x * resfactor)

- $ lookup YResolution allentries

- return $ ImageSize{

- pxX = wdth

- , pxY = hght

- , dpiX = xres

- , dpiY = yres }

-

-data DataFormat = UnsignedByte Word8

- | AsciiString BL.ByteString

- | UnsignedShort Word16

- | UnsignedLong Word32

- | UnsignedRational Rational

- | SignedByte Word8

- | Undefined BL.ByteString

- | SignedShort Word16

- | SignedLong Word32

- | SignedRational Rational

- | SingleFloat Word32

- | DoubleFloat Word64

- deriving (Show)

-

-data TagType = ImageDescription

- | Make

- | Model

- | Orientation

- | XResolution

- | YResolution

- | ResolutionUnit

- | Software

- | DateTime

- | WhitePoint

- | PrimaryChromaticities

- | YCbCrCoefficients

- | YCbCrPositioning

- | ReferenceBlackWhite

- | Copyright

- | ExifOffset

- | ExposureTime

- | FNumber

- | ExposureProgram

- | ISOSpeedRatings

- | ExifVersion

- | DateTimeOriginal

- | DateTimeDigitized

- | ComponentConfiguration

- | CompressedBitsPerPixel

- | ShutterSpeedValue

- | ApertureValue

- | BrightnessValue

- | ExposureBiasValue

- | MaxApertureValue

- | SubjectDistance

- | MeteringMode

- | LightSource

- | Flash

- | FocalLength

- | MakerNote

- | UserComment

- | FlashPixVersion

- | ColorSpace

- | ExifImageWidth

- | ExifImageHeight

- | RelatedSoundFile

- | ExifInteroperabilityOffset

- | FocalPlaneXResolution

- | FocalPlaneYResolution

- | FocalPlaneResolutionUnit

- | SensingMethod

- | FileSource

- | SceneType

- | UnknownTagType

- deriving (Show, Eq, Ord)

-

-tagTypeTable :: M.Map Word16 TagType

-tagTypeTable = M.fromList

- [ (0x010e, ImageDescription)

- , (0x010f, Make)

- , (0x0110, Model)

- , (0x0112, Orientation)

- , (0x011a, XResolution)

- , (0x011b, YResolution)

- , (0x0128, ResolutionUnit)

- , (0x0131, Software)

- , (0x0132, DateTime)

- , (0x013e, WhitePoint)

- , (0x013f, PrimaryChromaticities)

- , (0x0211, YCbCrCoefficients)

- , (0x0213, YCbCrPositioning)

- , (0x0214, ReferenceBlackWhite)

- , (0x8298, Copyright)

- , (0x8769, ExifOffset)

- , (0x829a, ExposureTime)

- , (0x829d, FNumber)

- , (0x8822, ExposureProgram)

- , (0x8827, ISOSpeedRatings)

- , (0x9000, ExifVersion)

- , (0x9003, DateTimeOriginal)

- , (0x9004, DateTimeDigitized)

- , (0x9101, ComponentConfiguration)

- , (0x9102, CompressedBitsPerPixel)

- , (0x9201, ShutterSpeedValue)

- , (0x9202, ApertureValue)

- , (0x9203, BrightnessValue)

- , (0x9204, ExposureBiasValue)

- , (0x9205, MaxApertureValue)

- , (0x9206, SubjectDistance)

- , (0x9207, MeteringMode)

- , (0x9208, LightSource)

- , (0x9209, Flash)

- , (0x920a, FocalLength)

- , (0x927c, MakerNote)

- , (0x9286, UserComment)

- , (0xa000, FlashPixVersion)

- , (0xa001, ColorSpace)

- , (0xa002, ExifImageWidth)

- , (0xa003, ExifImageHeight)

- , (0xa004, RelatedSoundFile)

- , (0xa005, ExifInteroperabilityOffset)

- , (0xa20e, FocalPlaneXResolution)

- , (0xa20f, FocalPlaneYResolution)

- , (0xa210, FocalPlaneResolutionUnit)

- , (0xa217, SensingMethod)

- , (0xa300, FileSource)

- , (0xa301, SceneType)

- ]

-{-# LANGUAGE DeriveDataTypeable, DeriveGeneric, OverloadedStrings #-}

-{-

-Copyright (C) 2016-17 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-{- |

- Module : Text.Pandoc.Logging

- Copyright : Copyright (C) 2006-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-This module provides data types and functions for warnings

-and info messages.

-

--}

-module Text.Pandoc.Logging (

- Verbosity(..)

- , LogMessage(..)

- , encodeLogMessages

- , showLogMessage

- , messageVerbosity

- ) where

-

-import Text.Parsec.Pos

-import Data.Data (Data)

-import Data.Generics (Typeable)

-import GHC.Generics (Generic)

-import qualified Data.Text as Text

-import Data.Aeson

-import Text.Pandoc.Definition

-import Data.Aeson.Encode.Pretty (encodePretty', keyOrder,

- defConfig, Config(..))

-import qualified Data.ByteString.Lazy as BL

-

--- | Verbosity level.

-data Verbosity = ERROR | WARNING | INFO | DEBUG

- deriving (Show, Read, Eq, Data, Enum, Ord, Bounded, Typeable, Generic)

-

-instance ToJSON Verbosity where

- toJSON x = toJSON (show x)

-

-data LogMessage =

- SkippedContent String SourcePos

- | CouldNotParseYamlMetadata String SourcePos

- | DuplicateLinkReference String SourcePos

- | DuplicateNoteReference String SourcePos

- | ReferenceNotFound String SourcePos

- | CircularReference String SourcePos

- | ParsingUnescaped String SourcePos

- | CouldNotLoadIncludeFile String SourcePos

- | ParsingTrace String SourcePos

- | InlineNotRendered Inline

- | BlockNotRendered Block

- | DocxParserWarning String

- | CouldNotFetchResource String String

- | CouldNotDetermineImageSize String String

- | CouldNotDetermineMimeType String

- | CouldNotConvertTeXMath String String

- deriving (Show, Eq, Data, Ord, Typeable, Generic)

-

-instance ToJSON LogMessage where

- toJSON x = object $ "verbosity" .= toJSON (messageVerbosity x) :

- case x of

- SkippedContent s pos ->

- ["type" .= String "SkippedContent",

- "contents" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= sourceLine pos,

- "column" .= sourceColumn pos]

- CouldNotParseYamlMetadata s pos ->

- ["type" .= String "YamlSectionNotAnObject",

- "message" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= toJSON (sourceLine pos),

- "column" .= toJSON (sourceColumn pos)]

- DuplicateLinkReference s pos ->

- ["type" .= String "DuplicateLinkReference",

- "contents" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= toJSON (sourceLine pos),

- "column" .= toJSON (sourceColumn pos)]

- DuplicateNoteReference s pos ->

- ["type" .= String "DuplicateNoteReference",

- "contents" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= toJSON (sourceLine pos),

- "column" .= toJSON (sourceColumn pos)]

- ReferenceNotFound s pos ->

- ["type" .= String "ReferenceNotFound",

- "contents" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= toJSON (sourceLine pos),

- "column" .= toJSON (sourceColumn pos)]

- CircularReference s pos ->

- ["type" .= String "CircularReference",

- "contents" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= toJSON (sourceLine pos),

- "column" .= toJSON (sourceColumn pos)]

- ParsingUnescaped s pos ->

- ["type" .= String "ParsingUnescaped",

- "contents" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= toJSON (sourceLine pos),

- "column" .= toJSON (sourceColumn pos)]

- CouldNotLoadIncludeFile fp pos ->

- ["type" .= String "CouldNotLoadIncludeFile",

- "path" .= Text.pack fp,

- "source" .= Text.pack (sourceName pos),

- "line" .= toJSON (sourceLine pos),

- "column" .= toJSON (sourceColumn pos)]

- ParsingTrace s pos ->

- ["type" .= String "ParsingTrace",

- "contents" .= Text.pack s,

- "source" .= Text.pack (sourceName pos),

- "line" .= sourceLine pos,

- "column" .= sourceColumn pos]

- InlineNotRendered il ->

- ["type" .= String "InlineNotRendered",

- "contents" .= toJSON il]

- BlockNotRendered bl ->

- ["type" .= String "BlockNotRendered",

- "contents" .= toJSON bl]

- DocxParserWarning s ->

- ["type" .= String "DocxParserWarning",

- "contents" .= Text.pack s]

- CouldNotFetchResource fp s ->

- ["type" .= String "CouldNotFetchResource",

- "path" .= Text.pack fp,

- "message" .= Text.pack s]

- CouldNotDetermineImageSize fp s ->

- ["type" .= String "CouldNotDetermineImageSize",

- "path" .= Text.pack fp,

- "message" .= Text.pack s]

- CouldNotDetermineMimeType fp ->

- ["type" .= String "CouldNotDetermineMimeType",

- "path" .= Text.pack fp]

- CouldNotConvertTeXMath s msg ->

- ["type" .= String "CouldNotConvertTeXMath",

- "contents" .= Text.pack s,

- "message" .= Text.pack msg]

-

-showPos :: SourcePos -> String

-showPos pos = sn ++ "line " ++

- show (sourceLine pos) ++ " column " ++ show (sourceColumn pos)

- where sn = if sourceName pos == "source" || sourceName pos == ""

- then ""

- else sourceName pos ++ " "

-

-encodeLogMessages :: [LogMessage] -> BL.ByteString

-encodeLogMessages ms =

- encodePretty' defConfig{ confCompare =

- keyOrder [ "type", "verbosity", "contents", "message", "path",

- "source", "line", "column" ] } ms

-

-showLogMessage :: LogMessage -> String

-showLogMessage msg =

- case msg of

- SkippedContent s pos ->

- "Skipped '" ++ s ++ "' at " ++ showPos pos

- CouldNotParseYamlMetadata s pos ->

- "Could not parse YAML metadata at " ++ showPos pos ++

- if null s then "" else (": " ++ s)

- DuplicateLinkReference s pos ->

- "Duplicate link reference '" ++ s ++ "' at " ++ showPos pos

- DuplicateNoteReference s pos ->

- "Duplicate note reference '" ++ s ++ "' at " ++ showPos pos

- ReferenceNotFound s pos ->

- "Reference not found for '" ++ s ++ "' at " ++ showPos pos

- CircularReference s pos ->

- "Circular reference '" ++ s ++ "' at " ++ showPos pos

- ParsingUnescaped s pos ->

- "Parsing unescaped '" ++ s ++ "' at " ++ showPos pos

- CouldNotLoadIncludeFile fp pos ->

- "Could not load include file '" ++ fp ++ "' at " ++ showPos pos

- ParsingTrace s pos ->

- "Parsing trace at " ++ showPos pos ++ ": " ++ s

- InlineNotRendered il ->

- "Not rendering " ++ show il

- BlockNotRendered bl ->

- "Not rendering " ++ show bl

- DocxParserWarning s ->

- "Docx parser warning: " ++ s

- CouldNotFetchResource fp s ->

- "Could not fetch resource '" ++ fp ++ "'" ++

- if null s then "" else (": " ++ s)

- CouldNotDetermineImageSize fp s ->

- "Could not determine image size for '" ++ fp ++ "'" ++

- if null s then "" else (": " ++ s)

- CouldNotDetermineMimeType fp ->

- "Could not determine mime type for '" ++ fp ++ "'"

- CouldNotConvertTeXMath s m ->

- "Could not convert TeX math '" ++ s ++ "', rendering as TeX" ++

- if null m then "" else (':':'\n':m)

-

-messageVerbosity:: LogMessage -> Verbosity

-messageVerbosity msg =

- case msg of

- SkippedContent{} -> INFO

- CouldNotParseYamlMetadata{} -> WARNING

- DuplicateLinkReference{} -> WARNING

- DuplicateNoteReference{} -> WARNING

- ReferenceNotFound{} -> WARNING

- CircularReference{} -> WARNING

- CouldNotLoadIncludeFile{} -> WARNING

- ParsingUnescaped{} -> INFO

- ParsingTrace{} -> DEBUG

- InlineNotRendered{} -> INFO

- BlockNotRendered{} -> INFO

- DocxParserWarning{} -> WARNING

- CouldNotFetchResource{} -> WARNING

- CouldNotDetermineImageSize{} -> WARNING

- CouldNotDetermineMimeType{} -> WARNING

- CouldNotConvertTeXMath{} -> WARNING

-

-

-{-

-Copyright (C) 2011-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.MIME

- Copyright : Copyright (C) 2011-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Mime type lookup for ODT writer.

--}

-module Text.Pandoc.MIME ( MimeType, getMimeType, getMimeTypeDef,

- extensionFromMimeType )where

-import System.FilePath

-import Data.Char ( toLower )

-import Data.List (isPrefixOf, isSuffixOf)

-import Data.Maybe (fromMaybe)

-import qualified Data.Map as M

-

-type MimeType = String

-

--- | Determine mime type appropriate for file path.

-getMimeType :: FilePath -> Maybe MimeType

-getMimeType fp

- -- ODT

- | fp == "layout-cache" =

- Just "application/binary"

- | "Formula-" `isPrefixOf` fp && "/" `isSuffixOf` fp =

- Just "application/vnd.oasis.opendocument.formula"

- -- generic

- | otherwise = M.lookup (map toLower $ drop 1 $ takeExtension fp) mimeTypes

-

--- | Determime mime type appropriate for file path, defaulting to

--- “application/octet-stream” if nothing else fits.

-getMimeTypeDef :: FilePath -> MimeType

-getMimeTypeDef = fromMaybe "application/octet-stream" . getMimeType

-

-extensionFromMimeType :: MimeType -> Maybe String

-extensionFromMimeType mimetype =

- M.lookup (takeWhile (/=';') mimetype) reverseMimeTypes

- -- note: we just look up the basic mime type, dropping the content-encoding etc.

-

-reverseMimeTypes :: M.Map MimeType String

-reverseMimeTypes = M.fromList $ map (\(k,v) -> (v,k)) mimeTypesList

-

-mimeTypes :: M.Map String MimeType

-mimeTypes = M.fromList mimeTypesList

-

-mimeTypesList :: [(String, MimeType)]

-mimeTypesList = -- List borrowed from happstack-server.

- [("gz","application/x-gzip")

- ,("cabal","application/x-cabal")

- ,("%","application/x-trash")

- ,("323","text/h323")

- ,("3gp","video/3gpp")

- ,("7z","application/x-7z-compressed")

- ,("abw","application/x-abiword")

- ,("ai","application/postscript")

- ,("aif","audio/x-aiff")

- ,("aifc","audio/x-aiff")

- ,("aiff","audio/x-aiff")

- ,("alc","chemical/x-alchemy")

- ,("art","image/x-jg")

- ,("asc","text/plain")

- ,("asf","video/x-ms-asf")

- ,("asn","chemical/x-ncbi-asn1")

- ,("aso","chemical/x-ncbi-asn1-binary")

- ,("asx","video/x-ms-asf")

- ,("atom","application/atom")

- ,("atomcat","application/atomcat+xml")

- ,("atomsrv","application/atomserv+xml")

- ,("au","audio/basic")

- ,("avi","video/x-msvideo")

- ,("b","chemical/x-molconn-Z")

- ,("bak","application/x-trash")

- ,("bat","application/x-msdos-program")

- ,("bcpio","application/x-bcpio")

- ,("bib","text/x-bibtex")

- ,("bin","application/octet-stream")

- ,("bmp","image/x-ms-bmp")

- ,("boo","text/x-boo")

- ,("book","application/x-maker")

- ,("bsd","chemical/x-crossfire")

- ,("c","text/x-csrc")

- ,("c++","text/x-c++src")

- ,("c3d","chemical/x-chem3d")

- ,("cab","application/x-cab")

- ,("cac","chemical/x-cache")

- ,("cache","chemical/x-cache")

- ,("cap","application/cap")

- ,("cascii","chemical/x-cactvs-binary")

- ,("cat","application/vnd.ms-pki.seccat")

- ,("cbin","chemical/x-cactvs-binary")

- ,("cbr","application/x-cbr")

- ,("cbz","application/x-cbz")

- ,("cc","text/x-c++src")

- ,("cdf","application/x-cdf")

- ,("cdr","image/x-coreldraw")

- ,("cdt","image/x-coreldrawtemplate")

- ,("cdx","chemical/x-cdx")

- ,("cdy","application/vnd.cinderella")

- ,("cef","chemical/x-cxf")

- ,("cer","chemical/x-cerius")

- ,("chm","chemical/x-chemdraw")

- ,("chrt","application/x-kchart")

- ,("cif","chemical/x-cif")

- ,("class","application/java-vm")

- ,("cls","text/x-tex")

- ,("cmdf","chemical/x-cmdf")

- ,("cml","chemical/x-cml")

- ,("cod","application/vnd.rim.cod")

- ,("com","application/x-msdos-program")

- ,("cpa","chemical/x-compass")

- ,("cpio","application/x-cpio")

- ,("cpp","text/x-c++src")

- ,("cpt","application/mac-compactpro")

- ,("crl","application/x-pkcs7-crl")

- ,("crt","application/x-x509-ca-cert")

- ,("csf","chemical/x-cache-csf")

- ,("csh","application/x-csh")

- ,("csm","chemical/x-csml")

- ,("csml","chemical/x-csml")

- ,("css","text/css")

- ,("csv","text/csv")

- ,("ctab","chemical/x-cactvs-binary")

- ,("ctx","chemical/x-ctx")

- ,("cu","application/cu-seeme")

- ,("cub","chemical/x-gaussian-cube")

- ,("cxf","chemical/x-cxf")

- ,("cxx","text/x-c++src")

- ,("d","text/x-dsrc")

- ,("dat","chemical/x-mopac-input")

- ,("dcr","application/x-director")

- ,("deb","application/x-debian-package")

- ,("dif","video/dv")

- ,("diff","text/x-diff")

- ,("dir","application/x-director")

- ,("djv","image/vnd.djvu")

- ,("djvu","image/vnd.djvu")

- ,("dl","video/dl")

- ,("dll","application/x-msdos-program")

- ,("dmg","application/x-apple-diskimage")

- ,("dms","application/x-dms")

- ,("doc","application/msword")

- ,("dot","application/msword")

- ,("dv","video/dv")

- ,("dvi","application/x-dvi")

- ,("dx","chemical/x-jcamp-dx")

- ,("dxr","application/x-director")

- ,("emb","chemical/x-embl-dl-nucleotide")

- ,("embl","chemical/x-embl-dl-nucleotide")

- ,("emf","image/x-emf")

- ,("eml","message/rfc822")

- ,("ent","chemical/x-ncbi-asn1-ascii")

- ,("eot","application/vnd.ms-fontobject")

- ,("eps","application/postscript")

- ,("etx","text/x-setext")

- ,("exe","application/x-msdos-program")

- ,("ez","application/andrew-inset")

- ,("fb","application/x-maker")

- ,("fbdoc","application/x-maker")

- ,("fch","chemical/x-gaussian-checkpoint")

- ,("fchk","chemical/x-gaussian-checkpoint")

- ,("fig","application/x-xfig")

- ,("flac","application/x-flac")

- ,("fli","video/fli")

- ,("fm","application/x-maker")

- ,("frame","application/x-maker")

- ,("frm","application/x-maker")

- ,("fs","text/plain")

- ,("gal","chemical/x-gaussian-log")

- ,("gam","chemical/x-gamess-input")

- ,("gamin","chemical/x-gamess-input")

- ,("gau","chemical/x-gaussian-input")

- ,("gcd","text/x-pcs-gcd")

- ,("gcf","application/x-graphing-calculator")

- ,("gcg","chemical/x-gcg8-sequence")

- ,("gen","chemical/x-genbank")

- ,("gf","application/x-tex-gf")

- ,("gif","image/gif")

- ,("gjc","chemical/x-gaussian-input")

- ,("gjf","chemical/x-gaussian-input")

- ,("gl","video/gl")

- ,("gnumeric","application/x-gnumeric")

- ,("gpt","chemical/x-mopac-graph")

- ,("gsf","application/x-font")

- ,("gsm","audio/x-gsm")

- ,("gtar","application/x-gtar")

- ,("h","text/x-chdr")

- ,("h++","text/x-c++hdr")

- ,("hdf","application/x-hdf")

- ,("hh","text/x-c++hdr")

- ,("hin","chemical/x-hin")

- ,("hpp","text/x-c++hdr")

- ,("hqx","application/mac-binhex40")

- ,("hs","text/x-haskell")

- ,("hta","application/hta")

- ,("htc","text/x-component")

- ,("htm","text/html")

- ,("html","text/html")

- ,("hxx","text/x-c++hdr")

- ,("ica","application/x-ica")

- ,("ice","x-conference/x-cooltalk")

- ,("ico","image/x-icon")

- ,("ics","text/calendar")

- ,("icz","text/calendar")

- ,("ief","image/ief")

- ,("iges","model/iges")

- ,("igs","model/iges")

- ,("iii","application/x-iphone")

- ,("inp","chemical/x-gamess-input")

- ,("ins","application/x-internet-signup")

- ,("iso","application/x-iso9660-image")

- ,("isp","application/x-internet-signup")

- ,("ist","chemical/x-isostar")

- ,("istr","chemical/x-isostar")

- ,("jad","text/vnd.sun.j2me.app-descriptor")

- ,("jar","application/java-archive")

- ,("java","text/x-java")

- ,("jdx","chemical/x-jcamp-dx")

- ,("jmz","application/x-jmol")

- ,("jng","image/x-jng")

- ,("jnlp","application/x-java-jnlp-file")

- ,("jpe","image/jpeg")

- ,("jpeg","image/jpeg")

- ,("jfif","image/jpeg")

- ,("jpg","image/jpeg")

- ,("js","application/x-javascript")

- ,("kar","audio/midi")

- ,("key","application/pgp-keys")

- ,("kil","application/x-killustrator")

- ,("kin","chemical/x-kinemage")

- ,("kml","application/vnd.google-earth.kml+xml")

- ,("kmz","application/vnd.google-earth.kmz")

- ,("kpr","application/x-kpresenter")

- ,("kpt","application/x-kpresenter")

- ,("ksp","application/x-kspread")

- ,("kwd","application/x-kword")

- ,("kwt","application/x-kword")

- ,("latex","application/x-latex")

- ,("lha","application/x-lha")

- ,("lhs","text/x-literate-haskell")

- ,("lsf","video/x-la-asf")

- ,("lsx","video/x-la-asf")

- ,("ltx","text/x-tex")

- ,("lyx","application/x-lyx")

- ,("lzh","application/x-lzh")

- ,("lzx","application/x-lzx")

- ,("m3u","audio/mpegurl")

- ,("m4a","audio/mpeg")

- ,("m4v","video/x-m4v")

- ,("maker","application/x-maker")

- ,("man","application/x-troff-man")

- ,("mcif","chemical/x-mmcif")

- ,("mcm","chemical/x-macmolecule")

- ,("mdb","application/msaccess")

- ,("me","application/x-troff-me")

- ,("mesh","model/mesh")

- ,("mid","audio/midi")

- ,("midi","audio/midi")

- ,("mif","application/x-mif")

- ,("mm","application/x-freemind")

- ,("mmd","chemical/x-macromodel-input")

- ,("mmf","application/vnd.smaf")

- ,("mml","text/mathml")

- ,("mmod","chemical/x-macromodel-input")

- ,("mng","video/x-mng")

- ,("moc","text/x-moc")

- ,("mol","chemical/x-mdl-molfile")

- ,("mol2","chemical/x-mol2")

- ,("moo","chemical/x-mopac-out")

- ,("mop","chemical/x-mopac-input")

- ,("mopcrt","chemical/x-mopac-input")

- ,("mov","video/quicktime")

- ,("movie","video/x-sgi-movie")

- ,("mp2","audio/mpeg")

- ,("mp3","audio/mpeg")

- ,("mp4","video/mp4")

- ,("mpc","chemical/x-mopac-input")

- ,("mpe","video/mpeg")

- ,("mpeg","video/mpeg")

- ,("mpega","audio/mpeg")

- ,("mpg","video/mpeg")

- ,("mpga","audio/mpeg")

- ,("ms","application/x-troff-ms")

- ,("msh","model/mesh")

- ,("msi","application/x-msi")

- ,("mvb","chemical/x-mopac-vib")

- ,("mxu","video/vnd.mpegurl")

- ,("nb","application/mathematica")

- ,("nc","application/x-netcdf")

- ,("nwc","application/x-nwc")

- ,("o","application/x-object")

- ,("oda","application/oda")

- ,("odb","application/vnd.oasis.opendocument.database")

- ,("odc","application/vnd.oasis.opendocument.chart")

- ,("odf","application/vnd.oasis.opendocument.formula")

- ,("odg","application/vnd.oasis.opendocument.graphics")

- ,("odi","application/vnd.oasis.opendocument.image")

- ,("odm","application/vnd.oasis.opendocument.text-master")

- ,("odp","application/vnd.oasis.opendocument.presentation")

- ,("ods","application/vnd.oasis.opendocument.spreadsheet")

- ,("odt","application/vnd.oasis.opendocument.text")

- ,("oga","audio/ogg")

- ,("ogg","application/ogg")

- ,("ogv","video/ogg")

- ,("ogx","application/ogg")

- ,("old","application/x-trash")

- ,("otg","application/vnd.oasis.opendocument.graphics-template")

- ,("oth","application/vnd.oasis.opendocument.text-web")

- ,("otp","application/vnd.oasis.opendocument.presentation-template")

- ,("ots","application/vnd.oasis.opendocument.spreadsheet-template")

- ,("otf","application/vnd.ms-opentype")

- ,("ott","application/vnd.oasis.opendocument.text-template")

- ,("oza","application/x-oz-application")

- ,("p","text/x-pascal")

- ,("p7r","application/x-pkcs7-certreqresp")

- ,("pac","application/x-ns-proxy-autoconfig")

- ,("pas","text/x-pascal")

- ,("pat","image/x-coreldrawpattern")

- ,("patch","text/x-diff")

- ,("pbm","image/x-portable-bitmap")

- ,("pcap","application/cap")

- ,("pcf","application/x-font")

- ,("pcf.Z","application/x-font")

- ,("pcx","image/pcx")

- ,("pdb","chemical/x-pdb")

- ,("pdf","application/pdf")

- ,("pfa","application/x-font")

- ,("pfb","application/x-font")

- ,("pgm","image/x-portable-graymap")

- ,("pgn","application/x-chess-pgn")

- ,("pgp","application/pgp-signature")

- ,("php","application/x-httpd-php")

- ,("php3","application/x-httpd-php3")

- ,("php3p","application/x-httpd-php3-preprocessed")

- ,("php4","application/x-httpd-php4")

- ,("phps","application/x-httpd-php-source")

- ,("pht","application/x-httpd-php")

- ,("phtml","application/x-httpd-php")

- ,("pk","application/x-tex-pk")

- ,("pl","text/x-perl")

- ,("pls","audio/x-scpls")

- ,("pm","text/x-perl")

- ,("png","image/png")

- ,("pnm","image/x-portable-anymap")

- ,("pot","text/plain")

- ,("ppm","image/x-portable-pixmap")

- ,("pps","application/vnd.ms-powerpoint")

- ,("ppt","application/vnd.ms-powerpoint")

- ,("prf","application/pics-rules")

- ,("prt","chemical/x-ncbi-asn1-ascii")

- ,("ps","application/postscript")

- ,("psd","image/x-photoshop")

- ,("py","text/x-python")

- ,("pyc","application/x-python-code")

- ,("pyo","application/x-python-code")

- ,("qt","video/quicktime")

- ,("qtl","application/x-quicktimeplayer")

- ,("ra","audio/x-pn-realaudio")

- ,("ram","audio/x-pn-realaudio")

- ,("rar","application/rar")

- ,("ras","image/x-cmu-raster")

- ,("rd","chemical/x-mdl-rdfile")

- ,("rdf","application/rdf+xml")

- ,("rgb","image/x-rgb")

- ,("rhtml","application/x-httpd-eruby")

- ,("rm","audio/x-pn-realaudio")

- ,("roff","application/x-troff")

- ,("ros","chemical/x-rosdal")

- ,("rpm","application/x-redhat-package-manager")

- ,("rss","application/rss+xml")

- ,("rtf","application/rtf")

- ,("rtx","text/richtext")

- ,("rxn","chemical/x-mdl-rxnfile")

- ,("sct","text/scriptlet")

- ,("sd","chemical/x-mdl-sdfile")

- ,("sd2","audio/x-sd2")

- ,("sda","application/vnd.stardivision.draw")

- ,("sdc","application/vnd.stardivision.calc")

- ,("sdd","application/vnd.stardivision.impress")

- ,("sdf","application/vnd.stardivision.math")

- ,("sds","application/vnd.stardivision.chart")

- ,("sdw","application/vnd.stardivision.writer")

- ,("ser","application/java-serialized-object")

- ,("sgf","application/x-go-sgf")

- ,("sgl","application/vnd.stardivision.writer-global")

- ,("sh","application/x-sh")

- ,("shar","application/x-shar")

- ,("shtml","text/html")

- ,("sid","audio/prs.sid")

- ,("sik","application/x-trash")

- ,("silo","model/mesh")

- ,("sis","application/vnd.symbian.install")

- ,("sisx","x-epoc/x-sisx-app")

- ,("sit","application/x-stuffit")

- ,("sitx","application/x-stuffit")

- ,("skd","application/x-koan")

- ,("skm","application/x-koan")

- ,("skp","application/x-koan")

- ,("skt","application/x-koan")

- ,("smi","application/smil")

- ,("smil","application/smil")

- ,("snd","audio/basic")

- ,("spc","chemical/x-galactic-spc")

- ,("spl","application/futuresplash")

- ,("spx","audio/ogg")

- ,("src","application/x-wais-source")

- ,("stc","application/vnd.sun.xml.calc.template")

- ,("std","application/vnd.sun.xml.draw.template")

- ,("sti","application/vnd.sun.xml.impress.template")

- ,("stl","application/vnd.ms-pki.stl")

- ,("stw","application/vnd.sun.xml.writer.template")

- ,("sty","text/x-tex")

- ,("sv4cpio","application/x-sv4cpio")

- ,("sv4crc","application/x-sv4crc")

- ,("svg","image/svg+xml")

- -- removed for now, since it causes problems with

- -- extensionFromMimeType: see #2183.

- -- ,("svgz","image/svg+xml")

- ,("sw","chemical/x-swissprot")

- ,("swf","application/x-shockwave-flash")

- ,("swfl","application/x-shockwave-flash")

- ,("sxc","application/vnd.sun.xml.calc")

- ,("sxd","application/vnd.sun.xml.draw")

- ,("sxg","application/vnd.sun.xml.writer.global")

- ,("sxi","application/vnd.sun.xml.impress")

- ,("sxm","application/vnd.sun.xml.math")

- ,("sxw","application/vnd.sun.xml.writer")

- ,("t","application/x-troff")

- ,("tar","application/x-tar")

- ,("taz","application/x-gtar")

- ,("tcl","application/x-tcl")

- ,("tex","text/x-tex")

- ,("texi","application/x-texinfo")

- ,("texinfo","application/x-texinfo")

- ,("text","text/plain")

- ,("tgf","chemical/x-mdl-tgf")

- ,("tgz","application/x-gtar")

- ,("tif","image/tiff")

- ,("tiff","image/tiff")

- ,("tk","text/x-tcl")

- ,("tm","text/texmacs")

- ,("torrent","application/x-bittorrent")

- ,("tr","application/x-troff")

- ,("ts","text/texmacs")

- ,("tsp","application/dsptype")

- ,("tsv","text/tab-separated-values")

- ,("ttf","application/x-font-truetype")

- ,("txt","text/plain")

- ,("udeb","application/x-debian-package")

- ,("uls","text/iuls")

- ,("ustar","application/x-ustar")

- ,("val","chemical/x-ncbi-asn1-binary")

- ,("vcd","application/x-cdlink")

- ,("vcf","text/x-vcard")

- ,("vcs","text/x-vcalendar")

- ,("vmd","chemical/x-vmd")

- ,("vms","chemical/x-vamas-iso14976")

- ,("vrm","x-world/x-vrml")

- ,("vrml","model/vrml")

- ,("vs","text/plain")

- ,("vsd","application/vnd.visio")

- ,("vtt","text/vtt")

- ,("wad","application/x-doom")

- ,("wav","audio/x-wav")

- ,("wax","audio/x-ms-wax")

- ,("wbmp","image/vnd.wap.wbmp")

- ,("wbxml","application/vnd.wap.wbxml")

- ,("webm","video/webm")

- ,("wk","application/x-123")

- ,("wm","video/x-ms-wm")

- ,("wma","audio/x-ms-wma")

- ,("wmd","application/x-ms-wmd")

- ,("wmf","image/x-wmf")

- ,("wml","text/vnd.wap.wml")

- ,("wmlc","application/vnd.wap.wmlc")

- ,("wmls","text/vnd.wap.wmlscript")

- ,("wmlsc","application/vnd.wap.wmlscriptc")

- ,("wmv","video/x-ms-wmv")

- ,("wmx","video/x-ms-wmx")

- ,("wmz","application/x-ms-wmz")

- ,("woff","application/font-woff")

- ,("woff2","font/woff2")

- ,("wp5","application/wordperfect5.1")

- ,("wpd","application/wordperfect")

- ,("wrl","model/vrml")

- ,("wsc","text/scriptlet")

- ,("wvx","video/x-ms-wvx")

- ,("wz","application/x-wingz")

- ,("xbm","image/x-xbitmap")

- ,("xcf","application/x-xcf")

- ,("xht","application/xhtml+xml")

- ,("xhtml","application/xhtml+xml")

- ,("xlb","application/vnd.ms-excel")

- ,("xls","application/vnd.ms-excel")

- ,("xlt","application/vnd.ms-excel")

- ,("xml","application/xml")

- ,("xpi","application/x-xpinstall")

- ,("xpm","image/x-xpixmap")

- ,("xsl","application/xml")

- ,("xtel","chemical/x-xtel")

- ,("xul","application/vnd.mozilla.xul+xml")

- ,("xwd","image/x-xwindowdump")

- ,("xyz","chemical/x-xyz")

- ,("zip","application/zip")

- ,("zmt","chemical/x-mopac-input")

- ]

-

-{-# LANGUAGE GeneralizedNewtypeDeriving, DeriveDataTypeable #-}

-{-

-Copyright (C) 2014 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.MediaBag

- Copyright : Copyright (C) 2014 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Definition of a MediaBag object to hold binary resources, and an

-interface for interacting with it.

--}

-module Text.Pandoc.MediaBag (

- MediaBag,

- lookupMedia,

- insertMedia,

- mediaDirectory,

- extractMediaBag

- ) where

-import System.FilePath

-import qualified System.FilePath.Posix as Posix

-import System.Directory (createDirectoryIfMissing)

-import qualified Data.Map as M

-import qualified Data.ByteString.Lazy as BL

-import Control.Monad (when)

-import Control.Monad.Trans (MonadIO(..))

-import Text.Pandoc.MIME (MimeType, getMimeTypeDef)

-import qualified Text.Pandoc.UTF8 as UTF8

-import Data.Maybe (fromMaybe)

-import System.IO (stderr)

-import Data.Data (Data)

-import Data.Typeable (Typeable)

-

--- | A container for a collection of binary resources, with names and

--- mime types. Note that a 'MediaBag' is a Monoid, so 'mempty'

--- can be used for an empty 'MediaBag', and '<>' can be used to append

--- two 'MediaBag's.

-newtype MediaBag = MediaBag (M.Map [String] (MimeType, BL.ByteString))

- deriving (Monoid, Data, Typeable)

-

-instance Show MediaBag where

- show bag = "MediaBag " ++ show (mediaDirectory bag)

-

--- | Insert a media item into a 'MediaBag', replacing any existing

--- value with the same name.

-insertMedia :: FilePath -- ^ relative path and canonical name of resource

- -> Maybe MimeType -- ^ mime type (Nothing = determine from extension)

- -> BL.ByteString -- ^ contents of resource

- -> MediaBag

- -> MediaBag

-insertMedia fp mbMime contents (MediaBag mediamap) =

- MediaBag (M.insert (splitDirectories fp) (mime, contents) mediamap)

- where mime = fromMaybe fallback mbMime

- fallback = case takeExtension fp of

- ".gz" -> getMimeTypeDef $ dropExtension fp

- _ -> getMimeTypeDef fp

-

--- | Lookup a media item in a 'MediaBag', returning mime type and contents.

-lookupMedia :: FilePath

- -> MediaBag

- -> Maybe (MimeType, BL.ByteString)

-lookupMedia fp (MediaBag mediamap) = M.lookup (splitDirectories fp) mediamap

-

--- | Get a list of the file paths stored in a 'MediaBag', with

--- their corresponding mime types and the lengths in bytes of the contents.

-mediaDirectory :: MediaBag -> [(String, MimeType, Int)]

-mediaDirectory (MediaBag mediamap) =

- M.foldWithKey (\fp (mime,contents) ->

- (((Posix.joinPath fp), mime, fromIntegral $ BL.length contents):)) [] mediamap

-

--- | Extract contents of MediaBag to a given directory. Print informational

--- messages if 'verbose' is true.

--- TODO: eventually we may want to put this into PandocMonad

--- In PandocPure, it could write to the fake file system...

-extractMediaBag :: MonadIO m

- => Bool

- -> FilePath

- -> MediaBag

- -> m ()

-extractMediaBag verbose dir (MediaBag mediamap) = liftIO $ do

- sequence_ $ M.foldWithKey

- (\fp (_ ,contents) ->

- ((writeMedia verbose dir (Posix.joinPath fp, contents)):)) [] mediamap

-

-writeMedia :: Bool -> FilePath -> (FilePath, BL.ByteString) -> IO ()

-writeMedia verbose dir (subpath, bs) = do

- -- we join and split to convert a/b/c to a\b\c on Windows;

- -- in zip containers all paths use /

- let fullpath = dir </> normalise subpath

- createDirectoryIfMissing True $ takeDirectory fullpath

- when verbose $ UTF8.hPutStrLn stderr $ "pandoc: extracting " ++ fullpath

- BL.writeFile fullpath bs

-

-

-{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}

-{-

-Copyright (C) 2012-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.Options

- Copyright : Copyright (C) 2012-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Data structures and functions for representing parser and writer

-options.

--}

-module Text.Pandoc.Options ( module Text.Pandoc.Extensions

- , ReaderOptions(..)

- , HTMLMathMethod (..)

- , CiteMethod (..)

- , ObfuscationMethod (..)

- , HTMLSlideVariant (..)

- , EPUBVersion (..)

- , WrapOption (..)

- , TopLevelDivision (..)

- , WriterOptions (..)

- , TrackChanges (..)

- , ReferenceLocation (..)

- , def

- , isEnabled

- ) where

-import Text.Pandoc.Extensions

-import Data.Default

-import Text.Pandoc.Highlighting (Style, pygments)

-import Data.Data (Data)

-import Data.Typeable (Typeable)

-import GHC.Generics (Generic)

-

-data ReaderOptions = ReaderOptions{

- readerExtensions :: Extensions -- ^ Syntax extensions

- , readerStandalone :: Bool -- ^ Standalone document with header

- , readerColumns :: Int -- ^ Number of columns in terminal

- , readerTabStop :: Int -- ^ Tab stop

- , readerApplyMacros :: Bool -- ^ Apply macros to TeX math

- , readerIndentedCodeClasses :: [String] -- ^ Default classes for

- -- indented code blocks

- , readerDefaultImageExtension :: String -- ^ Default extension for images

- , readerTrackChanges :: TrackChanges

-} deriving (Show, Read, Data, Typeable, Generic)

-

-instance Default ReaderOptions

- where def = ReaderOptions{

- readerExtensions = emptyExtensions

- , readerStandalone = False

- , readerColumns = 80

- , readerTabStop = 4

- , readerApplyMacros = True

- , readerIndentedCodeClasses = []

- , readerDefaultImageExtension = ""

- , readerTrackChanges = AcceptChanges

- }

-

---

--- Writer options

---

-

-data EPUBVersion = EPUB2 | EPUB3 deriving (Eq, Show, Read, Data, Typeable, Generic)

-

-data HTMLMathMethod = PlainMath

- | LaTeXMathML (Maybe String) -- url of LaTeXMathML.js

- | JsMath (Maybe String) -- url of jsMath load script

- | GladTeX

- | WebTeX String -- url of TeX->image script.

- | MathML

- | MathJax String -- url of MathJax.js

- | KaTeX String String -- url of stylesheet and katex.js

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

-data CiteMethod = Citeproc -- use citeproc to render them

- | Natbib -- output natbib cite commands

- | Biblatex -- output biblatex cite commands

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

--- | Methods for obfuscating email addresses in HTML.

-data ObfuscationMethod = NoObfuscation

- | ReferenceObfuscation

- | JavascriptObfuscation

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

--- | Varieties of HTML slide shows.

-data HTMLSlideVariant = S5Slides

- | SlidySlides

- | SlideousSlides

- | DZSlides

- | RevealJsSlides

- | NoSlides

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

--- | Options for accepting or rejecting MS Word track-changes.

-data TrackChanges = AcceptChanges

- | RejectChanges

- | AllChanges

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

--- | Options for wrapping text in the output.

-data WrapOption = WrapAuto -- ^ Automatically wrap to width

- | WrapNone -- ^ No non-semantic newlines

- | WrapPreserve -- ^ Preserve wrapping of input source

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

--- | Options defining the type of top-level headers.

-data TopLevelDivision = TopLevelPart -- ^ Top-level headers become parts

- | TopLevelChapter -- ^ Top-level headers become chapters

- | TopLevelSection -- ^ Top-level headers become sections

- | TopLevelDefault -- ^ Top-level type is determined via

- -- heuristics

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

--- | Locations for footnotes and references in markdown output

-data ReferenceLocation = EndOfBlock -- ^ End of block

- | EndOfSection -- ^ prior to next section header (or end of document)

- | EndOfDocument -- ^ at end of document

- deriving (Show, Read, Eq, Data, Typeable, Generic)

-

--- | Options for writers

-data WriterOptions = WriterOptions

- { writerTemplate :: Maybe String -- ^ Template to use

- , writerVariables :: [(String, String)] -- ^ Variables to set in template

- , writerTabStop :: Int -- ^ Tabstop for conversion btw spaces and tabs

- , writerTableOfContents :: Bool -- ^ Include table of contents

- , writerIncremental :: Bool -- ^ True if lists should be incremental

- , writerHTMLMathMethod :: HTMLMathMethod -- ^ How to print math in HTML

- , writerNumberSections :: Bool -- ^ Number sections in LaTeX

- , writerNumberOffset :: [Int] -- ^ Starting number for section, subsection, ...

- , writerSectionDivs :: Bool -- ^ Put sections in div tags in HTML

- , writerExtensions :: Extensions -- ^ Markdown extensions that can be used

- , writerReferenceLinks :: Bool -- ^ Use reference links in writing markdown, rst

- , writerDpi :: Int -- ^ Dpi for pixel to/from inch/cm conversions

- , writerWrapText :: WrapOption -- ^ Option for wrapping text

- , writerColumns :: Int -- ^ Characters in a line (for text wrapping)

- , writerEmailObfuscation :: ObfuscationMethod -- ^ How to obfuscate emails

- , writerIdentifierPrefix :: String -- ^ Prefix for section & note ids in HTML

- -- and for footnote marks in markdown

- , writerSourceURL :: Maybe String -- ^ Absolute URL + directory of 1st source file

- , writerUserDataDir :: Maybe FilePath -- ^ Path of user data directory

- , writerCiteMethod :: CiteMethod -- ^ How to print cites

- , writerHtmlQTags :: Bool -- ^ Use @<q>@ tags for quotes in HTML

- , writerSlideLevel :: Maybe Int -- ^ Force header level of slides

- , writerTopLevelDivision :: TopLevelDivision -- ^ Type of top-level divisions

- , writerListings :: Bool -- ^ Use listings package for code

- , writerHighlightStyle :: Maybe Style -- ^ Style to use for highlighting

- -- (Nothing = no highlighting)

- , writerSetextHeaders :: Bool -- ^ Use setext headers for levels 1-2 in markdown

- , writerEpubMetadata :: Maybe String -- ^ Metadata to include in EPUB

- , writerEpubStylesheet :: Maybe String -- ^ EPUB stylesheet specified at command line

- , writerEpubFonts :: [FilePath] -- ^ Paths to fonts to embed

- , writerEpubChapterLevel :: Int -- ^ Header level for chapters (separate files)

- , writerTOCDepth :: Int -- ^ Number of levels to include in TOC

- , writerReferenceDoc :: Maybe FilePath -- ^ Path to reference document if specified

- , writerLaTeXArgs :: [String] -- ^ Flags to pass to latex-engine

- , writerReferenceLocation :: ReferenceLocation -- ^ Location of footnotes and references for writing markdown

- } deriving (Show, Data, Typeable, Generic)

-

-instance Default WriterOptions where

- def = WriterOptions { writerTemplate = Nothing

- , writerVariables = []

- , writerTabStop = 4

- , writerTableOfContents = False

- , writerIncremental = False

- , writerHTMLMathMethod = PlainMath

- , writerNumberSections = False

- , writerNumberOffset = [0,0,0,0,0,0]

- , writerSectionDivs = False

- , writerExtensions = emptyExtensions

- , writerReferenceLinks = False

- , writerDpi = 96

- , writerWrapText = WrapAuto

- , writerColumns = 72

- , writerEmailObfuscation = NoObfuscation

- , writerIdentifierPrefix = ""

- , writerSourceURL = Nothing

- , writerUserDataDir = Nothing

- , writerCiteMethod = Citeproc

- , writerHtmlQTags = False

- , writerSlideLevel = Nothing

- , writerTopLevelDivision = TopLevelDefault

- , writerListings = False

- , writerHighlightStyle = Just pygments

- , writerSetextHeaders = True

- , writerEpubMetadata = Nothing

- , writerEpubStylesheet = Nothing

- , writerEpubFonts = []

- , writerEpubChapterLevel = 1

- , writerTOCDepth = 3

- , writerReferenceDoc = Nothing

- , writerLaTeXArgs = []

- , writerReferenceLocation = EndOfDocument

- }

-

--- | Returns True if the given extension is enabled.

-isEnabled :: Extension -> WriterOptions -> Bool

-isEnabled ext opts = ext `extensionEnabled` (writerExtensions opts)

-{-# LANGUAGE OverloadedStrings, CPP, ScopedTypeVariables #-}

-{-

-Copyright (C) 2012-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.PDF

- Copyright : Copyright (C) 2012-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-Conversion of LaTeX documents to PDF.

--}

-module Text.Pandoc.PDF ( makePDF ) where

-

-import Data.ByteString.Lazy (ByteString)

-import qualified Data.ByteString.Lazy as B

-import qualified Data.ByteString.Lazy.Char8 as BC

-import qualified Data.ByteString as BS

-import Data.Monoid ((<>))

-import System.Exit (ExitCode (..))

-import System.FilePath

-import System.IO (stdout)

-import System.IO.Temp (withTempFile)

-import System.Directory

-import Data.Digest.Pure.SHA (showDigest, sha1)

-import System.Environment

-import Control.Monad (unless, when, (<=<))

-import qualified Control.Exception as E

-import Data.List (isInfixOf)

-import Data.Maybe (fromMaybe)

-import qualified Text.Pandoc.UTF8 as UTF8

-import Text.Pandoc.Definition

-import Text.Pandoc.MediaBag

-import Text.Pandoc.Walk (walkM)

-import Text.Pandoc.Shared (warn, withTempDir, inDirectory, stringify)

-import Text.Pandoc.Writers.Shared (getField, metaToJSON)

-import Text.Pandoc.Options (WriterOptions(..), HTMLMathMethod(..))

-import Text.Pandoc.Logging (Verbosity(..))

-import Text.Pandoc.MIME (extensionFromMimeType, getMimeType)

-import Text.Pandoc.Process (pipeProcess)

-import Control.Monad.Trans (MonadIO(..))

-import qualified Data.ByteString.Lazy as BL

-import qualified Codec.Picture as JP

-#ifdef _WINDOWS

-import Data.List (intercalate)

-#endif

-import Text.Pandoc.Class (PandocIO, runIOorExplode, fetchItem, setMediaBag, runIO)

-

-#ifdef _WINDOWS

-changePathSeparators :: FilePath -> FilePath

-changePathSeparators = intercalate "/" . splitDirectories

-#endif

-

-makePDF :: MonadIO m

- => String -- ^ pdf creator (pdflatex, lualatex,

- -- xelatex, context, wkhtmltopdf)

- -> (WriterOptions -> Pandoc -> PandocIO String) -- ^ writer

- -> WriterOptions -- ^ options

- -> Verbosity -- ^ verbosity level

- -> MediaBag -- ^ media

- -> Pandoc -- ^ document

- -> m (Either ByteString ByteString)

-makePDF "wkhtmltopdf" writer opts verbosity _ doc@(Pandoc meta _) = liftIO $ do

- let mathArgs = case writerHTMLMathMethod opts of

- -- with MathJax, wait til all math is rendered:

- MathJax _ -> ["--run-script", "MathJax.Hub.Register.StartupHook('End Typeset', function() { window.status = 'mathjax_loaded' });",

- "--window-status", "mathjax_loaded"]

- _ -> []

- meta' <- metaToJSON opts (return . stringify) (return . stringify) meta

- let toArgs (f, mbd) = maybe [] (\d -> ['-':'-':f, d]) mbd

- let args = mathArgs ++

- concatMap toArgs

- [("page-size", getField "papersize" meta')

- ,("title", getField "title" meta')

- ,("margin-bottom", fromMaybe (Just "1.2in")

- (getField "margin-bottom" meta'))

- ,("margin-top", fromMaybe (Just "1.25in")

- (getField "margin-top" meta'))

- ,("margin-right", fromMaybe (Just "1.25in")

- (getField "margin-right" meta'))

- ,("margin-left", fromMaybe (Just "1.25in")

- (getField "margin-left" meta'))

- ]

- source <- runIOorExplode $ writer opts doc

- html2pdf verbosity args source

-makePDF program writer opts verbosity mediabag doc =

- liftIO $ withTempDir "tex2pdf." $ \tmpdir -> do

- doc' <- handleImages opts mediabag tmpdir doc

- source <- runIOorExplode $ writer opts doc'

- let args = writerLaTeXArgs opts

- case takeBaseName program of

- "context" -> context2pdf verbosity tmpdir source

- prog | prog `elem` ["pdflatex", "lualatex", "xelatex"]

- -> tex2pdf' verbosity args tmpdir program source

- _ -> return $ Left $ UTF8.fromStringLazy $ "Unknown program " ++ program

-

-handleImages :: WriterOptions

- -> MediaBag

- -> FilePath -- ^ temp dir to store images

- -> Pandoc -- ^ document

- -> IO Pandoc

-handleImages opts mediabag tmpdir =

- walkM (convertImages tmpdir) <=< walkM (handleImage' opts mediabag tmpdir)

-

-handleImage' :: WriterOptions

- -> MediaBag

- -> FilePath

- -> Inline

- -> IO Inline

-handleImage' opts mediabag tmpdir (Image attr ils (src,tit)) = do

- exists <- doesFileExist src

- if exists

- then return $ Image attr ils (src,tit)

- else do

- res <- runIO $ do

- setMediaBag mediabag

- fetchItem (writerSourceURL opts) src

- case res of

- Right (contents, Just mime) -> do

- let ext = fromMaybe (takeExtension src) $

- extensionFromMimeType mime

- let basename = showDigest $ sha1 $ BL.fromChunks [contents]

- let fname = tmpdir </> basename <.> ext

- BS.writeFile fname contents

- return $ Image attr ils (fname,tit)

- _ -> do

- warn $ "Could not find image `" ++ src ++ "', skipping..."

- -- return alt text

- return $ Emph ils

-handleImage' _ _ _ x = return x

-

-convertImages :: FilePath -> Inline -> IO Inline

-convertImages tmpdir (Image attr ils (src, tit)) = do

- img <- convertImage tmpdir src

- newPath <-

- case img of

- Left e -> src <$ warn e

- Right fp -> return fp

- return (Image attr ils (newPath, tit))

-convertImages _ x = return x

-

--- Convert formats which do not work well in pdf to png

-convertImage :: FilePath -> FilePath -> IO (Either String FilePath)

-convertImage tmpdir fname =

- case mime of

- Just "image/png" -> doNothing

- Just "image/jpeg" -> doNothing

- Just "application/pdf" -> doNothing

- _ -> JP.readImage fname >>= \res ->

- case res of

- Left _ -> return $ Left $ "Unable to convert `" ++

- fname ++ "' for use with pdflatex."

- Right img ->

- E.catch (Right fileOut <$ JP.savePngImage fileOut img) $

- \(e :: E.SomeException) -> return (Left (show e))

- where

- fileOut = replaceDirectory (replaceExtension fname ".png") tmpdir

- mime = getMimeType fname

- doNothing = return (Right fname)

-

-tex2pdf' :: Verbosity -- ^ Verbosity level

- -> [String] -- ^ Arguments to the latex-engine

- -> FilePath -- ^ temp directory for output

- -> String -- ^ tex program

- -> String -- ^ tex source

- -> IO (Either ByteString ByteString)

-tex2pdf' verbosity args tmpDir program source = do

- let numruns = if "\\tableofcontents" `isInfixOf` source

- then 3 -- to get page numbers

- else 2 -- 1 run won't give you PDF bookmarks

- (exit, log', mbPdf) <- runTeXProgram verbosity program args 1 numruns tmpDir source

- case (exit, mbPdf) of

- (ExitFailure _, _) -> do

- let logmsg = extractMsg log'

- let extramsg =

- case logmsg of

- x | "! Package inputenc Error" `BC.isPrefixOf` x

- && program /= "xelatex"

- -> "\nTry running pandoc with --latex-engine=xelatex."

- _ -> ""

- return $ Left $ logmsg <> extramsg

- (ExitSuccess, Nothing) -> return $ Left ""

- (ExitSuccess, Just pdf) -> return $ Right pdf

-

--- parsing output

-

-extractMsg :: ByteString -> ByteString

-extractMsg log' = do

- let msg' = dropWhile (not . ("!" `BC.isPrefixOf`)) $ BC.lines log'

- let (msg'',rest) = break ("l." `BC.isPrefixOf`) msg'

- let lineno = take 1 rest

- if null msg'

- then log'

- else BC.unlines (msg'' ++ lineno)

-

-extractConTeXtMsg :: ByteString -> ByteString

-extractConTeXtMsg log' = do

- let msg' = take 1 $

- dropWhile (not . ("tex error" `BC.isPrefixOf`)) $ BC.lines log'

- if null msg'

- then log'

- else BC.unlines msg'

-

--- running tex programs

-

--- Run a TeX program on an input bytestring and return (exit code,

--- contents of stdout, contents of produced PDF if any). Rerun

--- a fixed number of times to resolve references.

-runTeXProgram :: Verbosity -> String -> [String] -> Int -> Int -> FilePath

- -> String -> IO (ExitCode, ByteString, Maybe ByteString)

-runTeXProgram verbosity program args runNumber numRuns tmpDir source = do

- let file = tmpDir </> "input.tex"

- exists <- doesFileExist file

- unless exists $ UTF8.writeFile file source

-#ifdef _WINDOWS

- -- note: we want / even on Windows, for TexLive

- let tmpDir' = changePathSeparators tmpDir

- let file' = changePathSeparators file

-#else

- let tmpDir' = tmpDir

- let file' = file

-#endif

- let programArgs = ["-halt-on-error", "-interaction", "nonstopmode",

- "-output-directory", tmpDir'] ++ args ++ [file']

- env' <- getEnvironment

- let sep = [searchPathSeparator]

- let texinputs = maybe (tmpDir' ++ sep) ((tmpDir' ++ sep) ++)

- $ lookup "TEXINPUTS" env'

- let env'' = ("TEXINPUTS", texinputs) :

- [(k,v) | (k,v) <- env', k /= "TEXINPUTS"]

- when (verbosity >= INFO && runNumber == 1) $ do

- putStrLn "[makePDF] temp dir:"

- putStrLn tmpDir'

- putStrLn "[makePDF] Command line:"

- putStrLn $ program ++ " " ++ unwords (map show programArgs)

- putStr "\n"

- putStrLn "[makePDF] Environment:"

- mapM_ print env''

- putStr "\n"

- putStrLn $ "[makePDF] Contents of " ++ file' ++ ":"

- B.readFile file' >>= B.putStr

- putStr "\n"

- (exit, out) <- pipeProcess (Just env'') program programArgs BL.empty

- when (verbosity >= INFO) $ do

- putStrLn $ "[makePDF] Run #" ++ show runNumber

- B.hPutStr stdout out

- putStr "\n"

- if runNumber <= numRuns

- then runTeXProgram verbosity program args (runNumber + 1) numRuns tmpDir source

- else do

- let pdfFile = replaceDirectory (replaceExtension file ".pdf") tmpDir

- pdfExists <- doesFileExist pdfFile

- pdf <- if pdfExists

- -- We read PDF as a strict bytestring to make sure that the

- -- temp directory is removed on Windows.

- -- See https://github.com/jgm/pandoc/issues/1192.

- then (Just . B.fromChunks . (:[])) `fmap` BS.readFile pdfFile

- else return Nothing

- return (exit, out, pdf)

-

-html2pdf :: Verbosity -- ^ Verbosity level

- -> [String] -- ^ Args to wkhtmltopdf

- -> String -- ^ HTML5 source

- -> IO (Either ByteString ByteString)

-html2pdf verbosity args source = do

- file <- withTempFile "." "html2pdf.html" $ \fp _ -> return fp

- pdfFile <- withTempFile "." "html2pdf.pdf" $ \fp _ -> return fp

- UTF8.writeFile file source

- let programArgs = args ++ [file, pdfFile]

- env' <- getEnvironment

- when (verbosity >= INFO) $ do

- putStrLn "[makePDF] Command line:"

- putStrLn $ "wkhtmltopdf" ++ " " ++ unwords (map show programArgs)

- putStr "\n"

- putStrLn "[makePDF] Environment:"

- mapM_ print env'

- putStr "\n"

- putStrLn $ "[makePDF] Contents of " ++ file ++ ":"

- B.readFile file >>= B.putStr

- putStr "\n"

- (exit, out) <- pipeProcess (Just env') "wkhtmltopdf" programArgs BL.empty

- removeFile file

- when (verbosity >= INFO) $ do

- B.hPutStr stdout out

- putStr "\n"

- pdfExists <- doesFileExist pdfFile

- mbPdf <- if pdfExists

- -- We read PDF as a strict bytestring to make sure that the

- -- temp directory is removed on Windows.

- -- See https://github.com/jgm/pandoc/issues/1192.

- then do

- res <- (Just . B.fromChunks . (:[])) `fmap` BS.readFile pdfFile

- removeFile pdfFile

- return res

- else return Nothing

- return $ case (exit, mbPdf) of

- (ExitFailure _, _) -> Left out

- (ExitSuccess, Nothing) -> Left ""

- (ExitSuccess, Just pdf) -> Right pdf

-

-context2pdf :: Verbosity -- ^ Verbosity level

- -> FilePath -- ^ temp directory for output

- -> String -- ^ ConTeXt source

- -> IO (Either ByteString ByteString)

-context2pdf verbosity tmpDir source = inDirectory tmpDir $ do

- let file = "input.tex"

- UTF8.writeFile file source

-#ifdef _WINDOWS

- -- note: we want / even on Windows, for TexLive

- let tmpDir' = changePathSeparators tmpDir

-#else

- let tmpDir' = tmpDir

-#endif

- let programArgs = "--batchmode" : [file]

- env' <- getEnvironment

- let sep = [searchPathSeparator]

- let texinputs = maybe (".." ++ sep) ((".." ++ sep) ++)

- $ lookup "TEXINPUTS" env'

- let env'' = ("TEXINPUTS", texinputs) :

- [(k,v) | (k,v) <- env', k /= "TEXINPUTS"]

- when (verbosity >= INFO) $ do

- putStrLn "[makePDF] temp dir:"

- putStrLn tmpDir'

- putStrLn "[makePDF] Command line:"

- putStrLn $ "context" ++ " " ++ unwords (map show programArgs)

- putStr "\n"

- putStrLn "[makePDF] Environment:"

- mapM_ print env''

- putStr "\n"

- putStrLn $ "[makePDF] Contents of " ++ file ++ ":"

- B.readFile file >>= B.putStr

- putStr "\n"

- (exit, out) <- pipeProcess (Just env'') "context" programArgs BL.empty

- when (verbosity >= INFO) $ do

- B.hPutStr stdout out

- putStr "\n"

- let pdfFile = replaceExtension file ".pdf"

- pdfExists <- doesFileExist pdfFile

- mbPdf <- if pdfExists

- -- We read PDF as a strict bytestring to make sure that the

- -- temp directory is removed on Windows.

- -- See https://github.com/jgm/pandoc/issues/1192.

- then (Just . B.fromChunks . (:[])) `fmap` BS.readFile pdfFile

- else return Nothing

- case (exit, mbPdf) of

- (ExitFailure _, _) -> do

- let logmsg = extractConTeXtMsg out

- return $ Left logmsg

- (ExitSuccess, Nothing) -> return $ Left ""

- (ExitSuccess, Just pdf) -> return $ Right pdf

-

-{-# LANGUAGE

- FlexibleContexts

-, GeneralizedNewtypeDeriving

-, TypeSynonymInstances

-, MultiParamTypeClasses

-, FlexibleInstances

-, IncoherentInstances #-}

-

-{-

-Copyright (C) 2006-2016 John MacFarlane <jgm@berkeley.edu>

-

-This program is free software; you can redistribute it and/or modify

-it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2 of the License, or

-(at your option) any later version.

-

-This program is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU General Public License for more details.

-

-You should have received a copy of the GNU General Public License

-along with this program; if not, write to the Free Software

-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

--}

-

-{- |

- Module : Text.Pandoc.Parsing

- Copyright : Copyright (C) 2006-2016 John MacFarlane

- License : GNU GPL, version 2 or above

-

- Maintainer : John MacFarlane <jgm@berkeley.edu>

- Stability : alpha

- Portability : portable

-

-A utility library with parsers used in pandoc readers.

--}

-module Text.Pandoc.Parsing ( anyLine,

- many1Till,

- notFollowedBy',

- oneOfStrings,

- oneOfStringsCI,

- spaceChar,

- nonspaceChar,

- skipSpaces,

- blankline,

- blanklines,

- enclosed,

- stringAnyCase,

- parseFromString,

- lineClump,

- charsInBalanced,

- romanNumeral,

- emailAddress,

- uri,

- mathInline,

- mathDisplay,

- withHorizDisplacement,

- withRaw,

- escaped,

- characterReference,

- anyOrderedListMarker,

- orderedListMarker,

- charRef,

- lineBlockLines,

- tableWith,

- widthsFromIndices,

- gridTableWith,

- readWith,

- readWithM,

- testStringWith,

- guardEnabled,

- guardDisabled,

- updateLastStrPos,

- notAfterString,

- logMessage,

- reportLogMessages,

- ParserState (..),

- HasReaderOptions (..),

- HasHeaderMap (..),

- HasIdentifierList (..),

- HasMacros (..),

- HasLogMessages (..),

- HasLastStrPosition (..),

- defaultParserState,

- HeaderType (..),

- ParserContext (..),

- QuoteContext (..),

- HasQuoteContext (..),

- NoteTable,

- NoteTable',

- KeyTable,

- SubstTable,

- Key (..),

- toKey,

- registerHeader,

- smartPunctuation,

- singleQuoteStart,

- singleQuoteEnd,

- doubleQuoteStart,

- doubleQuoteEnd,

- ellipses,

- apostrophe,

- dash,

- nested,

- citeKey,

- macro,

- applyMacros',

- Parser,

- ParserT,

- F(..),

- runF,

- askF,

- asksF,

- token,

- (<+?>),

- extractIdClass,

- insertIncludedFile,

- -- * Re-exports from Text.Pandoc.Parsec

- Stream,

- runParser,

- runParserT,

- parse,

- anyToken,

- getInput,

- setInput,

- unexpected,

- char,

- letter,

- digit,

- alphaNum,

- skipMany,

- skipMany1,

- spaces,

- space,

- anyChar,

- satisfy,

- newline,

- string,

- count,

- eof,

- noneOf,

- oneOf,

- lookAhead,

- notFollowedBy,

- many,

- many1,

- manyTill,

- (<|>),

- (<?>),

- choice,

- try,

- sepBy,

- sepBy1,

- sepEndBy,

- sepEndBy1,

- endBy,

- endBy1,

- option,

- optional,

- optionMaybe,

- getState,

- setState,

- updateState,

- SourcePos,

- getPosition,

- setPosition,

- sourceColumn,

- sourceLine,

- setSourceColumn,

- setSourceLine,

- newPos

- )

-where

-

-import Text.Pandoc.Definition

-import Text.Pandoc.Options

-import Text.Pandoc.Builder (Blocks, Inlines, rawBlock, HasMeta(..))

-import qualified Text.Pandoc.Builder as B

-import Text.Pandoc.XML (fromEntities)

-import qualified Text.Pandoc.UTF8 as UTF8 (putStrLn)

-import Text.Parsec hiding (token)

-import Text.Parsec.Pos (newPos)

-import Data.Char ( toLower, toUpper, ord, chr, isAscii, isAlphaNum,

- isHexDigit, isSpace, isPunctuation )

-import Data.List ( intercalate, transpose, isSuffixOf )

-import Text.Pandoc.Shared

-import qualified Data.Map as M

-import Text.TeXMath.Readers.TeX.Macros (applyMacros, Macro,

- parseMacroDefinitions)

-import Text.HTML.TagSoup.Entity ( lookupEntity )

-import Text.Pandoc.Asciify (toAsciiChar)

-import Data.Monoid ((<>))

-import Text.Pandoc.Class (PandocMonad, readFileFromDirs, report)

-import Text.Pandoc.Logging

-import Data.Default

-import qualified Data.Set as Set

-import Control.Monad.Reader

-import Control.Monad.Identity

-import Data.Maybe (catMaybes)

-

-import Text.Pandoc.Error

-import Control.Monad.Except

-

-type Parser t s = Parsec t s

-

-type ParserT = ParsecT

-

-newtype F a = F { unF :: Reader ParserState a } deriving (Monad, Applicative, Functor)

-

-runF :: F a -> ParserState -> a

-runF = runReader . unF

-

-askF :: F ParserState

-askF = F ask

-

-asksF :: (ParserState -> a) -> F a

-asksF f = F $ asks f

-

-instance Monoid a => Monoid (F a) where

- mempty = return mempty

- mappend = liftM2 mappend

- mconcat = liftM mconcat . sequence

-