for (String line :
                            reader.lines().filter(l -> !l.startsWith("#")).collect(Collectors.toList())) {
                        Class<?> clazz = classLoader.loadClass(line);
                        bindImplicit(clazz);
                    }
                }
            }
        } catch (Exception e) {

                    .map(Node::getDependency)
                    .filter(Objects::nonNull)
                    .map(Artifact::toCoordinate)
                    .collect(Collectors.toList());
            Predicate<PathType> filter = request.getPathTypeFilter();
            if (request.getRequestType() == DependencyResolverRequest.RequestType.FLATTEN) {

            result.setActivePomProfiles(
                    modelId, activePomProfiles.stream().map(Profile::new).collect(Collectors.toList()));
            modelv4 = profileInjector.injectProfiles(modelv4, activePomProfiles, request, problems);
            if (currentData == resultData) {
                for (Profile activeProfile : activeExternalProfiles) {

        this.setThreadSafe(true);
        this.setImplementation(md.getImplementation());
        try {
            this.setParameters(md.getParameters().stream().map(Parameter::new).collect(Collectors.toList()));
        } catch (DuplicateParameterException e) {
            throw new IllegalArgumentException(e);
        }
        this.mojoDescriptorV4 = md;
        this.v4Api = true;
    }

                .peek(l -> Objects.requireNonNull(l.getId(), "A lifecycle must have an id."))
                .sorted(Comparator.comparing(Lifecycle::getId, comparator))
                .collect(Collectors.toList());
    }

    private Map<String, Lifecycle> lookupLifecycles() {
        // TODO: Remove the following code when maven-compat is gone

                        }
                        List<Class<?>> nonInterfaces =
                                Stream.of(value).filter(c -> !c.isInterface()).collect(Collectors.toList());
                        if (!nonInterfaces.isEmpty()) {
                            throw new IllegalArgumentException(

                Session iSessionWithRepos = iSession.withRemoteRepositories(request.getRepositories().stream()
                        .map(iSession::getRemoteRepository)
                        .toList());
                String gav =
                        pomArtifact.getGroupId() + ":" + pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion();
                ModelResolver modelResolver = new DefaultModelResolver();

            return Collections.emptyList();
        }
        return Arrays.stream(excludes.split(","))
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .collect(Collectors.toList());
    }

    private ValidationReportLevel validationReportLevel(RepositorySystemSession session) {
        return (ValidationReportLevel) session.getData()

            return result.getArtifactResults().stream()
                    .filter(ArtifactResult::isResolved)
                    .map(ArtifactResult::getArtifact)
                    .collect(Collectors.toList());
        } catch (PluginResolutionException | InterpolationException e) {
            throw new ExtensionResolutionException(extension, e);
        }
    }

        List<RemoteRepository> repositories = profile.getRepositories().stream()
                .map(repositoryFactory::createRemote)
                .toList();
        InternalSession s = (InternalSession) session.withRemoteRepositories(repositories);
        InternalSession.associate(rsession, s);
        return s;