ZȤ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  NoneHIf you use two different KeyGens to work with the same map, you deserve  what you get.   None7DAST 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. 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. +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 J  !"#$%9  !"#$%1   !"#$%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. )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 &'()*+,-&'()*+,-None(.@Promises are used for referencing the results of future runtime 2 computations during load time splice processing. /9A 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. 0Runs 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. 1HTakes 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 3 family of ) functions, much like the combination of ( and runChildrenWith  for interpreted splices. 2:Returns a runtime computation that simply renders the node' s children. 3IBinds a list of Builder splices before using the children of the spliced  node as a view. 4HWrapper that composes a transformation function with the second item in 4 each of the tuples before calling promiseChildren. 5FBinds a list of Text splices before using the children of the spliced  node as a view. 6FBinds 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. 7CYields 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. 80Yields a runtime action that returns a builder. 9IYields 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 L from Heist.Interpreted. ;HConvenience wrapper around yieldRuntime allowing you to work with Text. <FThis lets you turn a plain runtime monad function returning a Builder  into a compiled splice. =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. A3Gets the result of a promised runtime computation. B.Adds a promise to the runtime splice context. CModifies a promise. DCreates 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. EEAdds 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. 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. RIAllows 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. SHTakes 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. UGGets 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. >./01Use 3 or a variant to create this  function. .Runtime computation returning a list of items 23456789:;<=>?@ABCD tag name splice action  source state splices to bind  source state EFGHIJKLMNOPQRSTU9Splice to run for each of the items in the runtime list.  You'll frequently use 0 here. List of splices to bind 4Runtime action returning a list of items to render. V>./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV=./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVNone)./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV)/G>0IJKMOLNPQRSTUV123456789:;<EF.DABC=?@HNone !Mappends a doctype to the state. X6Binds a new splice declaration to a tag name within a . Y0Binds a set of new splice declarations within a . Z 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. \IBinds a list of splices before using the children of the spliced node as  a view. ]IWrapper around runChildrenWith that applies a transformation function to G the second item in each of the tuples before calling runChildrenWith. ^FLike runChildrenWith but using constant templates rather than dynamic  splices. _ILike runChildrenWith but using literal text rather than dynamic splices. `.Convenience function for looking up a splice. a1Adds an HTML format template to the heist state. b0Adds an XML format template to the heist state. cCStops 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. d-Performs splice processing on a single node. eGPerforms 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". f/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. g>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. h)Binds a list of constant string splices. i'Binds a single constant string splice. jHRenders 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. kCLike callTemplate except the splices being bound are constant text  splices. l6Renders 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. mIRenders 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. !WX tag name splice action  source state Ysplices to bind  start state Z[\8List of splices to bind before running the param nodes. Returns the passed in view. ]Splice generating function List of tuples to be bound ^_`a-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 b-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 cde  f   ghijThe name of the template Association list of  (name,value) parameter pairs kThe name of the template Association list of  (name,value) parameter pairs lm!WXYZ[\]^_`abcde  f   ghijklm!WXYZ[\]^_`abcde  f   ghijklmNone(-WXYZ[\]^_`abcdefghijklmWab`XY-Z[\]^_(cdefghijklmNonen$Default name for the ignore splice. o=The ignore tag and everything it surrounds disappears in the  rendered output. nonononoNonep#Default name for the apply splice. q*Default attribute name for the apply tag. sEApplies a template as if the supplied nodes were the children of the   apply tag. t$Implementation of the apply splice. pqrstupqrstupqrstupqrstuNonev"Default name for the bind splice. w)Default attribute name for the bind tag. x#Implementation of the bind splice. vwxvwxvwxvwxNone y(State for storing cache tag information zClears 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 z 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. yz{|}yz{|}y{|}z yz{|}None~Name 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.  nopqrstuvwxyz{|}~ 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  !"#$%&'()  !"#$%&'()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. Templates returned from the  function. 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 I should include these in the hcLoadTimeSplices list in your HeistConfig. 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 I should include these in the hcLoadTimeSplices list in your HeistConfig. 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. 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 L do 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. 0Prepends an error onto a Left. 10102 !"#$$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg@hi]AjklmnopqPQNrstYuXvwxyz{|}~         #nhi?       !" # $ % & ' ( ) * + , - . / 0 1 2345678 9 : heist-0.11.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 AttrSpliceChunk RuntimeSplice DocumentFiledfDocdfFileTPathMIMETypeTemplate templateNamescompiledTemplateNames spliceNamescompiledSpliceNames evalHeistT getParamNodelocalParamNodegetsHSgetHSputHSmodifyHS restoreHSlocalHSorError hasTemplate mapSplices getContextgetTemplateFilePathgetDoc getXMLDocbindAttributeSplicesPromiseSplice runChildren mapPromisespromiseChildrenpromiseChildrenWithpromiseChildrenWithTranspromiseChildrenWithTextpromiseChildrenWithNodes yieldPure yieldRuntimeyieldRuntimeEffect yieldPureTextyieldRuntimeText yieldLater runNodeListcodeGenrunNode runAttributes getPromise putPromise adjustPromisenewEmptyPromise addSpliceswithLocalSplicesrenderTemplate callTemplatemapSndapplySnd textSplices textSplice nodeSplices nodeSplice pureSplices pureSplicemapInputPromisedefer deferMany withSplicesmanyWithSpliceswithPureSplices bindSplice bindSplicesrunChildrenWithrunChildrenWithTransrunChildrenWithTemplatesrunChildrenWithText lookupSplice addTemplateaddXMLTemplate stopRecursion evalTemplate bindStrings bindStringcallTemplateWithTextrenderWithArgs ignoreTag ignoreImplapplyTag applyAttrrawApply applyNodes applyImpldeprecatedContentCheckbindTagbindAttrbindImpl CacheTagStateclearCacheTagState cacheImplcacheImplCompiled mkCacheTaghtmlTaghtmlImpl extractHeadsNoMarkdownFileExceptionMarkdownExceptionPandocMissingException markdownTagmarkdownSplicepandocpandocBSreadProcessWithExitCode' ifISplice ifCSplice bindStrictTagbindStrictImplbindJson HeistConfighcInterpretedSpliceshcLoadTimeSpliceshcCompiledSpliceshcAttributeSplices hcTemplatesdefaultLoadTimeSplicesdefaultInterpretedSplices loadTemplatesaddTemplatePathPrefix initHeistinitHeistWithCacheTagTemplateDirectorynewTemplateDirectorynewTemplateDirectory'getDirectoryHSgetDirectoryCTSreloadTemplateDirectory newKeyGenKeyGenKeyHeterogeneousEnvironmentgetKeyIdemptymakeKeylookupinsertdeleteadjustAttASTtransformers-0.3.0.0Control.Monad.Trans.Classlift RuntimeAction RuntimeHtmlPuretemplateStateTyCon 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 runHeistTunRTtr showChunk isPureChunkisIdent$fTypeable1HeistT$fTypeableHeistState $fShowChunk$fMonoidRuntimeSplice ParserFun showTPathsetCurTemplateFile attParser splitPathWithsplitLocalPathsplitTemplatePathlookupTemplateghc-prim GHC.TypesTrue singleLookup traversePath loadTemplate getDocWith setTemplatesinsertTemplate tpathName setCurContextmimeType pureTextChunk runSplicerunDocumentFile consolidatebytestring-0.10.0.0Data.ByteString.Internal ByteStringsubtreeIsStatichasAttributeSubstitutions compileNodexmlhtml-0.2.0.3Text.XmlHtml.CommonNodecompileTemplatecompileTemplatescompileTemplates' parseAttrs parseAttrparseAtt attrToChunk attrToBuildergetAttributeSplice interpret addDoctype text-0.11.2.3Data.Text.InternalText runAttrSpliceattSubstmAX_RECURSION_DEPTH recurseSplice lookupAndRun fixDocTypeDocumentevalWithDoctypesblaze-builder-0.3.1.0'Blaze.ByteString.Builder.Internal.TypesBuilderparseTTL generateIdgetId setupSpliceCTS cacheTagNameaddCompiledRefgetTTL"$fExceptionNoMarkdownFileException$fShowNoMarkdownFileException$fExceptionMarkdownException$fShowMarkdownException!$fExceptionPandocMissingException$fShowPandocMissingException JsonMonad errorMessage withValue boolToText numToTextfindExprasHtml snippetTagvalueTag explodeTagemptyHSpreproc preprocess TemplateRepo initHeist'$fMonoidHeistConfigleftPass