anchor.diff:  
   %% @doc Embed the data in the template.
   -spec compile(template(), data()) -> binary().
  -compile(#?MODULE{data = Tags} = T, Data) ->
  +compile(T, Data) ->
  +    compile(T, Data, []).
  +
  +%% @doc Embed the data in the template.
  +-spec compile(template(), data(), options()) -> binary().
  +compile(#?MODULE{data = Tags} = T, Data, Options) ->
       case check_data_type(Data) of
           false -> error(function_clause, [T, Data]);
  -        _     -> iolist_to_binary(lists:reverse(compile_impl(Tags, Data, [])))
  +        _     -> iolist_to_binary(lists:reverse(compile_impl(Tags, Data, [], Options)))
       end.
   
   %%----------------------------------------------------------------------------------------------------------------------
  
positive.code: %% @equiv compile(parse_binary(Bin), Data)
  -spec render(binary(), data()) -> binary().
  render(Bin, Data) ->
      compile(parse_binary(Bin), Data).
  
  %% @doc Create a {@link template/0} from a binary.
  -spec parse_binary(binary()) -> template().
  
negative.code: %% @doc {@link compile/2}
  %%
  %% ATTENTION: The result is a list that is inverted.
  -spec compile_impl(Template :: [tag()], data(), Result :: iodata(), Options :: options()) -> iodata().
  compile_impl([], _, Result, _) ->
      Result;
  compile_impl([{n, Key} | T], Map, Result, Options) ->
      compile_impl(T, Map, [escape(to_binary(data_get(binary_to_list(Key), Map, <<>>, Options))) | Result], Options);
  compile_impl([{'&', Key} | T], Map, Result, Options) ->
      compile_impl(T, Map, [to_binary(data_get(binary_to_list(Key), Map, <<>>, Options)) | Result], Options);
  compile_impl([{'#', Key, Tags, Source} | T], Map, Result, Options) ->
      Value = data_get(binary_to_list(Key), Map, undefined, Options),
      case check_data_type(Value) of
          true                                        -> compile_impl(T, Map, compile_impl(Tags, Value, Result, Options), Options);
          _ when is_list(Value)                       -> compile_impl(T, Map, lists:foldl(fun(X, Acc) -> compile_impl(Tags, X, Acc, Options) end,
                                                                                          Result, Value), Options);
          _ when Value =:= false; Value =:= undefined -> compile_impl(T, Map, Result, Options);
          _ when is_function(Value, 2)                -> compile_impl(T, Map, [Value(Source, fun(Text) -> render(Text, Map) end) | Result], Options);
          _                                           -> compile_impl(T, Map, compile_impl(Tags, Map, Result, Options), Options)
      end;
  compile_impl([{'^', Key, Tags} | T], Map, Result, Options) ->
      Value = data_get(binary_to_list(Key), Map, undefined, Options),
      case Value =:= undefined orelse Value =:= [] orelse Value =:= false of
          true  -> compile_impl(T, Map, compile_impl(Tags, Map, Result, Options), Options);
          false -> compile_impl(T, Map, Result, Options)
      end;
  compile_impl([Bin | T], Map, Result, Options) ->
      compile_impl(T, Map, [Bin | Result], Options).
  
  %% @see parse_binary/1
  -spec parse_binary_impl(state(), Input :: binary()) -> template().
  