Composition vs Aggregation: is this a “hidden my dependencies” case?

I have been thinking about this for a while and could not get to a conclusion.
I need to convert a object to another (that will end up serialized as XML).
Both objects have many fields, let’s have an example:

SourceObject
 - String field1
 - Integer field2
 - SourceObjectChild1 field3
   - String child1Field1
   - String child1Field2
 - SourceObjectChild2 field4
   - and it goes

I need to convert it to

TargetObject
  - TargetObjectChild1
    - some fields
  - TargetObjectChild2
    - some fields
  - TargetObjectChild3
    - some fields
  - TargetObjectChild4
    - some fields

Of course the real objects are bigger than this.

Then I present 4 possible solutions. The only hard requeriment is that all classes must be unit tested.
I don’t have any need to swap nor mock implementations of the child converters.

What are the pros and cons about each approach? I’m currently using approach 1, but not feeling too confortable about creating the objects directly inside the convert method.
Are approachs 1 and 2 considered to be have hidden dependencies? Are approachs 1 and 2 (too) harmful?

1)

class TargetObjectChild1Converter {
  public TargetObjectChild1Converter(String sourceField1, SourceObjectChild1 child1) {
     // set private fields here
  }
  public TargetObjectChild1 convert() {
     // do some calculations using private fields
     return new TargetObjectChild1(...);
  }
}

class TargetObjectConverter {
   public TargetObject convert(SourceObject source) {
      var child1 = new TargetObjectChild1Converter(source.getXXX(), source.getYYY()).convert()
      var child2 = new TargetObjectChild2Converter(source.getAAA(), source.getBBB()).convert()
      // some more
      return new TargetObject(child1, child2, ...)
   }
}

class TargetObjectChild1Converter {
  public TargetObjectChild1Converter() {
  }
  public TargetObjectChild1 convert(String sourceField1, SourceObjectChild1 child1) {
     // do some calculations using parameters
     return new TargetObjectChild1(...);
  }
}

class TargetObjectConverter {
   public TargetObject convert(SourceObject source) {
      var child1 = new TargetObjectChild1Converter().convert(source.getXXX(), source.getYYY())
      var child2 = new TargetObjectChild2Converter().convert(source.getAAA(), source.getBBB())
      // some more
      return new TargetObject(child1, child2, ...)
   }
}

class TargetObjectChild1Converter {
  public TargetObjectChild1Converter() {
  }
  public TargetObjectChild1 convert(String sourceField1, SourceObjectChild1 child1) {
     // do some calculations using parameters
     return new TargetObjectChild1(...);
  }
}

class TargetObjectConverter {

  public TargetObjectConverter(TargetObjectChild1Converter converter1, TargetObjectChild2Converter converter2, ....) {
     // set privated fields here
  }

  public TargetObject convert(SourceObject source) {
      var child1 = converter1.convert(source.getXXX(), source.getYYY())
      var child2 = converter2.convert(source.getAAA(), source.getBBB())
      // some more
      return new TargetObject(child1, child2, ...)
  }
}

// I don't like this option as it is possible to child converters to access data they don't need
class TargetObjectChild1Converter {
  public TargetObjectChild1Converter {
  }
  public TargetObjectChild1 convert(SourceObject source) {
     // do some calculations using parameter
     return new TargetObjectChild1(...);
  }
}

class TargetObjectConverter {

  public TargetObjectConverter(TargetObjectChild1Converter converter1, TargetObjectChild2Converter converter2, ....) {
     // set privated fields here
  }

  public TargetObject convert(SourceObject source) {
    var child1 = converter1.convert(source)
    var child2 = converter2.convert(source)
    // some more
    return new TargetObject(child1, child2, ...)
  }
}