anchor.diff:              parse1(State, Rest, [{Mark, Tag, lists:reverse(Result1)} | Result0]);
           _ ->
               error(?PARSE_ERROR)
  +    end.
  +
  +%% @doc Partial part of the `parse/1'
  +-spec parse_jump(state(), Tag :: binary(), NextBin :: binary(), Result :: [tag()]) -> [tag()] | partial().
  +parse_jump(#state{dirname = Dirname} = State0, Tag, NextBin, Result0) ->
  +    Filename = filename:join(?COND(Dirname =:= <<>>, [Tag], [Dirname, Tag])),
  +    case file:read_file(Filename) of
  +        {ok, Bin} ->
  +            case parse1(State0, Bin, Result0) of
  +                {partial, _}    -> error(?PARSE_ERROR);
  +                {State, Result} -> parse1(State, NextBin, Result)
  +            end;
  +        _ ->
  +            error(?FILE_ERROR, [Filename])
       end.
   
   %% @doc Update delimiter part of the `parse/1'
  
positive.code:           data :: [tag()]
          }).
  
  -type template() :: #?MODULE{}.
  -type data()     :: #{string() => data() | iodata() | fun((data(), function()) -> iodata())}.
  
  %%----------------------------------------------------------------------------------------------------------------------
  
negative.code: parse(State, Bin) ->
      case parse1(State, Bin, []) of
          {partial, _} -> error(?PARSE_ERROR);
          {_, Tags}    -> lists:reverse(Tags)
      end.
  
  %% @doc Part of the `parse/1'
  %%
  %% ATTENTION: The result is a list that is inverted.
  -spec parse1(state(), Input :: binary(), Result :: [tag()]) -> {state(), [tag()]} | partial().
  parse1(#state{start = Start, stop = Stop} = State, Bin, Result) ->
      case binary:split(Bin, Start) of
          []                       -> {State, Result};
          [B1]                     -> {State, [B1 | Result]};
          [B1, <<"{", B2/binary>>] -> parse2(State, binary:split(B2, <<"}", Stop/binary>>), [B1 | Result]);
          [B1, B2]                 -> parse3(State, binary:split(B2, Stop),                 [B1 | Result])
      end.
  