json.project.configurations[0].dependencies[0].name == "foo:baz:1.0"
        json.project.configurations[0].dependencies[0].resolvable == 'RESOLVED'
        json.project.configurations[0].dependencies[0].alreadyRendered == false
        json.project.configurations[0].dependencies[0].hasConflict == false
        json.project.configurations[0].dependencies[0].children.size() == 2

                state : "open",
                attr : {'data-module' : dependency.module},
                children : []
            };
            var classes = [];
            if (dependency.alreadyRendered) {
                classes.push('alreadyRendered');
            }
            if (dependency.hasConflict) {
                classes.push('hasConflict');
            }
            if (!dependency.resolvable) {

            map.put("resolvable", childDependency.getResolutionState());
            map.put("hasConflict", hasConflict);
            map.put("alreadyRendered", alreadyRendered);
            map.put("children", Collections.emptyList());
            if (!alreadyRendered) {
                map.put("children", createDependencyChildren(childDependency, visited));
            }
            return map;
        });
    }

import org.gradle.internal.logging.text.StyledTextOutput;

public interface NodeRenderer {
    NodeRenderer NO_OP = (output, node, alreadyRendered) -> {
    };

    void renderNode(StyledTextOutput output, RenderableDependency node, boolean alreadyRendered);

            return;
        }

        final boolean alreadyRendered = !visited.add(node.getId());
        if (alreadyRendered) {
            legendRenderer.setHasCyclicDependencies(true);
        }

        renderNode(node, last, alreadyRendered, dependenciesRenderer);

        if (!alreadyRendered) {
            Set<? extends RenderableDependency> children = node.getChildren();

    public void renderNode(StyledTextOutput output, RenderableDependency node, boolean alreadyRendered) {
        output.text(node.getName());
        switch (node.getResolutionState()) {
            case FAILED:
                output.withStyle(Failure).text(" FAILED");
                break;
            case RESOLVED:
                if (alreadyRendered && !node.getChildren().isEmpty()) {
                    output.withStyle(Info).text(" (*)");

 */

.dependencyTree, #insight {
    border: solid 2px #d0d0d0;
    border-radius: 10px;
    padding: 8px;
    background-color: #FFFFEE
}
.alreadyRendered > a, .unresolvable > a {
    border-radius: 4px;
}
.alreadyRendered > a {
    border: solid 1px #EEEEEE;
    background-color: #EEEEEE !IMPORTANT;
}
.hasConflict > a {
    font-weight: bold !IMPORTANT;
    color: #FAA732 !IMPORTANT;
}

        private boolean seenTestSuite;

        @Override
        public void renderNode(StyledTextOutput output, RenderableDependency node, boolean alreadyRendered) {
            output.text(node.getName());
            if (node instanceof DependentComponentsRenderableDependency) {
                DependentComponentsRenderableDependency dep = (DependentComponentsRenderableDependency) node;

            boolean leaf = node.getChildren().isEmpty();
            target.text(leaf ? configurationName : node.getName());
            if (node.getDescription() != null) {
                target.text(" ").withStyle(Description).text(node.getDescription());
            }
            if (alreadyRendered && !leaf) {
                target.withStyle(Info).text(" (*)");