anchor.diff:  receive_chunk({'DOWN', _, _, _, _Reason}, _State) ->
       error(incomplete);
   receive_chunk({gun_data, _Pid, StreamRef, IsFin, Data}, State) ->
  -    manage_chunk(IsFin, StreamRef, Data, State);
  +    NewState = manage_chunk(IsFin, StreamRef, Data, State),
  +    case IsFin of
  +        fin ->
  +            {next_state, at_rest, NewState};
  +        nofin ->
  +            {next_state, receive_chunk, NewState}
  +    end;
   receive_chunk({gun_error, _Pid, _StreamRef, _Reason}, State) ->
       {next_state, at_rest, State}.
   
  
positive.code:     base64:encode(Username ++ [$: | Password]).
  
  %% @private
  sse_events(Data, State = #{buffer := Buffer}) ->
      NewBuffer = <<Buffer/binary, Data/binary>>,
      DataList = binary:split(NewBuffer, <<"\n\n">>, [global]),
      case lists:reverse(DataList) of
          [_] ->
              {[], State#{buffer := NewBuffer}};
          [<<>> | Events] ->
              {lists:reverse(Events), State#{buffer := <<"">>}};
          [Rest | Events] ->
              {lists:reverse(Events), State#{buffer := Rest}}
      end.
  
  
negative.code:                        responses := Responses,
                         async_mode := binary}) ->
      NewResponses = queue:in({IsFin, StreamRef, Data}, Responses),
      State#{responses => NewResponses};
  manage_chunk(IsFin, StreamRef, Data,
               State = #{handle_event := undefined,
                         responses := Responses,
                         async_mode := sse}) ->
      {Events, NewState} = sse_events(IsFin, Data, State),
      FunAdd = fun(Event, Acc) ->
                       queue:in({IsFin, StreamRef, Event}, Acc)
               end,
      NewResponses = lists:foldl(FunAdd, Responses, Events),
      NewState#{responses => NewResponses};
  manage_chunk(IsFin, StreamRef, Data,
               State = #{handle_event := HandleEvent,
                         async_mode := binary}) ->
      HandleEvent(IsFin, StreamRef, Data),
      State;
  manage_chunk(IsFin, StreamRef, Data,
               State = #{handle_event := HandleEvent,
                         async_mode := sse}) ->
      {Events, NewState} = sse_events(IsFin, Data, State),
      Fun = fun (Event) -> HandleEvent(IsFin, StreamRef, Event) end,
      lists:foreach(Fun, Events),
  
      NewState.
  
  %% @private
  process_options(Options, HeadersMap, HttpVerb) ->
  