*/
    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**

     *
     * @param node the dependency node
     * @param dep the dependency for the given node, or {@code null} if none
     * @param filter filter the paths accepted by the tool which will consume the path.
     * @param path the path to the dependency, or {@code null} if the dependency was null
     * @param cache cache of module information about each dependency

@Named
@Singleton
public class DefaultDependencyResolver implements DependencyResolver {

    @Override
    public List<Node> flatten(Session s, Node node, PathScope scope) throws DependencyResolverException {
        InternalSession session = InternalSession.from(s);
        DependencyNode root = cast(AbstractNode.class, node, "node").getDependencyNode();
        List<DependencyNode> dependencies = session.getRepositorySystem()

    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node) {
        return getNode(node, false);
    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose) {
        return allNodes.computeIfAbsent(node, n -> new DefaultNode(this, n, verbose));
    }

    @Nonnull
    @Override

        depRequest.setTrace(trace);

        DependencyNode node;
        try {
            collect.setTrace(RequestTrace.newChild(trace, depRequest));
            node = repoSystem.collectDependencies(session, collect).getRoot();
            result.setDependencyGraph(node);
        } catch (DependencyCollectionException e) {
            result.setDependencyGraph(e.getResult().getRoot());

import org.apache.maven.internal.xml.XmlNodeImpl;

/**
 * An attribute iterator for JXPath to support <code>Xpp3Dom</code>.
 *
 */
class Xpp3DomAttributeIterator implements NodeIterator {

    private NodePointer parent;

    private XmlNodeImpl node;

    private List<Map.Entry<String, String>> attributes;

    private Map.Entry<String, String> attribute;

    private int position;

    /**
     * Returns the file paths of all dependencies, dispatched according the tool options where to place them.
     * The {@link PathType} keys identify, for example, {@code --class-path} or {@code --module-path} options.
     * In the case of Java tools, the map may also contain {@code --patch-module} options, which are
     * {@linkplain org.apache.maven.api.JavaPathType#patchModule(String) handled in a special way}.
     *
     * <p><b>Design note:</b>

import org.apache.maven.api.xml.XmlNode;

/**
 * A node pointer for JXPath to support <code>Xpp3Dom</code>.
 *
 */
class Xpp3DomNodePointer extends NodePointer {

    private XmlNode node;

    public Xpp3DomNodePointer(XmlNode node) {
        super(null);
        this.node = node;
    }

    public Xpp3DomNodePointer(NodePointer parent, XmlNode node) {
        super(parent);
        this.node = node;
    }

import org.apache.maven.api.Dependency;
import org.apache.maven.api.Node;
import org.apache.maven.api.RemoteRepository;
import org.apache.maven.api.annotations.Nonnull;
import org.eclipse.aether.graph.DependencyNode;

class WrapperNode extends AbstractNode {
    protected final Node delegate;
    protected final List<Node> children;

    WrapperNode(Node delegate, List<Node> children) {
        this.delegate = delegate;

        this();
        this.metadata = metadata;
    }

    public MetadataGraphNode addIncident(MetadataGraphNode node) {
        inNodes.add(node);
        return this;
    }

    public MetadataGraphNode addExident(MetadataGraphNode node) {
        exNodes.add(node);
        return this;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {