e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		m[id] = e
	}
	return m
}

// flatten all children of the root into the root element and return it.
func (d *dataUsageCache) flatten(root dataUsageEntry) dataUsageEntry {
	for id := range root.Children {
		e := d.Cache[id]
		if len(e.Children) > 0 {
			e = d.flatten(e)
		}
		root.merge(e)
	}
	root.Children = nil

     *
     * @return the root node of the dependency graph or {@code null} if none
     */
    @Nullable
    Node getRoot();

    /**
     * The ordered list of the flattened dependency nodes.
     *
     * @return the ordered list of the flattened dependency nodes
     */
    @Nonnull
    List<Node> getNodes();

    /**

            identifiers.put(ident, method);
          }
        }
      }
    }
    return ImmutableList.copyOf(identifiers.values());
  }

  /** Global cache of classes to their flattened hierarchy of supertypes. */
  private static final LoadingCache<Class<?>, ImmutableSet<Class<?>>> flattenHierarchyCache =
      CacheBuilder.newBuilder()
          .weakKeys()
          .build(

        File f = getFileForClasspathResource("canonical-pom.xml");
        MavenProject projectToClone = getProject(f);
        projectToClone.setPomFile(new File(new File(f.getParentFile(), "target"), "flattened.xml"));
        MavenProject clonedProject = projectToClone.clone();
        assertEquals(projectToClone.getFile(), clonedProject.getFile(), "POM file is preserved across clone");
        assertEquals(

    protected String lineSeparator = "\n";

    /** Whether to extract top-level fields as metadata. */
    protected boolean extractMetadata = true;

    /** Prefix for flattened nested keys. */
    protected String nestedKeySeparator = ".";

    /** Maximum number of array elements to extract. */
    protected int maxArrayElements = 100;

    /**
     * Constructs a new JsonExtractor.

 * <p>
 * This builder applies two orthogonal transformations:
 * <ul>
 *   <li><b>Dependency Flattening</b>: When enabled via {@code maven.consumer.pom.flatten=true}, dependency management
 *       is flattened into direct dependencies for non-POM projects, and mixins are removed.</li>
 *   <li><b>Model Version Handling</b>: When {@code preserve.model.version=true} is set, the consumer POM

    /**
     * Shortcut for {@code getService(DependencyResolver.class).flatten(...)}.
     *
     * @param node node for which to get a flattened list
     * @param scope build path scope (main compile, test compile, etc.) of desired nodes
     * @return flattened list of node with the given build path scope

		}

		// 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},
		},
		{

 * 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