.map(String::trim)
                .filter(l -> !l.isEmpty() && !l.startsWith("#"))
                .filter(l -> l.startsWith("distributionUrl"))
                .findFirst()
                .orElseThrow(() -> new IllegalStateException("distributionUrl not found in " + props));

        int idx = distributionUrl.indexOf('=');
        if (idx < 0) {

        if (coreExtensions.isEmpty() || coreExtensions.get().isEmpty()) {
            return List.of();
        }

        return selectCoreExtensions(
                context, context.invokerRequest.coreExtensions().orElseThrow());
    }

    /**
     * Selects extensions to load discovered from various sources by precedence ("first wins"), as
     * {@link InvokerRequest#coreExtensions()} is in precedence order. Also reports conflicts, if any.

                        "Failed to process metadata.", e);
            }
        })
                .orElseThrow(() -> new SsoMessageException(
                        messages -> messages.addErrorsFailedToProcessSsoRequest(UserMessages.GLOBAL_PROPERTY_KEY, "Invalid state."),

        return getAvailableJavaInstallationLocationSteam().filter(installationLocation -> isSameFile(javaHome, installationLocation))
            .findFirst()
            .orElseThrow(() -> new GradleException("Could not locate available Java installation in Gradle registry at: " + javaHome));
    }

    private boolean isSameFile(File javaHome, InstallationLocation installationLocation) {
        try {

    private static final class Holder {
        static final XmlService INSTANCE = ServiceLoader.load(XmlService.class)
                .findFirst()
                .orElseThrow(() -> new IllegalStateException("No XmlService implementation found"));

        private Holder() {}
    }

            DispatcherMeta meta = secDispatcher.availableDispatchers().stream()
                    .filter(d -> Objects.equals(config.getDefaultDispatcher(), d.name()))
                    .findFirst()
                    .orElseThrow();
            if (!meta.fields().isEmpty()) {
                dispatcherConfigResult = prompt.prompt(
                        context.header,

        return Optional.ofNullable(plan.get(project)).map(m -> m.get(name));
    }

    public BuildStep requiredStep(MavenProject project, String name) {
        return step(project, name).orElseThrow(() -> new NoSuchElementException("Step " + name + " not found"));
    }

    // add a follow-up plan to this one
    public void then(BuildPlan step) {
        step.plan.forEach((k, v) -> plan.merge(k, v, this::merge));

    }
    
    private ChannelInfo selectLeastLoaded(Collection<ChannelInfo> channels) {
        return channels.stream()
            .min(Comparator.comparingLong(ChannelInfo::getRequestsPending))
            .orElseThrow();
    }
    
    private ChannelInfo selectWeightedRandom(Collection<ChannelInfo> channels) {
        // Calculate total weight
        int totalWeight = channels.stream()

            try (Stream<String> lines = Files.lines(file.toPath())) {
                String packageLine = lines.filter(line -> line.startsWith("package"))
                    .findFirst()
                    .orElseThrow(() -> new IOException("Can't find package definition in file " + file));
                Matcher matcher = pattern.matcher(packageLine);
                if (matcher.find()) {
                    return matcher.group(1);

            .entrySet()
            .stream()
            .filter(entry -> entry.getValue().contains("elastic/elasticsearch"))
            .findFirst()
            .map(Map.Entry::getKey)
            .orElseThrow(
                () -> new GradleException(
                    "I need to ensure the git tags are up-to-date, but I couldn't find a git remote for [elastic/elasticsearch]"
                )
            );