/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None +246BHLMVIf you use two different KeyGens to work with the same map, you deserve what you get.  None +246BLM;AST to hold attribute parsing structure. This is necessary because attoparsec doesn't support parsers running in another monad.FHeistT is the monad transformer used for splice processing. HeistT intentionally does not expose any of its functionality via MonadState or MonadReader functions. We define passthrough instances for the most common types of monads. These instances allow the user to use HeistT in a monad stack without needing calls to .n4 is the runtime monad (the parameter to HeistState).mT 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 IOO, and more importantly it is NOT runtime. In Heist, the rule of thumb is that IO means load time and n means runtime.SHolds all the state information needed for template processing. You will build a  HeistState using  initHeist and any of Heist's HeistState -> HeistState1 "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 fA mapping of template names to templates , _compiledTemplateMap :: HashMap TPath (m Builder, MIMEType) "A flag to control splice recursion3The path to the template currently being processed.RA counter keeping track of the current recursion depth to prevent infinite loops.4The doctypes encountered during template processing.5The full path to the current template's file on disk.4A key generator used to produce new unique Promises.Flag indicating whether we're in preprocessing mode. During preprocessing, errors should stop execution and be reported. During template rendering, it's better to skip the errors and render the page.This is needed because compiled templates are generated with a bunch of calls to renderFragment rather than a single call to render.,A prefix for all splices (namespace ++ ":").4List of errors encountered during splice processing.Whether to throw an error when a tag wih the heist namespace does not correspond to a bound splice. When not using a namespace, this flag is ignored.Type alias for attribute splices. The function parameter is the value of the bound attribute splice. The return value is a list of attribute key/value pairs that get substituted in the place of the bound attribute.@Opaque type representing pieces of output from compiled splices.,runtime action used only for its side-effectoutput computed at run timeoutput 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.'^Reversed 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 ) is a forest of XML nodes. Here we deviate from the "single root node" constraint of well-formed XML because we want to allow templates to contain document fragments that may not have a single root.*"Convenient type alies for splices.-<Gets the names of all the templates defined in a HeistState..<Gets the names of all the templates defined in a HeistState./FGets the names of all the interpreted splices defined in a HeistState.0CGets the names of all the compiled splices defined in a HeistState.1DEvaluates a template monad as a computation in the underlying monad.2Helper for MonadError instance.3Helper for MonadCont instance.4(Gets the node currently being processed. G<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.5 HeistT's .6 HeistT's .7 HeistT's .8 HeistT's .9 HeistT's .:Restores the HeistState. This function is almost like putHS except it preserves the current doctypes. You should use this function instead of putHS 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.;ZAbstracts the common pattern of running a HeistT computation with a modified heist state.<Modifies the recursion depth.MonadCont passthrough instanceMonadError passthrough instance MonadReader passthrough instanceMonadState passthrough instanceMonadPlus passthrough instance Alternative passthrough instanceMonadFix passthrough instanceMonadCatchIO instanceMonadTrans instanceMonadIO instanceMonad instanceApplicative instanceFunctor instanceM  !"#$%&'()*+,-./0123456789:;<=>  !"#$%&'()*+,-./0123456789:;<=.  "!#$%&'()*+,-./0123456789:;<=None +246BLMType synonym for parsers.>If Heist is running in fail fast mode, then this function will throw an exception with the second argument as the error message. Otherwise, the first argument will be executed to represent silent failure.This behavior allows us to fail quickly if an error crops up during load-time splice processing or degrade more gracefully if the error occurs while a user request is being processed.UPrepends the location of the template currently being processed to an error message.?>Adds an error message to the list of splice processing errors.Function for showing a TPath.'Convert a TPath into a ByteString path.Sets the current template file.+Parser for attribute variable substitution.Converts a path into an array of the elements in reverse order. If the 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|Converts a path into an array of the elements in reverse order using the path separator of the local operating system. See  for more details.uConverts a path into an array of the elements in reverse order using a forward slash (/) as the path separator. See  for more details./Convenience function for looking up a template.@Returns 7 if the given template can be found in the heist state.3Does a single template lookup without cascading up.Searches for a template by looking in the full path then backing up into each of the parent directories until the template is found.AMaps a splice generating function over a list and concatenates the results. This function now has a more general type signature so it works with both compiled and interpreted splices. The old type signature was this: YmapSplices :: (Monad n) => (a -> Splice n n) -> [a] -> Splice n nBGets the current contextCGets the full path to the file holding the template currently being processed. Returns Nothing if the template is not associated with a file 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. Loads a template at the specified path, choosing the appropriate parser based on the file extension. The template is only loaded if it has a ".tpl" or ".xtpl" extension. Returns an empty list if the extension doesn't match. (Reads an HTML or XML template from disk.D!Reads an HTML template from disk.E Reads an XML template from disk. %Sets the templateMap in a HeistState. #Adds a template to the heist state.F0Binds a set of new splice declarations within a . Mappends a doctype to the state.>?@ASplice generating function%List of items to generate splices for0The result of all splices concatenated together.BC path of the template root+full file path (includes the template root)  DE  Fsplices to bind start state>?@ABC   DE  F>?@ABC   DE  FNone +246BLM)GqPromises are used for referencing the results of future runtime computations during load time splice processing.H9A compiled Splice is a HeistT computation that returns a DList (Chunk m).uThe more interesting part of the type signature is what comes before the return value. The first type parameter in  n IOs is the runtime 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 compiled splices themselves are run in the IO monad, which will usually mean at load time. Compiled splices run at load time, and they return computations that run at runtime.I%Runs the parameter node's children and returns the resulting compiled chunks. By itself this function is a simple passthrough splice that makes the spliced node disappear. In combination with locally bound splices, this function makes it easier to pass the desired view into your splices.$Yields pure text known at load time.JDYields a pure Builder known at load time. You should use this and Md as much as possible to maximize the parts of your page that can be compiled to static ByteStrings.K/Yields a runtime action that returns a builder.LVYields a runtime action that returns no value and is only needed for its side effect.MVA convenience wrapper around yieldPure for working with Text. Roughly equivalent to [ from Heist.Interpreted.NGConvenience wrapper around yieldRuntime allowing you to work with Text.O_Returns a computation that performs load-time splice processing on the supplied list of nodes.>Runs a DocumentFile with the appropriate template context set.$Consolidate consecutive Pure Chunks.PFGiven a list of output chunks, consolidate turns consecutive runs of  Pure Html6 values into maximally-efficient pre-rendered strict  chunks.-Looks up a splice in the compiled splice map.QRuns a single node. If there is no splice referenced anywhere in the subtree, then it is rendered as a pure chunk, otherwise it calls compileNode to generate the appropriate runtime computation.UChecks whether a node's subtree is static and can be rendered up front at load time.8Checks whether a string has any attribute substitutions.Given a R in the DOM tree, produces a "runtime splice" that will generate html at runtime.RPerforms splice processing on a list of attributes. This is useful in situations where you need to stop recursion, but still run splice processing on the node's attributes.SPerforms splice processing on a list of attributes. This is useful in situations where you need to stop recursion, but still run splice processing on the node's attributes.T2Gets the result of a promised runtime computation.U-Adds a promise to the runtime splice context.VModifies a promise.WCreates an empty promise.?Binds a compiled splice. This function should not be exported.HBinds a list of compiled splices. This function should not be exported.XAdds a list of compiled splices to the splice map. This function is useful because it allows compiled splices to bind other compiled splices during load-time splice processing.Y`Looks up a compiled template and returns a runtime monad computation that constructs a builder.Z;Looks up a compiled template and returns a compiled splice.[GConverts a pure text splice function to a pure Builder splice function.\GConverts a pure Node splice function to a pure Builder splice function.]LConverts a pure XML Node splice function to a pure Builder splice function.^MConverts a pure HTML Node splice function to a pure Builder splice function._[Converts a pure Builder splice function into a monadic splice function of a RuntimeSplice.`^Runs a splice, but first binds splices given by splice functions that need some runtime data.agLike withSplices, but evaluates the splice repeatedly for each element in a list generated at runtime.VMore powerful version of manyWithSplices that lets you also define attribute splices.b Similar to A in interpreted mode. Gets a runtime list of items and applies a compiled runtime splice function to each element of the list.c/Saves the results of a runtme computation in a G8 so they don't get recalculated if used more than once.dLike deferMap, but only runs the result if a Maybe function of the runtime value returns Just. If it returns Nothing, then no output is generated.This is a good example of how to do more complex flow control with promises. The generalization of this abstraction is too complex to be distilled to elegant high-level combinators. If you need to implement your own special flow control, then you should use functions from the L module similarly to how it is done in the implementation of this function.e[Converts an RuntimeSplice into a Splice, given a helper function that generates a Builder.7GHI JKLMNO!"#PQ$%&'RList of attributesSList of attributes()*+TUVWtag name splice action source statesplices to bind source stateXYZ,[\]^_`Splice to be runSplices to be bound first(Runtime data needed by the above splicesabcde7GHI JKLMNO!"#PQ$%&'RS()*+TUVWXYZ,[\]^_`abcde6GHI JKLMNO!"#PQ$%&'RS()*+TUVWXYZ,[\]^_`abcdeNone +246BLMHIJKLMNOPQRSXYZ[\]^_`abcdeHYPI[\]^_bcde`aXJKLMNOQRSZNone +246BLMGTUVWGWTUVNone +246BLMg6Binds a new splice declaration to a tag name within a .h0Binds a set of new splice declarations within a .i Converts - to a splice returning a single TextNode.jRuns the parameter node's children and returns the resulting node list. By itself this function is a simple passthrough splice that makes the spliced node disappear. In combination with locally bound splices, this function makes it easier to pass the desired view into your splices.kQBinds a list of splices before using the children of the spliced node as a view.lWrapper around runChildrenWith that applies a transformation function to the second item in each of the tuples before calling runChildrenWith.mOLike runChildrenWith but using constant templates rather than dynamic splices.nHLike runChildrenWith but using literal text rather than dynamic splices.o-Convenience function for looking up a splice.p0Adds an HTML format template to the heist state.q/Adds an XML format template to the heist state.rLStops 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, LF will be included in the output verbatim without running any splices.s,Performs splice processing on a single node.tPerforms splice processing on a list of attributes. This is useful in situations where you need to stop recursion, but still run splice processing on the node's attributes..SRuns the attribute splice if it exists, otherwise it does inline $() substitution./MHelper function for substituting a parsed attribute into an attribute tuple.0ZParses an attribute for any identifier expressions and performs appropriate substitution.1Gets the attribute value. If the splice's result list contains non-text 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, and only if it was a text node. This caused problems when the splice's result contained HTML entities, as they would split a text node. This was then fixed to take the first consecutive bunch of text nodes, and return their concatenation. This was seen as more useful than throwing an error, and more intuitive than trying to render all the nodes as text.XHowever, 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 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 accept that they were silly to pass more than that to be substituted than 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".u.Performs splice processing on a list of nodes.2?The maximum recursion depth. (Used to prevent infinite loops.)3Checks the recursion flag and recurses accordingly. Does not recurse deeper than mAX_RECURSION_DEPTH to avoid infinite loops.4 Looks up a template name runs a  computation on it.v=Looks up a template name evaluates it by calling runNodeList.5Sets the document type of a 6 based on the  value.7sRuns a template and sets the doctype properly. This is the right thing to do if we are starting at the top level.w(Binds a list of constant string splices.x&Binds a single constant string splice.yRenders a template with the specified parameters. This is the function to use when you want to "call" a template and pass in parameters from inside a splice. If the template does not exist, this version simply returns an empty list.zLLike callTemplate except the splices being bound are constant text splices.{6Renders a template from the specified HeistState to a 8. The MIME type returned is based on the detected character encoding, and whether the root template was an HTML or XML format template. It will always be  text/html or text/xmlt. If a more specific MIME type is needed for a particular XML application, it must be provided by the application.|Renders a template with the specified arguments passed to it. This is a convenience function for the common pattern of calling renderTemplate after using bindString, bindStrings, or bindSplice to set up the arguments to the template. fgtag name splice action source statehsplices to bind start stateijk7List of splices to bind before running the param nodes.Returns the passed in view.lSplice generating functionList of tuples to be boundmnop,Path that the template will be referenced byThe template's DOM nodesIAn optional path to the actual file on disk where the template is storedq,Path that the template will be referenced byThe template's DOM nodesIAn optional path to the actual file on disk where the template is storedrst./01u234v57wxyThe name of the template!Splices to call the template withzThe name of the template!Splices to call the template with{| fghijklmnopqrst./01u234v57wxyz{| fghijklmnopqrst./01u234v57wxyz{|None +246BLMAFfghijklmnopqrstuvwxyz{|fpqoghFijklmnArstuvwxyz{|None +246BLM}#Default name for the ignore splice.~NThe ignore tag and everything it surrounds disappears in the rendered output.}~}~}~}~None +246BLMSplices and templates_A namespace to use for all tags that are bound to splices. Use empty string for no namespace.Whether to throw an error when a tag wih the heist namespace does not correspond to a bound splice. When not using a namespace, this flag is ignored.mThe splices and templates Heist will use. To bind a splice simply include it in the appropriate place here.yInterpreted splices are the splices that Heist has always had. They return a list of nodes and are processed at runtime.Load time splices are like interpreted splices because they return a 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.Compiled splices return a DList of Chunks and are processed at load time to generate a runtime monad action that will be used to render the template.PAttribute splices are bound to attribute names and return a list of attributes.FA list of all the locations that Heist should get its templates from.An IO action for getting a template repo from this location. By not just using a directory path here, we support templates loaded from a database, retrieved from the network, or anything else you can think of.8My lens creation function to avoid a dependency on lens.TLens for interpreted splices :: Simple Lens (SpliceConfig m) (Splices (I.Splice m))SLens for load time splices :: Simple Lens (SpliceConfig m) (Splices (I.Splice IO))QLens for complied splices :: Simple Lens (SpliceConfig m) (Splices (C.Splice m))TLens for attribute splices :: Simple Lens (SpliceConfig m) (Splices (AttrSplice m))OLens for template locations :: Simple Lens (SpliceConfig m) [TemplateLocation]JLens for the SpliceConfig :: Simple Lens (HeistConfig m) (SpliceConfig m);Lens for the namespace :: Simple Lens (HeistConfig m) TextFLens for the namespace error flag :: Simple Lens (HeistConfig m) BoolSLens for interpreted splices :: Simple Lens (HeistConfig m) (Splices (I.Splice m))RLens for load time splices :: Simple Lens (HeistConfig m) (Splices (I.Splice IO))PLens for compiled splices :: Simple Lens (HeistConfig m) (Splices (C.Splice m))SLens for attribute splices :: Simple Lens (HeistConfig m) (Splices (AttrSplice m))NLens for template locations :: Simple Lens (HeistConfig m) [TemplateLocation]Z  !"#$%&'()*+,-./0123456789:;<=[*)('#$%& "!+, -./0123456789:;<=None +246BLM"Default name for the apply splice.)Default attribute name for the apply tag.FApplies a template as if the supplied nodes were the children of the  apply tag.#Implementation of the apply splice.-This splice crashes with an error message. Its purpose is to provide a load-time warning to anyone still using the old content tag in their templates. In Heist 0.10, tho content tag was replaced by two separate apply-content and bind-content tags used by the apply and bind splices respectively.None +246BLM!Default name for the bind splice.(Default attribute name for the bind tag."Implementation of the bind splice. None +246BLM 'State for storing cache tag informationClears the cache tag state.98Converts a TTL string into an integer number of seconds.This is the splice that actually does the work. You should bind it to the same tag name as you bound the splice returned by mkCacheTag otherwise it won't work and you'll get runtime errors.1This is the compiled splice version of cacheImpl.Returns items necessary to set up a "cache" tag. The cache tag cannot be bound automatically with the other default Heist tags. This is because this function also returns CacheTagState, so the user will be able to clear it with the  function.LThis function returns a splice and a CacheTagState. The splice is of type  Splice IO because it has to be bound as a load time preprocessing splice. Haskell's type system won't 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.<EA splice that sets the id attribute so that nodes can be cache-aware. =>?9@:;< =>?9@:;< None +246BLMName for the html splice.The html splice runs all children and then traverses the returned node 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) nodeLA tuple of a list of head nodes and the original tree with heads removed. None +246BLM%Default name for the markdown splice.&Implementation of the markdown splice.command to run any argumentsstandard inputexitcode, stdout, stderr  None +246BLMRRun the splice contents if given condition is True, make splice disappear if not.Function for constructing if splices that use a runtime predicate function to determine whether the node's children should be rendered. }~ None +246BLM!Default name for the bind splice."Implementation of the bind splice.None +246BLMThis 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"/>O -- 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/>9 -- the given JSON value, parsed and spliced in as HTML ABCDEFGHIJ ABCDEFGHIJNone +246BLM%Maps a function over all the splices.)Applies an argument to a splice function.Infix operator for  flip applyS*Maps a function over all the splice names.Adds a prefix to the tag names for a list of splices. If the existing tag name is empty, then the new tag name is just the prefix. Otherwise the new tag name is the prefix followed by the separator followed by the existing name.I specialized to use a colon as separator in the style of XML namespaces.KLMNOPQRSTUVWXYZ[\]^* *None +246BELM mThe built-in set of splices that you should use in compiled splice mode. This list includes everything from  plus a splice for the content tag that errors out when it sees any instance of the old content tag, which has now been moved to two separate tags called apply-content and bind-content.-The built-in set of static splices. All the splices that used to be enabled by default are included here. To get the normal Heist behavior you should include these in the scLoadTimeSplices list in your SpliceConfig. If you are using interpreted splice mode, then you might also want to bind the 2 splice to the content tag as a load time splice.PAn empty HeistConfig that uses the "h" namespace with error checking turned on.Loads templates from disk. This function returns just a template map so you can load multiple directories and combine the maps before initializing your HeistState.6Reloads all the templates an an existing TemplateRepo.Adds a path prefix to a templates in a map returned by loadTemplates. If you want to add multiple levels of directories, separate them with slashes as in "foo/bar". Using an empty string as a path prefix will leave the map unchanged._Creates an empty HeistState.This is the main Heist initialization function. You pass in a map of all templates and all of your splices and it constructs and returns a HeistState.We don't provide functions to add either type of loadtime splices to your HeistState after initHeist because it doesn't make any sense unless you re-initialize all templates with the new splices. If you add any old-style runtime heist splices after calling this function, they will still work fine if you use Heist.Interpreted.renderTemplate. If you add any templates later, then those templates will be available for interpreted rendering, but not for compiled rendering.In the past you could add templates to your HeistState after initialization using its Monoid instance. Due to implementation details, this is no longer possible. All of your templates must be known when you call this function.`ERuns preprocess on a TemplateRepo and returns the modified templates.a7Processes a single template, running load time splices.8Wrapper around initHeist that also sets up a cache tag. It sets up both compiled and interpreted versions of the cache tag splices. If you need to configure the cache tag differently than how this function does it, you will still probably want to pattern your approach after this function's implementation.b_cd`aVKLMNOPQRSTUVWXYZ[\]^#$%&'()*-./01456789:;>?@BCDE9)'(#$%&-.@/014BC56789:;DE?>b_cd`aNone +246BLM,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.6Clears cached content and reloads templates from disk.ePrepends an error onto a Left.fefeg !"#$%&'()*+,-./012234567789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx[yzn\{|}~debml              !"#$%&'(yz)Z*+,-./0123456789:;04<=>?&'@ABCD E F G H I J K LMNOPQRSTUVWXYWXZWX[WX\WX]WX^WX_WX`WXaWXbWXcWXdWXeWXfWXgWXhWXiWXiWXjWXklmnopqrs heist-0.14.1Heist.Internal.TypesHeistHeist.InterpretedHeist.Compiled.LowLevelHeist.CompiledHeist.Splices.IgnoreHeist.Splices.ApplyHeist.Splices.BindHeist.Splices.CacheHeist.Splices.HtmlHeist.Splices.Markdown Heist.SplicesHeist.Splices.BindStrictHeist.Splices.JsonHeist.SpliceAPIHeist.TemplateDirectoryData.HeterogeneousEnvironmentHeist.Internal.Types.HeistState Heist.CommonHeist.Compiled.InternalLowLevelHeist.Interpreted.InternalAttASTIdentLiteralHeistT runHeistT HeistState _spliceMap _templateMap_compiledSpliceMap_compiledTemplateMap_attrSpliceMap_recurse _curContext_recursionDepth _doctypes_curTemplateFile_keygen_preprocessingMode _curMarkup _splicePrefix _spliceErrors_errorNotBound AttrSpliceChunk RuntimeAction RuntimeHtmlPure RuntimeSpliceunRTMarkupHtmlXml DocumentFiledfDocdfFileTPathMIMETypeTemplateSplices showChunk isPureChunk templateNamescompiledTemplateNames spliceNamescompiledSpliceNames evalHeistT _liftCatch _liftCallCC getParamNodelocalParamNodegetsHSgetHSputHSmodifyHS restoreHSlocalHSmodRecursionDepthisIdentorErrortellSpliceError hasTemplate mapSplices getContextgetTemplateFilePathgetDoc getXMLDocbindAttributeSplicesPromiseSplice runChildren yieldPure yieldRuntimeyieldRuntimeEffect yieldPureTextyieldRuntimeText runNodeListcodeGenrunNode runAttributesrunAttributesRaw getPromise putPromise adjustPromisenewEmptyPromisewithLocalSplicesrenderTemplate callTemplate textSplice nodeSplice xmlNodeSplicehtmlNodeSplice pureSplice withSplicesmanyWithSplices deferManydeferMap mayDeferMap bindLater bindSplice bindSplicesrunChildrenWithrunChildrenWithTransrunChildrenWithTemplatesrunChildrenWithText lookupSplice addTemplateaddXMLTemplate stopRecursion evalTemplate bindStrings bindStringcallTemplateWithTextrenderWithArgs ignoreTag ignoreImpl HeistConfig_hcSpliceConfig _hcNamespace_hcErrorNotBound SpliceConfig_scInterpretedSplices_scLoadTimeSplices_scCompiledSplices_scAttributeSplices_scTemplateLocationsTemplateLocation TemplateRepolensscInterpretedSplicesscLoadTimeSplicesscCompiledSplicesscAttributeSplicesscTemplateLocationshcSpliceConfig hcNamespacehcErrorNotBoundhcInterpretedSpliceshcLoadTimeSpliceshcCompiledSpliceshcAttributeSpliceshcTemplateLocations$fMonoidSpliceConfigapplyTag applyAttrrawApply applyNodes applyImpldeprecatedContentCheckbindTagbindAttrbindImpl CacheTagStateclearCacheTagState cacheImplcacheImplCompiled mkCacheTaghtmlTaghtmlImpl extractHeadsNoMarkdownFileExceptionMarkdownExceptionPandocMissingException markdownTagmarkdownSplicepandocpandocBSreadProcessWithExitCode'"$fExceptionNoMarkdownFileException$fShowNoMarkdownFileException$fExceptionMarkdownException$fShowMarkdownException!$fExceptionPandocMissingException$fShowPandocMissingException ifISplice ifCSplice bindStrictTagbindStrictImplbindJsonSplicesM noSplicesmapSapplyS$$mapNames prefixSplicesnamespaceSplicesdefaultLoadTimeSplicesdefaultInterpretedSplicesemptyHeistConfig loadTemplatesreloadTemplatesaddTemplatePathPrefix initHeistinitHeistWithCacheTagTemplateDirectorynewTemplateDirectorynewTemplateDirectory'getDirectoryHSgetDirectoryCTSreloadTemplateDirectory newKeyGenKeyGenKeyHeterogeneousEnvironmentgetKeyIdemptymakeKeylookupinsertdeleteadjusttransformers-0.3.0.0Control.Monad.Trans.Classlift mtl-2.1.3.1Control.Monad.Reader.ClasslocalControl.Monad.State.Classgetsgetputmodify$fMonadContHeistT$fMonadErroreHeistT$fMonadReaderrHeistT$fMonadStatesHeistT$fMonadPlusHeistT$fAlternativeHeistT$fMonadFixHeistT$fMonadCatchIOHeistT$fMonadTransHeistT$fMonadIOHeistT $fMonadHeistT$fApplicativeHeistT$fFunctorHeistT $fShowChunk$fMonoidRuntimeSplice ParserFun heistErrMsg showTPath tpathNamesetCurTemplateFile attParser splitPathWithsplitLocalPathsplitTemplatePathlookupTemplateghc-prim GHC.TypesTrue singleLookup traversePath loadTemplate loadTemplate' getDocWith setTemplatesinsertTemplate addDoctype runHashMaprunMapNoErrors setCurContextmimeType pureTextChunkrunDocumentFile consolidatebytestring-0.10.4.0Data.ByteString.Internal ByteStringsubtreeIsStatichasAttributeSubstitutions compileNodexmlhtml-0.2.3.4Text.XmlHtml.CommonNodemanyWithrenderFragmentcompileTemplatecompileTemplatescompileTemplates' parseAttrs parseAttrparseAtt parseAtt2 attrToChunk attrToBuildergetAttributeSplicegetAttributeSplice2 interpret text-1.2.0.4Data.Text.InternalText runAttrSpliceattSubstmAX_RECURSION_DEPTH recurseSplice lookupAndRun fixDocTypeDocumentevalWithDoctypesblaze-builder-0.3.3.4'Blaze.ByteString.Builder.Internal.TypesBuilderparseTTL generateIdgetId setupSpliceCTS cacheTagNameaddCompiledRefgetTTL JsonMonad errorMessage withValue boolToText numToTextfindExprasHtml snippetTagvalueTag explodeTagmap-syntax-0.2Data.Map.SyntaxmapVmapK runMapSyntax' runMapSyntaxrunMap#?#!##addStratReplaceIgnoreErrorDupStratirValirKeyirStratItemRep MapSyntaxM MapSyntaxemptyHSpreproc preprocess allErrorsmkSplicePrefix initHeist'leftPass