}

		// Lookup remainder of path in each array element and
		// make result array.
		var result []any
		for _, a := range arr {
			rval, flatten, err := jsonpathEval(p[1:], a)
			if err != nil {
				return nil, false, err
			}

			if flatten {
				// Flatten if array.
				if arr, ok := rval.([]any); ok {
					result = append(result, arr...)
					continue
				}
			}
			result = append(result, rval)

		path       string
		isNil      bool
		size, objs int
		flatten    bool
		oSizes     sizeHistogram
	}{
		{
			path:    "/",
			size:    363515,
			flatten: true,
			objs:    14,
			oSizes:  sizeHistogram{0: 7, 1: 5, 2: 2},
		},
		{
			path:    "/dir1",
			size:    342210,
			objs:    7,
			flatten: false,
			oSizes:  sizeHistogram{0: 2, 1: 3, 2: 2},
		},
		{

) {
  val commonName: Any?
    get() {
      return tbsCertificate.subject
        .flatten()
        .firstOrNull { it.type == ObjectIdentifiers.COMMON_NAME }
        ?.value
    }

  val organizationalUnitName: Any?
    get() {
      return tbsCertificate.subject
        .flatten()
        .firstOrNull { it.type == ObjectIdentifiers.ORGANIZATIONAL_UNIT_NAME }
        ?.value
    }

 * followed by <dfn>flattening</dfn> and <dfn>resolution</dfn>.
 * The version selection is done for each dependency during the collection phase.
 * The flatten phase keeps only a single version per ({@code groupId}, {@code artifactId}) pair.
 * The resolution phase actually downloads the dependencies (or artifacts) that have been computed.
 *
 * @since 4.0.0
 */
@Experimental

            .plus(subprojectsFolder.asFile)
            .plus(testingFolder.asFile)
            .plus(packingFolder.asFile)

        return subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten()
    }

    private
    fun generateSubprojects(): List<GradleSubproject> {
        return generateSubprojectsDirectories()
            .filter {
                File(it, "build.gradle.kts").exists() ||

        mainTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { it.major }
            .map { (_, v) -> listOf(v.maxOrNull()!!.format()) }.flatten()
    }

    private
    fun VersionNumber.format() =
        // reformat according to our versioning scheme, since toString() would typically convert 1.0 to 1.0.0

    /**
     * Should upgrade plugins known to fail with Maven 4 to their minimum compatible versions.
     * This includes upgrading plugins like maven-exec-plugin, maven-enforcer-plugin,
     * flatten-maven-plugin, and maven-shade-plugin to versions that work with Maven 4.
     *
     * @return an {@link Optional} containing the boolean value {@code true} if specified, or empty
     */
    @Nonnull

					// updates-collector goroutine still
					// holds a reference to this.
					wg.Wait()
					continue
				}

				wg.Wait()
				// Flatten for upstream, but save full state.
				var root dataUsageEntry
				if r := cache.root(); r != nil {
					root = cache.flatten(*r)
				}
				select {
				case <-ctx.Done():
					return
				case bucketResults <- dataUsageEntryInfo{
					Name:   cache.Info.Name,

            // TODO: This doesn't allow adoc files to be generated?
            task.from(extension.getUserManual().getRoot(), sub -> {
                sub.include("**/*.adoc");
                // Flatten adocs into a single directory
                sub.eachFile(fcd -> fcd.setRelativePath(RelativePath.parse(true, fcd.getName())));
            });

        val subprojectRoots = File("../platforms").listFiles(File::isDirectory).plus(File("../subprojects"))
        val subProjectFolders =
            subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten().filter { dir ->
                // filter out the directories that have only a `build` subdirectory - this usually happens after branch switching