*/
    protected void parseTextContent(final Node node, final StringBuilder buf) {
        if (node.hasChildNodes()) {
            final NodeList nodeList = node.getChildNodes();
            for (int i = 0; i < nodeList.getLength(); i++) {
                final Node childNode = nodeList.item(i);
                parseTextContent(childNode, buf);
            }
        } else if (node.getNodeType() == Node.TEXT_NODE) {

                    value = Arrays.stream((String[]) value).toList();
                } else if (value instanceof List<?>) {
                    // nothing
                } else {
                    value = split(value.toString(), "\n")
                            .get(stream -> stream.filter(StringUtil::isNotBlank).map(String::trim).collect(Collectors.toList()));
                }

                }

                BuildPlan buildPlan = plan;
                for (BuildStep step :
                        planSteps.stream().flatMap(p -> plan.steps(p.project)).toList()) {
                    for (MojoExecution execution : step.executions().toList()) {
                        buildPlan = computeForkPlan(step, execution, buildPlan);
                    }
                }

                for (BuildStep step : planSteps) {

                        .repositories(repositories.stream()
                                .map(RepositoryUtils::toRepo)
                                .map(session::getRemoteRepository)
                                .toList())
                        .coordinates(List.of(coordinates))
                        .build();
                ArtifactResolverResult res =
                        session.getService(ArtifactResolver.class).resolve(req);

                    .stream()
                    .filter(e -> (now - e.getValue().getExpiration()) / 1000L > getStateTtl())
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList())
                    .forEach(s -> {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Removing old state: {}", s);
                        }

    private List<String> getSourceRootDirs(ProjectScope scope, Language language) {
        return getEnabledSourceRoots(scope, language)
                .map((source) -> source.directory().toString())
                .toList();
    }

    /**
     * @deprecated Replaced by {@code getEnabledSourceRoots(ProjectScope.MAIN, Language.JAVA_FAMILY)}.
     */
    @Deprecated(since = "4.0.0")

                            }
                        });
                        final List<String> newGroupList = stream(user.getGroupNames()).get(stream -> stream.collect(Collectors.toList()));
                        stream(user.getGroupNames()).of(stream -> stream.forEach(name -> {
                            if (oldGroupList.contains(name)) {
                                oldGroupList.remove(name);

    }

    private ImmutableList<FluentFuture<?>> inputFutures() {
      return FluentIterable.from(inputs)
          .<FluentFuture<?>>transform(future -> future.future)
          .toList();
    }
  }

  /**
   * A generic {@link Combiner} that lets you use a lambda or method reference to combine two {@link