W      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None 1;=>?KQUVGVIf you use two different KeyGens to work with the same map, you deserve what you get. None1;=>?CFKTUVat?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.Stack of the splices used.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.Exception type for splice compile errors. Wraps the original exception and provides context. data (Exception e) => CompileException e = CompileException*Detailed information about a splice error.%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.'output known at load time(output computed at run time),runtime action used only for its side-effect*(Monad used for runtime splice execution.-?Designates whether a document should be treated as XML or HTML.0*Holds data about templates read from disk.4^Reversed list of directories. This holds the path to the template currently being processed.5;MIME Type. The type alias is here to make the API clearer.6A 6 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.7"Convenient type alies for splices.:1Transform a SpliceError record to a Text message.;<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.>CGets the names of all the compiled splices defined in a HeistState.?DEvaluates a template monad as a computation in the underlying monad.@Helper for MonadError instance.AHelper for MonadCont instance.B(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".C HeistT's .D HeistT's gets.E HeistT's .F HeistT's .G HeistT's modify.HRestores the HeistState. This function is almost like putHS except it preserves the current doctypes and splice errors. 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.IZAbstracts the common pattern of running a HeistT computation with a modified heist state.JModifies the recursion depth.K#Increments the namespaced tag countMonadCont passthrough instanceMonadError passthrough instance MonadReader passthrough instanceMonadState passthrough instanceMonadPlus passthrough instance Alternative passthrough instance MonadFix passthrough instance MonadTrans instance MonadIO instance Monad instance Applicative instanceFunctor instanceM $#"! %&)('*+,-./0132456789:;<=>?@ABCDEFGHIJKL   !"#$&'()*+,-./0123None 1;=>?KUVType synonym for parsers.MIf 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.N>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.OReturns 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.PMaps 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 nQGets the current contextRGets 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.S!Reads an HTML template from disk.T Reads an XML template from disk.%Sets the templateMap in a HeistState. #Adds a template to the heist state.U0Binds a set of new splice declarations within a .! Mappends a doctype to the state.PSplice generating function%List of items to generate splices for0The result of all splices concatenated together.path of the template root+full file path (includes the template root)Usplices to bind start state "#$MN%OPQRST &U!None 1;=>?KUV*VqPromises are used for referencing the results of future runtime computations during load time splice processing.W9A 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 us 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.X%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.YDYields a pure Builder known at load time. You should use this and \d as much as possible to maximize the parts of your page that can be compiled to static ByteStrings.Z/Yields a runtime action that returns a builder.[VYields a runtime action that returns no value and is only needed for its side effect.\VA convenience wrapper around yieldPure for working with Text. Roughly equivalent to j from Heist.Interpreted.]GConvenience wrapper around yieldRuntime allowing you to work with Text.^_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._BGiven a list of output chunks, codeGen turns consecutive runs of  Pure Html6 values into maximally-efficient pre-rendered strict * chunks.+-Looks up a splice in the compiled splice map.`Runs 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.aPerforms 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.bPerforms 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.c2Gets the result of a promised runtime computation.d-Adds a promise to the runtime splice context.eModifies a promise.fCreates an empty promise.0?Binds a compiled splice. This function should not be exported.1HBinds a list of compiled splices. This function should not be exported.gAdds 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.h`Looks up a compiled template and returns a runtime monad computation that constructs a builder.?Note that template names should not include the .tpl extension: renderTemplate hs "index"i;Looks up a compiled template and returns a compiled splice.jGConverts a pure text splice function to a pure Builder splice function.k%This is the same as htmlNodeSplice. lLConverts a pure XML Node splice function to a pure Builder splice function.mMConverts a pure HTML Node splice function to a pure Builder splice function.n[Converts a pure Builder splice function into a monadic splice function of a RuntimeSplice.o^Runs a splice, but first binds splices given by splice functions that need some runtime data.pgLike withSplices, but evaluates the splice repeatedly for each element in a list generated at runtime.qVMore powerful version of manyWithSplices that lets you also define attribute splices.r Similar to P in interpreted mode. Gets a runtime list of items and applies a compiled runtime splice function to each element of the list.s0Saves the results of a runtime computation in a V8 so they don't get recalculated if used more than once.uNote that this is just a specialized version of function application ($) done for the side effect in runtime splice.tAA version of defer which applies a function on the runtime value.uLike 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.v[Converts an RuntimeSplice into a Splice, given a helper function that generates a Builder.aList of attributesbList of attributes0tag name splice action source state1splices to bind source stateoSplice to be runSplices to be bound first(Runtime data needed by the above splices:V2WX3'YZ[\]^(4567)_+`89,-.:;ab<=>?cdef01ghi@jklmnoApqrstuvV2None 1;=>?KUVnVcdefVfcdeNone 1;=>?KUV&WXYZ[\]^_`abghijklmnopqrstuvWh_XjklmnrstuvopqgYZ[\]^`abiNone 1;=>?KUV86x6Binds a new splice declaration to a tag name within a .y0Binds a set of new splice declarations within a .z Converts B to a splice returning a single TextNode.{Runs 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.|QBinds a list of splices before using the children of the spliced node as a view.}Wrapper around runChildrenWith that applies a transformation function to the second item in each of the tuples before calling runChildrenWith.~OLike runChildrenWith but using constant templates rather than dynamic splices.HLike runChildrenWith but using literal text rather than dynamic splices.-Convenience function for looking up a splice.0Adds an HTML format template to the heist state./Adds an XML format template to the heist state.LStops 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.,Performs splice processing on a single node.Performs 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.CSRuns the attribute splice if it exists, otherwise it does inline $() substitution.DMHelper function for substituting a parsed attribute into an attribute tuple.EZParses an attribute for any identifier expressions and performs appropriate substitution.FGets 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"..Performs splice processing on a list of nodes.G?The maximum recursion depth. (Used to prevent infinite loops.)HChecks the recursion flag and recurses accordingly. Does not recurse deeper than mAX_RECURSION_DEPTH to avoid infinite loops.I Looks up a template name runs a  computation on it.=Looks up a template name evaluates it by calling runNodeList.JSets the document type of a K based on the  value.LsRuns a template and sets the doctype properly. This is the right thing to do if we are starting at the top level.(Binds a list of constant string splices.&Binds a single constant string splice.Renders 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.LLike callTemplate except the splices being bound are constant text splices.6Renders a template from the specified HeistState to a M. 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.?Note that template names should not include the .tpl extension: renderTemplate hs "index"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.xtag name splice action source stateysplices to bind start state|7List of splices to bind before running the param nodes.Returns the passed in view.}Splice generating functionList of tuples to be bound,Path that the template will be referenced byThe template's DOM nodesIAn optional path to the actual file on disk where the template is stored,Path that the template will be referenced byThe template's DOM nodesIAn optional path to the actual file on disk where the template is storedThe name of the template!Splices to call the template withThe name of the template!Splices to call the template with!wxyz{|}~CDEFGHIJLNone 1;=>?KUV9KPUwxyz{|}~wxyUz{|}~PNone 1;=>?KUVdSplices 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.Predicate function to control which templates to compile. Using templates filtered out with this is still possible via callTemplate.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]RLens for compiled template filter :: Simple Lens (SpliceConfig m) (TBool -> Bool)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]RLens for compiled template filter :: Simple Lens (SpliceConfig m) (TBool -> Bool)l  !"#$%&'()*+,-/.0123456789:;<=>?@ABCDEFGHIJKLn76540123-./*+,&'()89% !"#$: ;<=>?@ABCDEFGHIJKLNone 1;=>?KUVp"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 1;=>?KUVs,!Default name for the bind splice.(Default attribute name for the bind tag."Implementation of the bind splice.None 1;=>?KUVt!Default name for the bind splice."Implementation of the bind splice. None 1;=>?KUVH 'State for storing cache tag informationClears the cache tag state.N8Converts 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.O?Explicit type signature to avoid the Show polymorphism problem.P+Gets a unique ID for use in the cache tags.QEA splice that sets the id attribute so that nodes can be cache-aware.R None 1;=>?KUVnName 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 1;=>?KUV#Default name for the ignore splice.NThe ignore tag and everything it surrounds disappears in the rendered output. None 1;=>?KUVThis 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 None"#1;=>?KUV SArguments to pandocT;Base directory for input files defaults to template pathUWrap content in div with classDefault optionsName of pandoc executableArguments passed to pandoc@Base directory for input files, defaults to current template dirtWrap pandoc output in div with class. Appends node attributes to div and appends class to ones specified on node.%Default name for the markdown splice.0Default markdown splice with executable "pandoc"&Implementation of the markdown splice.Vcommand to run any argumentsstandard inputexitcode, stdout, stderrWXSTUYZ[None 1;=>?KUVRRun 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.Implements an if/then/else conditional splice. It splits its children around the <else/> element to get the markup to be used for the two cases.Implements an if/then/else conditional splice. It splits its children around the <else/> element to get the markup to be used for the two cases.'None1;=>?KNUV/ 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.^7Processes 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.H !"#$%&*01234567:;<=>?BCDEFGHIMNOQRSTH6450123%*& !"#$;<O=>?BQRCDEFGHISTN:M7None 1;=>?KUV,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._Prepends an error onto a Left.`a !"#$%&'()*+,--./00123456789:;;<=>?@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~fygopmxw            !"#$%&'()*+,-./0123456789:;e<=>?@ABCDEFGHIJKLMNOCGPQRS9:TU3VW X Y Z [ \ ] ^ _ `  a   bcdef heist-1.1-1fdRVoilYFWBHemfNzbPqRHeist.Internal.TypesHeistHeist.InterpretedHeist.Compiled.LowLevelHeist.CompiledHeist.Splices.ApplyHeist.Splices.BindHeist.Splices.BindStrictHeist.Splices.CacheHeist.Splices.HtmlHeist.Splices.IgnoreHeist.Splices.JsonHeist.Splices.Markdown Heist.SplicesHeist.TemplateDirectoryData.HeterogeneousEnvironmentHeist.Internal.Types.HeistState Heist.CommonHeist.Compiled.InternalHeist.Interpreted.InternalAttASTLiteralIdentHeistT runHeistT HeistState _spliceMap _templateMap_compiledSpliceMap_compiledTemplateMap_attrSpliceMap_recurse _curContext _splicePath_recursionDepth _doctypes_curTemplateFile_keygen_preprocessingMode _curMarkup _splicePrefix _spliceErrors_errorNotBound_numNamespacedTagsCompileExceptionoriginalExceptionexceptionContext SpliceError spliceHistoryspliceTemplateFilevisibleSplices contextNode spliceMsg AttrSpliceChunkPure RuntimeHtml RuntimeAction RuntimeSpliceunRTMarkupXmlHtml DocumentFiledfDocdfFileTPathMIMETypeTemplateSplices showChunk isPureChunkspliceErrorText templateNamescompiledTemplateNames spliceNamescompiledSpliceNames evalHeistT _liftCatch _liftCallCC getParamNodelocalParamNodegetsHSgetHSputHSmodifyHS restoreHSlocalHSmodRecursionDepthincNamespacedTagsisIdentorErrortellSpliceError hasTemplate mapSplices getContextgetTemplateFilePathgetDoc getXMLDocbindAttributeSplicesPromiseSplice runChildren yieldPure yieldRuntimeyieldRuntimeEffect yieldPureTextyieldRuntimeText runNodeListcodeGenrunNode runAttributesrunAttributesRaw getPromise putPromise adjustPromisenewEmptyPromisewithLocalSplicesrenderTemplate callTemplate textSplice nodeSplice xmlNodeSplicehtmlNodeSplice pureSplice withSplicesmanyWithSplicesmanyWith deferManydeferdeferMap mayDeferMap bindLater bindSplice bindSplicesrunChildrenWithrunChildrenWithTransrunChildrenWithTemplatesrunChildrenWithText lookupSplice addTemplateaddXMLTemplate stopRecursion evalTemplate bindStrings bindStringcallTemplateWithTextrenderWithArgsrenderTemplateToDoc HeistConfig_hcSpliceConfig _hcNamespace_hcErrorNotBound SpliceConfig_scInterpretedSplices_scLoadTimeSplices_scCompiledSplices_scAttributeSplices_scTemplateLocations_scCompiledTemplateFilterTemplateLocation TemplateRepolensscInterpretedSplicesscLoadTimeSplicesscCompiledSplicesscAttributeSplicesscTemplateLocationsscCompiledTemplateFilterhcSpliceConfig hcNamespacehcErrorNotBoundhcInterpretedSpliceshcLoadTimeSpliceshcCompiledSpliceshcAttributeSpliceshcTemplateLocationshcCompiledTemplateFilter$fMonoidSpliceConfig$fSemigroupSpliceConfigapplyTag applyAttrrawApply applyNodes applyImpldeprecatedContentCheckbindTagbindAttrbindImpl bindStrictTagbindStrictImpl CacheTagStateclearCacheTagState cacheImplcacheImplCompiled mkCacheTaghtmlTaghtmlImpl extractHeads ignoreTag ignoreImplbindJson PandocOptionsNoMarkdownFileExceptionMarkdownExceptionPandocMissingExceptiondefaultPandocOptionssetPandocExecutable setPandocArgssetPandocBaseDirsetPandocWrapDivpandocExecutable pandocArgs pandocBaseDir pandocWrapDiv markdownTagmarkdownSplice pandocSplice!$fExceptionPandocMissingException$fShowPandocMissingException$fExceptionMarkdownException$fShowMarkdownException"$fExceptionNoMarkdownFileException$fShowNoMarkdownFileException$fEqPandocOptions$fOrdPandocOptions$fShowPandocOptions ifISplice ifCSplice ifElseISplice ifElseCSplicedefaultLoadTimeSplicesdefaultInterpretedSplicesemptyHeistConfig loadTemplatesreloadTemplatesaddTemplatePathPrefix initHeistinitHeistWithCacheTagTemplateDirectorynewTemplateDirectorynewTemplateDirectory'getDirectoryHSgetDirectoryCTSreloadTemplateDirectory newKeyGenKeyGenKeyHeterogeneousEnvironmentgetKeyIdemptymakeKeylookupinsertdeleteadjusttransformers-0.5.2.0Control.Monad.Trans.Classlift mtl-2.2.1-DscMMmDQUE6GBfOSl4qMUHControl.Monad.Reader.ClasslocalControl.Monad.State.Classgetput$fMonadContHeistT$fMonadErroreHeistT$fMonadReaderrHeistT$fMonadStatesHeistT$fMonadPlusHeistT$fAlternativeHeistT$fMonadFixHeistT$fMonadTransHeistT$fMonadIOHeistT $fMonadHeistT$fApplicativeHeistT$fFunctorHeistT ParserFun heistErrMsg showTPath tpathNamesetCurTemplateFile attParser splitPathWithsplitLocalPathsplitTemplatePathlookupTemplateghc-prim GHC.TypesTrue singleLookup traversePath loadTemplate loadTemplate' getDocWith setTemplatesinsertTemplate addDoctype runHashMaprunMapNoErrorsapplySpliceMap setCurContextmimeType pureTextChunkrunDocumentFile consolidatebytestring-0.10.8.2Data.ByteString.Internal ByteStringsubtreeIsStatichasAttributeSubstitutions compileNode&xmlhtml-0.2.5.2-9DxjGPF2zKF3MQWvRAf9CXText.XmlHtml.CommonNoderenderFragmentcompileTemplatecompileTemplatesnoNamespaceSplicesMsgcompileTemplates' parseAttrs parseAttrparseAtt parseAtt2 attrToChunk attrToBuildergetAttributeSplicegetAttributeSplice2 interpretfoldMapM#text-1.2.2.2-EakMpasry3jA6OIwSZhq9MData.Text.InternalText runAttrSpliceattSubstmAX_RECURSION_DEPTH recurseSplice lookupAndRun fixDocTypeDocumentevalWithDoctypes Data.ByteString.Builder.InternalBuilderparseTTL generateIdgetId setupSpliceCTS _pandocArgs_pandocBaseDir_pandocWrapDivreadProcessWithExitCode'_pandocExecutableemptyHSpreproc preprocessleftPass