/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvw x y z { | } ~  NoneHIf you use two different KeyGens to work with the same map, you deserve  what you get.   None9DAST to hold attribute parsing structure. This is necessary because  attoparsec doesn',t support parsers running in another monad. DHeistT is the monad transformer used for splice processing. HeistT J intentionally does not expose any of its functionality via MonadState or M MonadReader functions. We define passthrough instances for the most common K types of monads. These instances allow the user to use HeistT in a monad  stack without needing calls to . n5 is the runtime monad (the parameter to HeistState). m, is the monad being run now. In this case, "now" is a variable  concept. The type  HeistT n n means that "now" is runtime. The type   HeistT n IO means that "now" is IO!, and more importantly it is NOT . runtime. In Heist, the rule of thumb is that IO means load time and n  means runtime. JHolds all the state information needed for template processing. You will  build a  HeistState using  initHeist and any of Heist's HeistState ->  HeistState "filter"( functions. Then you use the resulting  HeistState  in calls to renderTemplate. m is the runtime monad ,A mapping of splice names to splice actions )A mapping of template names to templates ,A mapping of splice names to splice actions )A mapping of template names to templates >, _compiledTemplateMap :: HashMap TPath (m Builder, MIMEType) #A flag to control splice recursion 4The path to the template currently being processed. BA counter keeping track of the current recursion depth to prevent  infinite loops. 5The doctypes encountered during template processing. %The full path to the current template's file on disk. 5A key generator used to produce new unique Promises. Flag indicating whether we'"re in preprocessing mode. During F preprocessing, errors should stop execution and be reported. During  template rendering, it'1s better to skip the errors and render the page. EThis is needed because compiled templates are generated with a bunch A of calls to renderFragment rather than a single call to render. JType alias for attribute splices. The function parameter is the value of F the bound attribute splice. The return value is a list of attribute  key/Fvalue pairs that get substituted in the place of the bound attribute. AOpaque type representing pieces of output from compiled splices. -runtime action used only for its side-effect output computed at run time output known at load time )Monad used for runtime splice execution. @Designates whether a document should be treated as XML or HTML. +Holds data about templates read from disk. CReversed list of directories. This holds the path to the template  currently being processed. <MIME Type. The type alias is here to make the API clearer. A  5 is a forest of XML nodes. Here we deviate from the "single  root node"8 constraint of well-formed XML because we want to allow J templates to contain document fragments that may not have a single root. =Gets the names of all the templates defined in a HeistState. =Gets the names of all the templates defined in a HeistState. GGets the names of all the interpreted splices defined in a HeistState. DGets the names of all the compiled splices defined in a HeistState. HThe Typeable instance is here so Heist can be dynamically executed with  Hint. EEvaluates a template monad as a computation in the underlying monad.  Helper for MonadError instance. Helper for MonadCont instance. HThe Typeable instance is here so Heist can be dynamically executed with  Hint. )Gets the node currently being processed.   <speech author="Shakespeare"> ! To sleep, perchance to dream.  </speech> When you call  getParamNode inside the code for the speech splice, it  returns the Node for the speech tag and its children. getParamNode >>=  childNodes returns a list containing one TextNode containing part of  Hamlet' s speech. liftM (getAttribute "author") getParamNode would  return Just  Shakespeare. HeistT's . HeistT's . HeistT's . HeistT's . HeistT's . GRestores the HeistState. This function is almost like putHS except it J preserves the current doctypes. You should use this function instead of  putHSE to restore an old state. This was needed because doctypes needs to  be in a  global scope! as opposed to the template call  local scope of @ state items such as recursionDepth, curContext, and spliceMap. BAbstracts the common pattern of running a HeistT computation with  a modified heist state. Modifies the recursion depth. MonadCont passthrough instance  MonadError passthrough instance !MonadReader passthrough instance  MonadState passthrough instance MonadPlus passthrough instance !Alternative passthrough instance MonadFix passthrough instance MonadCatchIO instance MonadTrans instance MonadIO instance Monad instance Applicative instance Functor instance N = 2 NoneCConvenient type alias that will probably be used most of the time. :A monad providing convenient syntax for defining splices. FForces a splice to be added. If the key already exists, its value is  overwritten. HTries to add a splice, but if the key already exists, then it throws an L error message. This may be useful if name collisions are bad and you want  to crash when they occur. =Inserts into the map only if the key does not already exist. A  with nothing in it. !6Runs the SplicesM monad, generating a map of splices. "$Constructs an alist representation. #+Internal helper function for adding a map. $&Maps a function over all the splices. %*Applies an argument to a splice function. &Inserts a splice into the . 'DInserts a splice with a function combining new value and old value. ( Union of  with a combining function. )Infix operator for  flip applyS *+Maps a function over all the splice names. +GAdds a prefix to the tag names for a list of splices. If the existing M tag name is empty, then the new tag name is just the prefix. Otherwise the F new tag name is the prefix followed by the separator followed by the  existing name. ,+9 specialized to use a colon as separator in the style of  XML namespaces. AMonoid instance does a union of the two maps with the second map  overwriting any duplicates.  !"#$%&'()*+, !"#$%&'()*+, !"#$%&'()*+, !"#$%&'()*+,NoneType synonym for parsers. -HIf Heist is running in fail fast mode, then this function will throw an J exception with the second argument as the error message. Otherwise, the > first argument will be executed to represent silent failure. DThis behavior allows us to fail quickly if an error crops up during L load-time splice processing or degrade more gracefully if the error occurs * while a user request is being processed. Function for showing a TPath.  Sets the current template file. ,Parser for attribute variable substitution. HConverts a path into an array of the elements in reverse order. If the I path is absolute, we need to remove the leading slash so the split doesn't  leave ""# as the last element of the TPath. FIXME ".." currently doesn'-t work in paths, the solution is non-trivial IConverts a path into an array of the elements in reverse order using the 3 path separator of the local operating system. See  for more  details. GConverts a path into an array of the elements in reverse order using a  forward slash (/) as the path separator. See  for more  details. 0Convenience function for looking up a template. .Returns 8 if the given template can be found in the heist state. 4Does a single template lookup without cascading up. ISearches for a template by looking in the full path then backing up into = each of the parent directories until the template is found. /CMaps a splice generating function over a list and concatenates the K results. This function now has a more general type signature so it works I with both compiled and interpreted splices. The old type signature was  this:  mapSplices :: (Monad n)  => (a -> Splice n n)  -> [a]  -> Splice n n 0Gets the current context 1DGets the full path to the file holding the template currently being K processed. Returns Nothing if the template is not associated with a file 5 on disk or if there is no template being processed. <Loads a template with the specified path and filename. The % template is only loaded if it has a .tpl or .xtpl extension. HLoads a template at the specified path, choosing the appropriate parser G based on the file extension. The template is only loaded if it has a  ".tpl" or ".xtpl"4 extension. Returns an empty list if the extension  doesn' t match. )Reads an HTML or XML template from disk. 2"Reads an HTML template from disk. 3!Reads an XML template from disk. &Sets the templateMap in a HeistState. $Adds a template to the heist state. 40Binds a set of new splice declarations within a . !Mappends a doctype to the state. -./Splice generating function &List of items to generate splices for 1The result of all splices concatenated together. 01path of the template root ,full file path (includes the template root) 234splices to bind  start state -./01234-./01234None'5@Promises are used for referencing the results of future runtime 2 computations during load time splice processing. 69A compiled Splice is a HeistT computation that returns a DList  (Chunk m). IThe more interesting part of the type signature is what comes before the , return value. The first type parameter in  n IO is the runtime I monad. This reveals that the Chunks know about the runtime monad. The  second type parameter in  HeistT n IO is IO. This tells is that the I compiled splices themselves are run in the IO monad, which will usually H mean at load time. Compiled splices run at load time, and they return # computations that run at runtime. 7Runs the parameter node'.s children and returns the resulting compiled L chunks. By itself this function is a simple passthrough splice that makes I the spliced node disappear. In combination with locally bound splices, K this function makes it easier to pass the desired view into your splices. %Yields pure text known at load time. 8CYields a pure Builder known at load time. You should use this and  ;= as much as possible to maximize the parts of your page that ( can be compiled to static ByteStrings. 90Yields a runtime action that returns a builder. :IYields a runtime action that returns no value and is only needed for its  side effect. ;GA convenience wrapper around yieldPure for working with Text. Roughly  equivalent to I from Heist.Interpreted. <HConvenience wrapper around yieldRuntime allowing you to work with Text. =GReturns a computation that performs load-time splice processing on the  supplied list of nodes. :Runs a single splice and returns the builder computation. ?Runs a DocumentFile with the appropriate template context set. %Consolidate consecutive Pure Chunks. >EGiven a list of output chunks, consolidate turns consecutive runs of   Pure Html5 values into maximally-efficient pre-rendered strict   chunks. .Looks up a splice in the compiled splice map. ?FRuns a single node. If there is no splice referenced anywhere in the B subtree, then it is rendered as a pure chunk, otherwise it calls > compileNode to generate the appropriate runtime computation. Checks whether a node'4s subtree is static and can be rendered up front at  load time. 9Checks whether a string has any attribute substitutions. Given a   in the DOM tree, produces a "runtime splice" that will  generate html at runtime. @GPerforms splice processing on a list of attributes. This is useful in C situations where you need to stop recursion, but still run splice  processing on the node's attributes. AGPerforms splice processing on a list of attributes. This is useful in C situations where you need to stop recursion, but still run splice  processing on the node's attributes. B3Gets the result of a promised runtime computation. C.Adds a promise to the runtime splice context. DModifies a promise. ECreates an empty promise.  @Binds a compiled splice. This function should not be exported.  IBinds a list of compiled splices. This function should not be exported. FEAdds a list of compiled splices to the splice map. This function is J useful because it allows compiled splices to bind other compiled splices % during load-time splice processing. GJLooks up a compiled template and returns a runtime monad computation that  constructs a builder. H<Looks up a compiled template and returns a compiled splice. IHConverts a pure text splice function to a pure Builder splice function. JHConverts a pure Node splice function to a pure Builder splice function. KGConverts a pure Builder splice function into a monadic splice function  of a RuntimeSplice. LFRuns a splice, but first binds splices given by splice functions that  need some runtime data. MJLike withSplices, but evaluates the splice repeatedly for each element in  a list generated at runtime. N Similar to /. in interpreted mode. Gets a runtime list of M items and applies a compiled runtime splice function to each element of the  list. O/Saves the results of a runtme computation in a 5 so they don't * get recalculated if used more than once. PCLike deferMap, but only runs the result if a Maybe function of the G runtime value returns Just. If it returns Nothing, then no output is  generated. CThis is a good example of how to do more complex flow control with H promises. The generalization of this abstraction is too complex to be M distilled to elegant high-level combinators. If you need to implement your B own special flow control, then you should use functions from the  + module similarly to how it is done in the " implementation of this function. QFConverts an RuntimeSplice into a Splice, given a helper function that  generates a Builder. 55 67 89:;<=>?@List of attributes AList of attributes BCDE  tag name splice action  source state  splices to bind  source state FGHIJKLSplice to be run Splices to be bound first )Runtime data needed by the above splices MNOPQ55 67 89:;<=>?@ABCDE  FGHIJKLMNOPQ45 67 89:;<=>?@ABCDE  FGHIJKLMNOPQNone6789:;<=>?@AFGHIJKLMNOPQ6G>7IJKNOPQLMF89:;<=?@AHNone5BCDE5EBCDNoneS6Binds a new splice declaration to a tag name within a . T0Binds a set of new splice declarations within a . U Converts  to a splice returning a single TextNode. VRuns the parameter node'0s children and returns the resulting node list. G By itself this function is a simple passthrough splice that makes the J spliced node disappear. In combination with locally bound splices, this F function makes it easier to pass the desired view into your splices. WIBinds a list of splices before using the children of the spliced node as  a view. XIWrapper around runChildrenWith that applies a transformation function to G the second item in each of the tuples before calling runChildrenWith. YFLike runChildrenWith but using constant templates rather than dynamic  splices. ZILike runChildrenWith but using literal text rather than dynamic splices. [.Convenience function for looking up a splice. \1Adds an HTML format template to the heist state. ]0Adds an XML format template to the heist state. ^CStops the recursive processing of splices. Consider the following  example:   <foo>  <bar>  ...  </bar>  </foo>  Assume that "foo"- is bound to a splice procedure. Running the foo ' splice will result in a list of nodes L . Normally foo will recursively  scan L for splices and run them. If foo calls  stopRecursion, L F will be included in the output verbatim without running any splices. _-Performs splice processing on a single node. `GPerforms splice processing on a list of attributes. This is useful in C situations where you need to stop recursion, but still run splice  processing on the node's attributes. ERuns the attribute splice if it exists, otherwise it does inline $()  substitution. FHelper function for substituting a parsed attribute into an attribute  tuple. @Parses an attribute for any identifier expressions and performs  appropriate substitution. (Gets the attribute value. If the splice' s result list contains non-text C nodes, this will translate them into text nodes with nodeText and  concatenate them together. :Originally, this only took the first node from the splices's result list, E and only if it was a text node. This caused problems when the splice's K result contained HTML entities, as they would split a text node. This was J then fixed to take the first consecutive bunch of text nodes, and return K their concatenation. This was seen as more useful than throwing an error, A and more intuitive than trying to render all the nodes as text. HHowever, it was decided in the end to render all the nodes as text, and - then concatenate them. If a splice returned  "some <b>text</b> foobar"', the user would almost certainly want  "some text foobar"/ to be rendered, and Heist would probably seem J annoyingly limited for not being able to do this. If the user really did  want it to render "some "*, it would probably be easier for them to K accept that they were silly to pass more than that to be substituted than 0 it would be for the former user to accept that  "some <b>text</b> foobar" is being rendered as "some " because  it's "more intuitive". a/Performs splice processing on a list of nodes. @The maximum recursion depth. (Used to prevent infinite loops.)  FChecks the recursion flag and recurses accordingly. Does not recurse : deeper than mAX_RECURSION_DEPTH to avoid infinite loops. ! Looks up a template name runs a  computation on it. b>Looks up a template name evaluates it by calling runNodeList. "Sets the document type of a # based on the   value. $HRuns a template and sets the doctype properly. This is the right thing , to do if we are starting at the top level. c)Binds a list of constant string splices. d'Binds a single constant string splice. eHRenders a template with the specified parameters. This is the function  to use when you want to call( a template and pass in parameters from G inside a splice. If the template does not exist, this version simply  returns an empty list. fCLike callTemplate except the splices being bound are constant text  splices. g6Renders a template from the specified HeistState to a %. The M MIME type returned is based on the detected character encoding, and whether J the root template was an HTML or XML format template. It will always be  texthtml@ or @textxml0. If a more specific MIME type is needed for a E particular XML application, it must be provided by the application. hIRenders a template with the specified arguments passed to it. This is a M convenience function for the common pattern of calling renderTemplate after M using bindString, bindStrings, or bindSplice to set up the arguments to the  template. RS tag name splice action  source state Tsplices to bind  start state UVW8List of splices to bind before running the param nodes. Returns the passed in view. XSplice generating function List of tuples to be bound YZ[\-Path that the template will be referenced by  The template' s DOM nodes 6An optional path to the actual file on disk where the  template is stored ]-Path that the template will be referenced by  The template' s DOM nodes 6An optional path to the actual file on disk where the  template is stored ^_`a !b"$cdeThe name of the template "Splices to call the template with fThe name of the template "Splices to call the template with gh RSTUVWXYZ[\]^_`a !b"$cdefgh RSTUVWXYZ[\]^_`a !b"$cdefghNone/4RSTUVWXYZ[\]^_`abcdefghR\][ST4UVWXYZ/^_`abcdefghNonei#Default name for the apply splice. j*Default attribute name for the apply tag. lEApplies a template as if the supplied nodes were the children of the   apply tag. m$Implementation of the apply splice. nHThis splice crashes with an error message. Its purpose is to provide a F load-time warning to anyone still using the old content tag in their I templates. In Heist 0.10, tho content tag was replaced by two separate H apply-content and bind-content tags used by the apply and bind splices  respectively. ijklmnijklmnijklmnijklmnNoneo"Default name for the bind splice. p)Default attribute name for the bind tag. q#Implementation of the bind splice. opqopqopqopqNone r(State for storing cache tag information sClears the cache tag state. &9Converts a TTL string into an integer number of seconds. tGThis is the splice that actually does the work. You should bind it to L the same tag name as you bound the splice returned by mkCacheTag otherwise  it won't work and you'll get runtime errors. u2This is the compiled splice version of cacheImpl. v$Returns items necessary to set up a "cache" tag. The cache tag cannot L be bound automatically with the other default Heist tags. This is because M this function also returns CacheTagState, so the user will be able to clear  it with the s function. KThis function returns a splice and a CacheTagState. The splice is of type   Splice IOA because it has to be bound as a load time preprocessing splice.  Haskell's type system won'0t allow you to screw up and pass this splice as " the wrong argument to initHeist. '@Explicit type signature to avoid the Show polymorphism problem. (,Gets a unique ID for use in the cache tags. )FA splice that sets the id attribute so that nodes can be cache-aware. r*+,s&-tuv'()rstuvrtuvs r*+,s&-tuv'() NonewName for the html splice. xGThe html splice runs all children and then traverses the returned node M forest removing all head nodes. Then it merges them all and prepends it to  the html tag's child list. y%Extracts all heads from a node tree. wxyThe root (html) node ;A tuple of a list of head nodes and the original tree with  heads removed. wxywxywxy Nonez$Default name for the ignore splice. {=The ignore tag and everything it surrounds disappears in the  rendered output. z{z{z{z{ None&Default name for the markdown splice. 'Implementation of the markdown splice. |}~command to run any arguments standard input exitcode, stdout, stderr ./0123 |}~ ~|}|}~./0123 NoneJRun the splice contents if given condition is True, make splice disappear  if not. BFunction for constructing if splices that use a runtime predicate ' function to determine whether the node's children should be rendered.  ijklmnopqrstuvwxyz{|}~ None"Default name for the bind splice. #Implementation of the bind splice. None:This splice binds convenience tags for the given JSON (or ) JSON-convertible) value and runs the tag's child nodes using the new  bindings. %Tags bound when you pass in an object ,Tags bound for an object looking like this:  ! { "k_1": v_1, ..., "k_N": v_N } < value:{k_i}> -- treats v_i as text  < snippet:{k_i}> -- treats v_i as HTML  < with:{k_i}>+ -- explodes v_i and runs its children < value var=" foo.bar.baz"/> -- walks the JSON tree to find  " foo.bar.baz" , and interprets it as a string  < snippet var=" foo.bar.baz"/>  < with var=" foo.bar.baz">...<with> )Tags bound when you pass in anything else <value/>* -- the given JSON value, as a string  <snippet/>: -- the given JSON value, parsed and spliced in as HTML 456789:;<= 456789:;<=NoneEInterpreted splices are the splices that Heist has always had. They 6 return a list of nodes and are processed at runtime. ELoad time splices are like interpreted splices because they return a E list of nodes. But they are like compiled splices because they are + processed once at load time. All of Heist's built-in splices should be  used as load time splices. DCompiled splices return a DList of Chunks and are processed at load I time to generate a runtime monad action that will be used to render the  template. DAttribute splices are bound to attribute names and return a list of  attributes. @A list of all the locations that Heist should get its templates  from. JAn IO action for getting a template repo from this location. By not just K using a directory path here, we support templates loaded from a database, @ retrieved from the network, or anything else you can think of. IThe built-in set of splices that you should use in compiled splice mode. $ This list includes everything from  plus a M splice for the content tag that errors out when it sees any instance of the G old content tag, which has now been moved to two separate tags called ! apply-content and bind-content. EThe built-in set of static splices. All the splices that used to be M enabled by default are included here. To get the normal Heist behavior you M should include these in the hcLoadTimeSplices list in your HeistConfig. If M you are using interpreted splice mode, then you might also want to bind the  n2 splice to the content tag as a load time splice. ILoads templates from disk. This function returns just a template map so L you can load multiple directories and combine the maps before initializing  your HeistState. 7Reloads all the templates an an existing TemplateRepo. JAdds a path prefix to a templates in a map returned by loadTemplates. If L you want to add multiple levels of directories, separate them with slashes  as in foo/bar9. Using an empty string as a path prefix will leave the  map unchanged. >Creates an empty HeistState. JThis is the main Heist initialization function. You pass in a map of all C templates and all of your splices and it constructs and returns a  HeistState. We don'Ct provide functions to add either type of loadtime splices to your , HeistState after initHeist because it doesn't make any sense unless you M re-initialize all templates with the new splices. If you add any old-style I runtime heist splices after calling this function, they will still work M fine if you use Heist.Interpreted.renderTemplate. If you add any templates J later, then those templates will be available for interpreted rendering, ! but not for compiled rendering. LIn the past you could add templates to your HeistState after initialization G using its Monoid instance. Due to implementation details, this is no J longer possible. All of your templates must be known when you call this  function. ?FRuns preprocess on a TemplateRepo and returns the modified templates. @8Processes a single template, running load time splices. IWrapper around initHeist that also sets up a cache tag. It sets up both M compiled and interpreted versions of the cache tag splices. If you need to I configure the cache tag differently than how this function does it, you F will still probably want to pattern your approach after this function's  implementation. A>B?@CC  !"#$%&'()*+,-.0123/  .0123-A>B?@CNone-Structure representing a template directory. Creates and returns a new  wrapped in an Either for  error handling. Creates and returns a new , using the monad's fail  function on error.  Gets the  from a TemplateDirectory. Clears the TemplateDirectory's cache tag state. 7Clears cached content and reloads templates from disk. DPrepends an error onto a Left. EDEDF !"#$%&'()*+,-.//0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeJfg]KhijklmnoSTQpqr\s[tuvwxyz{|}~            lfgI !"#$%&' ()*+,-./012345678 9 : ; < = >?@ABCDEFGHIJKLMNOPheist-0.13.0.2HeistHeist.SpliceAPIHeist.InterpretedHeist.Compiled.LowLevelHeist.CompiledHeist.Splices.ApplyHeist.Splices.BindHeist.Splices.CacheHeist.Splices.HtmlHeist.Splices.IgnoreHeist.Splices.Markdown Heist.SplicesHeist.Splices.BindStrictHeist.Splices.JsonHeist.TemplateDirectoryData.HeterogeneousEnvironment Heist.Types Heist.CommonHeist.Compiled.InternalLowLevelHeist.Interpreted.InternalHeistT HeistState AttrSpliceChunk RuntimeSplice DocumentFiledfDocdfFileTPathMIMETypeTemplate templateNamescompiledTemplateNames spliceNamescompiledSpliceNames evalHeistT getParamNodelocalParamNodegetsHSgetHSputHSmodifyHS restoreHSlocalHSSplicesSplicesM unSplices###!#? noSplices runSplices splicesToListaddmapSapplySinsertS insertWithS unionWithS$$mapNames prefixSplicesnamespaceSplicesorError hasTemplate mapSplices getContextgetTemplateFilePathgetDoc getXMLDocbindAttributeSplicesPromiseSplice runChildren yieldPure yieldRuntimeyieldRuntimeEffect yieldPureTextyieldRuntimeText runNodeListcodeGenrunNode runAttributesrunAttributesRaw getPromise putPromise adjustPromisenewEmptyPromisewithLocalSplicesrenderTemplate callTemplate textSplice nodeSplice pureSplice withSplicesmanyWithSplices deferManydeferMap mayDeferMap bindLater bindSplice bindSplicesrunChildrenWithrunChildrenWithTransrunChildrenWithTemplatesrunChildrenWithText lookupSplice addTemplateaddXMLTemplate stopRecursion evalTemplate bindStrings bindStringcallTemplateWithTextrenderWithArgsapplyTag applyAttrrawApply applyNodes applyImpldeprecatedContentCheckbindTagbindAttrbindImpl CacheTagStateclearCacheTagState cacheImplcacheImplCompiled mkCacheTaghtmlTaghtmlImpl extractHeads ignoreTag ignoreImplNoMarkdownFileExceptionMarkdownExceptionPandocMissingException markdownTagmarkdownSplicepandocpandocBSreadProcessWithExitCode' ifISplice ifCSplice bindStrictTagbindStrictImplbindJson HeistConfighcInterpretedSpliceshcLoadTimeSpliceshcCompiledSpliceshcAttributeSpliceshcTemplateLocationsTemplateLocation TemplateRepodefaultLoadTimeSplicesdefaultInterpretedSplices loadTemplatesreloadTemplatesaddTemplatePathPrefix initHeistinitHeistWithCacheTagTemplateDirectorynewTemplateDirectorynewTemplateDirectory'getDirectoryHSgetDirectoryCTSreloadTemplateDirectory newKeyGenKeyGenKeyHeterogeneousEnvironmentgetKeyIdemptymakeKeylookupinsertdeleteadjustAttASTtransformers-0.3.0.0Control.Monad.Trans.Classlift _spliceMap _templateMap_compiledSpliceMap_compiledTemplateMap_recurse _curContext_recursionDepth _doctypes_curTemplateFile_keygen_preprocessingMode _curMarkup RuntimeAction RuntimeHtmlPureMarkuptemplateStateTyCon liftCatch liftCallCCtemplateMonadTyCon mtl-2.1.2Control.Monad.Reader.ClasslocalControl.Monad.State.ClassgetsgetputmodifymodRecursionDepth$fMonadContHeistT$fMonadErroreHeistT$fMonadReaderrHeistT$fMonadStatesHeistT$fMonadPlusHeistT$fAlternativeHeistT$fMonadFixHeistT$fMonadCatchIOHeistT$fMonadTransHeistT$fMonadIOHeistT $fMonadHeistT$fApplicativeHeistT$fFunctorHeistTIdentLiteral runHeistT_attrSpliceMapunRTHtmlXmltr showChunk isPureChunkisIdent$fTypeable1HeistT$fTypeableHeistState $fShowChunk$fMonoidRuntimeSplice$fMonoidSplicesM ParserFun showTPathsetCurTemplateFile attParser splitPathWithsplitLocalPathsplitTemplatePathlookupTemplateghc-prim GHC.TypesTrue singleLookup traversePath loadTemplate loadTemplate' getDocWith setTemplatesinsertTemplate addDoctype tpathName setCurContextmimeType pureTextChunk runSplicerunDocumentFile consolidatebytestring-0.10.0.2Data.ByteString.Internal ByteStringsubtreeIsStatichasAttributeSubstitutions compileNode xmlhtml-0.2.3Text.XmlHtml.CommonNoderenderFragmentcompileTemplatecompileTemplatescompileTemplates' parseAttrs parseAttrparseAtt parseAtt2 attrToChunk attrToBuildergetAttributeSplicegetAttributeSplice2 interpret text-0.11.2.3Data.Text.InternalText runAttrSpliceattSubstmAX_RECURSION_DEPTH recurseSplice lookupAndRun fixDocTypeDocumentevalWithDoctypesblaze-builder-0.3.1.1'Blaze.ByteString.Builder.Internal.TypesBuilderparseTTL generateIdgetId setupSpliceCTS cacheTagNameaddCompiledRefgetTTL"$fExceptionNoMarkdownFileException$fShowNoMarkdownFileException$fExceptionMarkdownException$fShowMarkdownException!$fExceptionPandocMissingException$fShowPandocMissingException JsonMonad errorMessage withValue boolToText numToTextfindExprasHtml snippetTagvalueTag explodeTagemptyHSpreproc preprocess allErrors initHeist'$fMonoidHeistConfigleftPass