return repositories;
    }

    @Override
    public Mirror getMirror(ArtifactRepository repository, List<Mirror> mirrors) {
        return null;
    }

    @Override
    public void injectAuthentication(List<ArtifactRepository> repositories, List<Server> servers) {}

    @Override
    public void injectMirror(List<ArtifactRepository> repositories, List<Mirror> mirrors) {}

    @Override

            if (mirrors) {
                repositorySystem.injectMirror(session, repositories);
            }

            repositorySystem.injectProxy(session, repositories);

            repositorySystem.injectAuthentication(session, repositories);
        }

        return repository;
    }

    private boolean isLocalRepository(ArtifactRepository repository) {

        repositorySystem.injectMirror(request.getRepositorySession(), internalRepositories);

        repositorySystem.injectProxy(request.getRepositorySession(), internalRepositories);

        repositorySystem.injectAuthentication(request.getRepositorySession(), internalRepositories);

        List<ArtifactRepository> dominantRepositories;
        List<ArtifactRepository> recessiveRepositories;

                        repositorySystem.injectProxy(request.getRepositorySession(), Arrays.asList(repo));
                        repositorySystem.injectAuthentication(request.getRepositorySession(), Arrays.asList(repo));
                        repos.add(repo);
                    } catch (InvalidRepositoryException e) {

                repository.setLayout(getLayout(mirror.getLayout()));
            }

            repository.setBlocked(mirror.isBlocked());
        }
    }

    @Override
    public void injectAuthentication(List<ArtifactRepository> repositories, List<Server> servers) {
        if (repositories != null) {
            Map<String, Server> serversById = new HashMap<>();

            if (servers != null) {

            }
        }
        mavenRepositorySystem.injectMirror(repositorySession, pomRepositories);
        mavenRepositorySystem.injectProxy(repositorySession, pomRepositories);
        mavenRepositorySystem.injectAuthentication(repositorySession, pomRepositories);
        return pomRepositories;
    }

    private boolean hasFile(Artifact artifact) {
        return artifact != null
                && artifact.getFile() != null

                                new org.apache.maven.model.DeploymentRepository(r));
                        repositorySystem.injectProxy(request.getRepositorySession(), List.of(repo));
                        repositorySystem.injectAuthentication(request.getRepositorySession(), List.of(repo));
                        project.setReleaseArtifactRepository(repo);
                    }
                } catch (InvalidRepositoryException e) {

                    authCtx.close();
                    return result;
                }
            }
        }
        return null;
    }

    public void injectAuthentication(RepositorySystemSession session, List<ArtifactRepository> repositories) {
        if (repositories != null && session != null) {
            for (ArtifactRepository repository : repositories) {