to.attribute(artifactType, 'size')
    }

    registerTransform(Minifier) {
        from.attribute(minified, false)
        to.attribute(minified, true)
    }
}

${artifactTransform("Minifier", "min", "Minifying")}
${artifactTransform("FileSizer", "txt", "Sizing")}

task resolve(type: Copy) {
    def artifacts = configurations.compileClasspath.incoming.artifactView {

For example, consider a `minified` attribute with two values: `true` and `false`.
The minified attribute represents a variant of a dependency with unnecessary class files removed.
There is an artifact transform registered, which can transform `minified` from `false` to `true`.
When `minified=true` is requested for a dependency, and there are only variants with `minified=false`, then Gradle selects the registered minify transform.

                    from.attribute(minified, false).attribute(artifactType, "jar")
                    to.attribute(minified, true).attribute(artifactType, "jar")
                }
                registerTransform(SomeTransform) {
                    from.attribute(optimized, false).attribute(minified, true).attribute(artifactType, "jar")
                    to.attribute(optimized, true).attribute(minified, true).attribute(artifactType, "jar")

	//   [p, q, ...] ➞ [x, y, ...]    mapping from type parameters to types
	traceInference = false
)

// A unifier maintains a list of type parameters and
// corresponding types inferred for each type parameter.
// A unifier is created by calling newUnifier.
type unifier struct {
	// handles maps each type parameter to its inferred type through
	// an indirection *Type called (inferred type) "handle".

	//   [p, q, ...] ➞ [x, y, ...]    mapping from type parameters to types
	traceInference = false
)

// A unifier maintains a list of type parameters and
// corresponding types inferred for each type parameter.
// A unifier is created by calling newUnifier.
type unifier struct {
	// handles maps each type parameter to its inferred type through
	// an indirection *Type called (inferred type) "handle".

                    println root.get()
                }
            }
        """

        expect:
        succeeds("resolve", "--stacktrace")
    }

    @Ignore("Original reproducer. Minified version below")
    @Requires(UnitTestPreconditions.Jdk17OrLater)
    @Issue("https://github.com/gradle/gradle/issues/26145#issuecomment-1957776331")

	ignoreInvalids bool // if set, identical treats an invalid type as identical to any type
}

// For changes to this code the corresponding changes should be made to unifier.nify.
func (c *comparer) identical(x, y Type, p *ifacePair) bool {
	x = Unalias(x)
	y = Unalias(y)

	if x == y {
		return true
	}

	if c.ignoreInvalids && (!isValid(x) || !isValid(y)) {

	ignoreInvalids bool // if set, identical treats an invalid type as identical to any type
}

// For changes to this code the corresponding changes should be made to unifier.nify.
func (c *comparer) identical(x, y Type, p *ifacePair) bool {
	x = Unalias(x)
	y = Unalias(y)

	if x == y {
		return true
	}

	if c.ignoreInvalids && (!isValid(x) || !isValid(y)) {

In JavaScript, a library may exist as uncompressed or minified artifact. In Gradle, a specific artifact identifier is called _classifier_, a term generally used in Maven and Ivy dependency management.

Let's say we wanted to download the minified artifact of the JQuery library instead of the uncompressed file. You can provide the classifier `min` as part of the dependency declaration.