T      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  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  !"#$%&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 *Gets the current context +DGets 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. ,"Reads an HTML template from disk. -!Reads an XML template from disk. &Sets the templateMap in a HeistState. $Adds a template to the heist state. .0Binds a set of new splice declarations within a . '()Splice generating function &List of items to generate splices for 1The result of all splices concatenated together. *+path of the template root ,full file path (includes the template root) ,-.splices to bind  start state '()*+,-.'()*+,-.None7/@Promises are used for referencing the results of future runtime 2 computations during load time splice processing. 09A 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. 1Runs 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. 2HTakes a promise function and a runtime action returning a list of items H that fit in the promise and returns a Splice that executes the promise 6 function for each item and concatenates the results. $This function works nicely with the 4 family of ) functions, much like the combination of ) and runChildrenWith  for interpreted splices. 3:Returns a runtime computation that simply renders the node' s children. 4IBinds a list of Builder splices before using the children of the spliced  node as a view. 5HWrapper that composes a transformation function with the second item in 4 each of the tuples before calling promiseChildren. 6FBinds a list of Text splices before using the children of the spliced  node as a view. 7FBinds a list of Node splices before using the children of the spliced L node as a view. Note that this will slow down page generation because the F nodes generated by the splices must be traversed and rendered into a  ByteString at runtime. %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 N 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. IIHelper function for transforming the second element of each of a list of  tuples. J The type signature says it all. KGAdds 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. LK9 specialized to use a colon as separator in the style of  XML namespaces. M4Converts pure text splices to pure Builder splices. NHConverts a pure text splice function to a pure Builder splice function. O4Converts pure Node splices to pure Builder splices. PHConverts a pure Node splice function to a pure Builder splice function. QAConverts pure Builder splices into monadic splice functions of a  /. RGConverts a pure Builder splice function into a monadic splice function  that takes a /. S.Change the promise type of a splice function. TRepromise a list of splices. UHChange the promise type of a splice function with a function that might F fail. If a Nothing is encountered, then the splice will generate no  output. V repromiseMay' for a list of splices. WIAllows you to use deferred Promises in a compiled splice. It takes care L of the boilerplate of creating and storing data in a promise to be used at M load time when compiled splices are processed. This function is similar to ; mapPromises but runs on a single value instead of a list. XHTakes a promise function and a runtime action returning a list of items H that fit in the promise and returns a Splice that executes the promise 6 function for each item and concatenates the results. Y3Another useful way of combining groups of splices. ) FIXME - We probably need to export this applyDeferred :: Monad n # => RuntimeSplice n a / -> [(Text, Promise a -> Splice n)] " -> [(Text, Splice n)] ,applyDeferred m = applySnd m . mapSnd defer FThis is kind of the opposite of defer. Not sure what to name it yet. M FIXME - This is a really common pattern, so I think we do want to expose it deferred :: (Monad n) + => (t -> RuntimeSplice n Builder)  -> Promise t  -> Splice n *deferred f p = return $ yieldRuntime $ f =<< getPromise p GRuns a splice computation with a list of splices that are functions of  runtime data. ZGGets a list of items at runtime, then for each item it runs the splice L with the list of splices bound. There is no pure variant of this function F because the desired behavior can only be achieved as a function of a  Promise. [Like Y, but works for "pure" splices that don' t operate in  the HeistT monad. E/012Use 4 or a variant to create this  function. .Runtime computation returning a list of items 3456789:;<=  >?   @ABCDE tag name splice action  source state splices to bind  source state FGHIJKLMNOPQRSTUVWXYZ9Splice to run for each of the items in the runtime list.  You'll frequently use 1 here. List of splices to bind 4Runtime action returning a list of items to render. [E/0123456789:;<=  >?   @ABCDEFGHIJKLMNOPQRSTUVWXYZ[D/0123456789:;<=  >?   @ABCDEFGHIJKLMNOPQRSTUVWXYZ[None-/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[-0G>1IJKLMOQNPRTVSUWXYZ[23456789:;<F/EBCD=?@AHNone !Mappends a doctype to the state. ]6Binds a new splice declaration to a tag name within a . ^0Binds a set of new splice declarations within a . _ Converts  to a splice returning a single TextNode. `Runs 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. aIBinds a list of splices before using the children of the spliced node as  a view. bIWrapper around runChildrenWith that applies a transformation function to G the second item in each of the tuples before calling runChildrenWith. cFLike runChildrenWith but using constant templates rather than dynamic  splices. dILike runChildrenWith but using literal text rather than dynamic splices. e.Convenience function for looking up a splice. f1Adds an HTML format template to the heist state. g0Adds an XML format template to the heist state. hCStops 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. i-Performs splice processing on a single node. jGPerforms 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". k/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. l>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. m)Binds a list of constant string splices. n'Binds a single constant string splice. oHRenders 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. pCLike callTemplate except the splices being bound are constant text  splices. q6Renders 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. rIRenders 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. !\] tag name splice action  source state ^splices to bind  start state _`a8List of splices to bind before running the param nodes. Returns the passed in view. bSplice generating function List of tuples to be bound cdef-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 g-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 hijklmnoThe name of the template Association list of  (name,value) parameter pairs pThe name of the template Association list of  (name,value) parameter pairs qr!\]^_`abcdefghijklmnopqr!\]^_`abcdefghijklmnopqrNone).\]^_`abcdefghijklmnopqr\fge]^._`abcd)hijklmnopqrNones$Default name for the ignore splice. t=The ignore tag and everything it surrounds disappears in the  rendered output. ststststNoneu#Default name for the apply splice. v*Default attribute name for the apply tag. xEApplies a template as if the supplied nodes were the children of the   apply tag. y$Implementation of the apply splice. zHThis 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. uvwxyzuvwxyzuvwxyzuvwxyzNone{"Default name for the bind splice. |)Default attribute name for the bind tag. }#Implementation of the bind splice. {|}{|}{|}{|}None ~(State for storing cache tag information Clears the cache tag state. !9Converts a TTL string into an integer number of seconds. GThis 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. 2This is the compiled splice version of cacheImpl. $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  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. ~%&'!("#$~~ ~%&'!("#$NoneName for the html splice. GThe 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. %Extracts all heads from a node tree. The root (html) node ;A tuple of a list of head nodes and the original tree with  heads removed.  None&Default name for the markdown splice. 'Implementation of the markdown splice. command to run any arguments standard input exitcode, stdout, stderr )*+,-. )*+,-. 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.  stuvwxyz{|}~ 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 /012345678 /012345678NoneEInterpreted 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  z2 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. 9Creates 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. <9=:;>=  !"#$%&'(*+,-= (*+ !"#$%&,-'<9=:;> None-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. ?Prepends an error onto a Left. @?@?A !"#$%%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklAmn_BopqrstuvPQNwxyYzX{|}~         $s     mn@ !"#$  %&'()*+,-./01 2 3 4 5 6 7 8 9 : ; < = > ? @ ABCDEFG H I heist-0.12.0HeistHeist.InterpretedHeist.CompiledHeist.Splices.IgnoreHeist.Splices.ApplyHeist.Splices.BindHeist.Splices.CacheHeist.Splices.HtmlHeist.Splices.Markdown Heist.SplicesHeist.Splices.BindStrictHeist.Splices.JsonHeist.TemplateDirectoryData.HeterogeneousEnvironment Heist.Types Heist.CommonHeist.Compiled.InternalHeist.Interpreted.InternalHeistT HeistState _spliceMap _templateMap_compiledSpliceMap_compiledTemplateMap_attrSpliceMap_recurse _curContext_recursionDepth _doctypes_curTemplateFile_keygen_preprocessingMode _curMarkup AttrSpliceChunk RuntimeSplice DocumentFiledfDocdfFileTPathMIMETypeTemplate templateNamescompiledTemplateNames spliceNamescompiledSpliceNames evalHeistT getParamNodelocalParamNodegetsHSgetHSputHSmodifyHS restoreHSlocalHSorError hasTemplate mapSplices getContextgetTemplateFilePathgetDoc getXMLDocbindAttributeSplicesPromiseSplice runChildren mapPromisespromiseChildrenpromiseChildrenWithpromiseChildrenWithTranspromiseChildrenWithTextpromiseChildrenWithNodes yieldPure yieldRuntimeyieldRuntimeEffect yieldPureTextyieldRuntimeText runNodeListcodeGenrunNode runAttributesrunAttributesRaw getPromise putPromise adjustPromisenewEmptyPromisewithLocalSplicesrenderTemplate callTemplatemapSndapplySnd prefixSplicesnamespaceSplices textSplices textSplice htmlSplices htmlSplice pureSplices pureSplice repromise' repromise repromiseMay' repromiseMaydefer deferMany withSplicesmanyWithSpliceswithPureSplices bindSplice bindSplicesrunChildrenWithrunChildrenWithTransrunChildrenWithTemplatesrunChildrenWithText lookupSplice addTemplateaddXMLTemplate stopRecursion evalTemplate bindStrings bindStringcallTemplateWithTextrenderWithArgs ignoreTag ignoreImplapplyTag applyAttrrawApply applyNodes applyImpldeprecatedContentCheckbindTagbindAttrbindImpl CacheTagStateclearCacheTagState cacheImplcacheImplCompiled mkCacheTaghtmlTaghtmlImpl extractHeadsNoMarkdownFileExceptionMarkdownExceptionPandocMissingException markdownTagmarkdownSplicepandocpandocBSreadProcessWithExitCode' ifISplice ifCSplice bindStrictTagbindStrictImplbindJson HeistConfighcInterpretedSpliceshcLoadTimeSpliceshcCompiledSpliceshcAttributeSpliceshcTemplateLocationsTemplateLocation TemplateRepodefaultLoadTimeSplicesdefaultInterpretedSplices loadTemplatesreloadTemplatesaddTemplatePathPrefix initHeistinitHeistWithCacheTagTemplateDirectorynewTemplateDirectorynewTemplateDirectory'getDirectoryHSgetDirectoryCTSreloadTemplateDirectory newKeyGenKeyGenKeyHeterogeneousEnvironmentgetKeyIdemptymakeKeylookupinsertdeleteadjustAttASTtransformers-0.3.0.0Control.Monad.Trans.Classlift 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 runHeistTunRTHtmlXmltr showChunk isPureChunkisIdent$fTypeable1HeistT$fTypeableHeistState $fShowChunk$fMonoidRuntimeSplice ParserFun showTPathsetCurTemplateFile attParser splitPathWithsplitLocalPathsplitTemplatePathlookupTemplateghc-prim GHC.TypesTrue singleLookup traversePath loadTemplate loadTemplate' getDocWith setTemplatesinsertTemplate tpathName setCurContextmimeType pureTextChunk runSplicerunDocumentFile consolidatebytestring-0.10.0.2Data.ByteString.Internal ByteStringsubtreeIsStatichasAttributeSubstitutions compileNode xmlhtml-0.2.1Text.XmlHtml.CommonNoderenderFragmentcompileTemplatecompileTemplatescompileTemplates' parseAttrs parseAttrparseAtt parseAtt2 attrToChunk attrToBuildergetAttributeSplicegetAttributeSplice2 interpret addDoctype text-0.11.3.1Data.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