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);

    // available in the repository.
    val runRequireString =
      REQUIRED_BUNDLES.joinToString(separator = ",") {
        "osgi.identity;filter:='(osgi.identity=$it)'"
      }

    val bndEditModel =
      BndEditModel(workspace).apply {
        // Temporary project to satisfy bnd API.
        project = Project(workspace, workspaceDir.toFile())
      }

		return nil, err
	}

	if !hold.Status.Valid() {
		return nil, ErrMalformedXML
	}
	return hold, err
}

// FilterObjectLockMetadata filters object lock metadata if s3:GetObjectRetention permission is denied or if isCopy flag set.
func FilterObjectLockMetadata(metadata map[string]string, filterRetention, filterLegalHold bool) map[string]string {
	// Copy on write

        // Also verify the change is reflected in the build plugins list
        Plugin pluginFromBuildList = project.getBuild().getPlugins().stream()
                .filter(p -> "org.apache.maven.plugins:maven-compiler-plugin".equals(p.getKey()))
                .findFirst()
                .orElse(null);
        assertNotNull(pluginFromBuildList, "Plugin should be found in build plugins list");

        dependenciesToRemove.forEach { (filePath, dependencies) ->
            val file = File(filePath)
            if (!file.exists()) return@forEach

            val lines = file.readLines().filter { line -> dependencies.none { line.contains(it) } }
            file.writeText(lines.joinToString("\n"))
        }
    }

    private fun extractDependencies(startLine: Int): List<String> {

import org.apache.maven.api.services.MavenException;
import org.apache.maven.api.services.MessageBuilderFactory;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.resolver.filter.CumulativeScopeArtifactFilter;
import org.apache.maven.execution.ExecutionEvent;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.internal.MultilineMessageHelper;

                    .filter(k -> !sys.contains(k.getKey()))
                    .peek(k -> context.pushedUserProperties.add(k.getKey()))
                    .forEach(k -> System.setProperty(k.getKey(), k.getValue()));
        } else {
            protoSession.getUserProperties().entrySet().stream()

      // Delay and Defer any initialisation of Conscrypt and BouncyCastle
      DeferredSocketAdapter(ConscryptSocketAdapter.factory),
      DeferredSocketAdapter(BouncyCastleSocketAdapter.factory),
    ).filter { it.isSupported() }

  @Throws(IOException::class)
  override fun connectSocket(
    socket: Socket,
    address: InetSocketAddress,
    connectTimeout: Int,
  ) {
    try {

        if (planStep.isPresent() && planStep.get().status.get() == BuildStep.PLANNING) {
            writer.accept("Build plan will be lazily computed");
        } else {
            plan.steps(project)
                    .filter(step ->
                            step.phase != null && step.executions().findAny().isPresent())
                    .sorted(Comparator.comparingInt(plan.sortedNodes()::indexOf))
                    .forEach(step -> {

             */
            val clazz = DefaultImportsReader::class.java
            return clazz.getResource(RESOURCE)
                .readText()
                .split('\n')
                .filter { it.isNotBlank() }
                .map { line -> line.substring(7, line.length - 2) }
        }
    }