List<Binding<Q>> bindingList = new ArrayList<>(res);
                    Comparator<Binding<Q>> comparing = Comparator.comparing(Binding::getPriority);
                    bindingList.sort(comparing.reversed());
                    Binding<Q> binding = bindingList.get(0);
                    return compile(binding);
                }
                if (key.getRawType() == List.class) {

/**
 * ProjectSorter
 */
public class ProjectSorter {
    private Graph graph;

    private List<MavenProject> sortedProjects;

    private Map<String, MavenProject> projectMap;

    /**
     * Sort a list of projects.
     * <ul>
     * <li>collect all the vertices for the projects that we want to build.</li>
     * <li>iterate through the deps of each project and if that dep is within

    //
    // 9) Execute AbstractLifecycleParticipant.afterProjectsRead(session)
    //
    // 10) Create ProjectDependencyGraph without trimming (as trimming was done in 7). A new topological sort is
    // required after the execution of 9) as the AbstractLifecycleParticipants are free to mutate the MavenProject
    // instances, which may change dependencies which can, in turn, affect the build order.
    //

            //  or QUALIFIERS.size and then resort to lexical ordering. Most comparisons are decided by the first
            // character,
            // so this is still fast. If more characters are needed then it requires a lexical sort anyway.
            return i == -1 ? (QUALIFIERS.size() + "-" + qualifier) : String.valueOf(i);
        }

        @Override
        public int compareTo(Item item) {
            if (item == null) {

            if (exits != null && exits.size() > 0) {
                MetadataGraphEdge[] sortedExits = exits.toArray(new MetadataGraphEdge[0]);
                Arrays.sort(sortedExits, (e1, e2) -> {
                    if (e1.getDepth() == e2.getDepth()) {
                        if (e2.getPomOrder() == e1.getPomOrder()) {
                            return e1.getTarget()

                                            artifact.setAvailableVersions(versions);
                                        }

                                        Collections.sort(versions);

                                        VersionRange versionRange = artifact.getVersionRange();

                                        version = versionRange.matchVersion(versions);

                        }
                    } catch (InvalidVersionSpecificationException e) {
                        result.addException(e);
                    }
                }

                Collections.sort(versions);
                result.setVersions(versions);
            }
        }

        return result;
    }

    private Map<String, ArtifactRepository> getVersions(

        if (request.getPom() != null) {
            result = getProjectsInRequestScope(request, activeProjects);

            List<MavenProject> sortedProjects = graph.getSortedProjects();
            result.sort(comparing(sortedProjects::indexOf));

            result = includeAlsoMakeTransitively(result, request, graph);
        }

        return result;
    }

    private List<MavenProject> trimSelectedProjects(