anchor.diff:  ===== With Section
   
   This section can be used to set the current context object.
  -This could be useful to simplify the template structure.
  -
  -[source]
  +This could be useful to simplify the template structure:
  +
  +[source,html]
   ----
   {#with item.parent}
  -  {name}  <1>
  +  <h1>{name}</h1>  <1>
  +  <p>{description}</p> <2>
   {/with}
   ----
  -<1> The name will be resolved against the `item.parent`.
  +<1> The `name` will be resolved against the `item.parent`.
  +<2> The `description` will be also resolved against the `item.parent`.
   
   It's also possible to specify an alias for the context object:
   
  -[source]
  -----
  -{#with item.parent as myParent}
  -  {myParent.name}
  +[source,html]
  +----
  +{#with item.parent as myParent} <1>
  +  <h1>{myParent.name}</h1>
   {/with}
   ----
  +<1> `myParent` is the alias that can be used inside the tag.
  +
  +This section might also come in handy when we'd like to avoid multiple expensive invocations:
  +
  +[source,html]
  +----
  +{#with item.callExpensiveLogicToGetTheValue(true) as it}
  +  {#if it is "fun"} <1>
  +    <h1>Yay!</h1>
  +  {#else}
  +    <h1>{it} is not fun at all!</h1>
  +  {/if}
  +{/with}
  +----
  +<1> `it` is the result of `item.callExpensiveLogicToGetTheValue(1,'foo',bazinga)`. The method is only invoked once even though the result may be used in multiple expressions.
  +
   
   [[include_helper]]
   ===== Include/Insert Sections
  
positive.code: 
  ====
  
  ===== Character Escapes
  
  For HTML and XML templates the `'`, `"`, `<`, `>`, `&` characters are escaped by default.
  
negative.code: 
  An expression consists of:
  
  * an optional namespace followed by a colon (`:`), 
  * one or more parts separated by dot (`.`).
  
  The first part of the expression is always resolved against the <<current_context_object, current context object>>.
  If no result is found for the first part it's resolved against the parent context object (if available).
  For an expression that starts with a namespace the current context object is found using all the available ``NamespaceResolver``s.
  For an expression that does not start with a namespace the current context object is *derived from the position* of the tag.
  All other parts are resolved using ``ValueResolver``s against the result of the previous resolution.
  
  For example, expression `{name}` has no namespace and single part - `name`.
  The "name" will be resolved using all available value resolvers against the current context object.
  However, the expression `{global:colors}` has the namespace `global` and single part - `colors`.
  First, all available ``NamespaceResolver``s will be used to find the current context object.
  And afterwards value resolvers will be used to resolve "colors" against the context object found. 
  
  [source]
  