* @param dependencyScopes the dependency scopes associated with this path scope
     * @return a new PathScope instance
     */
    static PathScope pathScope(String id, ProjectScope projectScope, DependencyScope... dependencyScopes) {
        return new DefaultPathScope(id, projectScope, dependencyScopes);
    }

    /**

            DependencyScope.COMPILE_ONLY,
            DependencyScope.COMPILE,
            DependencyScope.PROVIDED);

    PathScope MAIN_RUNTIME =
            pathScope("main-runtime", ProjectScope.MAIN, DependencyScope.COMPILE, DependencyScope.RUNTIME);

    PathScope TEST_COMPILE = pathScope(
            "test-compile",
            ProjectScope.TEST,
            DependencyScope.COMPILE,
            DependencyScope.PROVIDED,

     */
    TEST_RUNTIME("test-runtime", false),

    /**
     * System scope.
     */
    SYSTEM("system", false);

    private static final Map<String, DependencyScope> IDS = Collections.unmodifiableMap(
            Stream.of(DependencyScope.values()).collect(Collectors.toMap(s -> s.id, s -> s)));

    /**
     * {@return the dependency scope for the given identifier, or {@code null} if none}.

        Collection<DependencyScope> allDependencyScopes = internalScopeManager.getDependencyScopeUniverse();
        Collection<DependencyScope> nonTransitiveDependencyScopes =
                allDependencyScopes.stream().filter(s -> !s.isTransitive()).collect(Collectors.toSet());
        DependencyScope system =
                internalScopeManager.getDependencyScope(DS_SYSTEM).orElse(null);

    }

    @Override
    public Collection<org.eclipse.aether.scope.DependencyScope> buildDependencyScopes(
            InternalScopeManager internalScopeManager) {
        ArrayList<org.eclipse.aether.scope.DependencyScope> result = new ArrayList<>();
        result.add(internalScopeManager.createDependencyScope(
                DependencyScope.COMPILE.id(), DependencyScope.COMPILE.isTransitive(), all()));

     * the {@code "Automatic-Module-Name"} attribute of the {@code META-INF/MANIFEST.MF} file if present.
     *
     * <p>A typical usage is to invoke this method for all dependencies having a
     * {@link DependencyScope#TEST TEST} or {@link DependencyScope#TEST_ONLY TEST_ONLY}
     * {@linkplain Dependency#getScope() scope}. An {@code --add-reads} option may need
     * to be generated for compiling and running the test classes that use such dependencies.</p>

    }

    private static boolean hasDependencyScope(Dependency dependency) {
        String scopeId = dependency.getScope();
        DependencyScope scope;
        if (scopeId == null || scopeId.isEmpty()) {
            scope = DependencyScope.COMPILE;
        } else {
            scope = DependencyScope.forId(scopeId);
        }
        return scope == null || !scope.isTransitive();
    }

    }

    protected DependencySelector getDependencySelector() {
        return new AndDependencySelector(
                ScopeDependencySelector.legacy(
                        null, Arrays.asList(DependencyScope.TEST.id(), DependencyScope.PROVIDED.id())),
                OptionalDependencySelector.fromDirect(),
                new ExclusionDependencySelector());
    }

    public static final String SCOPE_COMPILE = DependencyScope.COMPILE.id();
    public static final String SCOPE_RUNTIME = DependencyScope.RUNTIME.id();
    public static final String SCOPE_TEST_ONLY = DependencyScope.TEST_ONLY.id();
    public static final String SCOPE_TEST = DependencyScope.TEST.id();

    private final List<LifecycleProvider> providers;

import java.util.Objects;
import java.util.Optional;
import java.util.stream.Stream;

import org.apache.maven.RepositoryUtils;
import org.apache.maven.api.DependencyCoordinates;
import org.apache.maven.api.DependencyScope;
import org.apache.maven.api.Exclusion;
import org.apache.maven.api.Packaging;
import org.apache.maven.api.ProducedArtifact;
import org.apache.maven.api.Project;
import org.apache.maven.api.Type;