ExcludeSpec ivyPatternExclude(ModuleIdentifier moduleId, IvyArtifactName artifact, String matcher);

    ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules);

    GroupSetExclude groupSet(Set<String> groups);

    ModuleSetExclude moduleSet(Set<String> modules);

    default ExcludeSpec fromUnion(Set<ExcludeSpec> remainder) {
        if (remainder.isEmpty()) {

    @Override
    public ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules) {
        return delegate.moduleIdSet(modules);
    }

    @Override
    public GroupSetExclude groupSet(Set<String> groups) {
        return delegate.groupSet(groups);
    }

    @Override
    public ModuleSetExclude moduleSet(Set<String> modules) {
        return delegate.moduleSet(modules);
    }

        factory.module(name)
    }

    ExcludeSpec moduleSet(String... names) {
        factory.moduleSet(RandomizedIteratorHashSet.of(names as Set<String>))
    }

    ExcludeSpec groupSet(String... groups) {
        factory.groupSet(RandomizedIteratorHashSet.of(groups as Set<String>))
    }

    ExcludeSpec moduleId(String group, String name) {
        factory.moduleId(newId(group, name))
    }

    }

    @Override
    public ModuleIdSetExclude moduleIdSet(Set<ModuleIdentifier> modules) {
        return DefaultModuleIdSetExclude.of(modules);
    }

    @Override
    public GroupSetExclude groupSet(Set<String> groups) {
        return new DefaultGroupSetExclude(groups);
    }

    @Override
    public ModuleSetExclude moduleSet(Set<String> modules) {
        return new DefaultModuleSetExclude(modules);
    }

            case "module ids":
                return "moduleIdSet(${value.collect { "'${anonymize(it)}'" }.join(', ')})"
            case "groups":
                return "groupSet(${value.collect { "'${anonymize(it)}'" }.join(', ')})"
            default:
                throw new UnsupportedOperationException("Not yet implemented for $opType")
        }
    }

    }

    ModuleSetExclude nextModuleSet() {
        FACTORY.moduleSet((0..(1 + random.nextInt(5))).collect { randomModuleName() } as Set<String>)
    }

    GroupSetExclude nextGroupSet() {
        FACTORY.groupSet((0..(1 + random.nextInt(5))).collect { randomGroupName() } as Set<String>)
    }

    ModuleIdSetExclude nextModuleIdSet() {

     */
    UNCATEGORIZED(false, false, false);

    private final boolean grouped;
    private final boolean topLevelWorkItem;
    private final boolean showHeader;

    BuildOperationCategory(boolean grouped, boolean topLevelWorkItem, boolean showHeader) {
        this.grouped = grouped;
        this.topLevelWorkItem = topLevelWorkItem;
        this.showHeader = showHeader;
    }

    private static final int NUMBER_OF_GROUPING_DIRS = 1;
    public static final int FILE_TREE_DEPTH_TO_TRACK_AND_CLEANUP = NUMBER_OF_GROUPING_DIRS + NUMBER_OF_CHECKSUM_DIRS;

    private static final Grouper<String> GROUPER = new Grouper<String>() {
        @Override
        public String determineGroup(String s) {
            return String.valueOf(Math.abs(s.hashCode()) % 100);
        }

        @Override

            "io.github.http-builder-ng.test"
        ]) as Set == [["org", "jetbrains"], ["io","github", "http-builder-ng"]] as Set
    }

    def "groups entries which have the same module component id"() {
        grouper {
            entry("org", "foo", "1.0", "foo-1.0.jar").addVerifiedKey(KEY_1)
            entry("org", "foo", "1.0", "foo-1.0.pom").addVerifiedKey(KEY_1)
        }

        when:
        executeGrouping()

        ),
      ps
    );
    local sanitizedPanels = sanitizePanels(panels, 0);

    local grouped = panelUtil.groupPanelsInRows(sanitizedPanels);

    local panelsBeforeRows = panelUtil.getPanelsBeforeNextRow(grouped);
    local rowPanels =
      std.filter(
        function(p) p.type == 'row',
        grouped
      );

    local CalculateXforPanel(index, panel) =