sr.ReturnNonDecryptable(true)

	// Debug corrupted streams.
	if false {
		sr.SkipEncrypted(true)
		return sr.DebugStream(os.Stdout)
	}
	extracted := false
	for {
		stream, err := sr.NextStream()
		if err != nil {
			if err == io.EOF {
				if extracted {
					return nil
				}
				return errors.New("no data found on stream")
			}
			if errors.Is(err, estream.ErrNoKey) {
				if stream.Name == "inspect.zip" {

            ?.let { buildReceipt ->
                buildReceipt["buildTimestamp"] as String
            }
    }

    override fun getDisplayName(): String =
        "the build timestamp extracted from the build receipt".let {
            when {
                parameters.ignoreIncomingBuildReceipt.get() -> "$it (ignored)"
                else -> it
            }
        }

    private

 */
package gradlebuild.docs.dsl.source.model;

import org.gradle.api.Action;

import java.io.Serializable;
import java.util.Objects;

/**
 * Static meta-data about a method parameter extracted from the source for the method.
 */
public class ParameterMetaData implements Serializable, TypeContainer {
    private final String name;
    private TypeMetaData type;

    public ParameterMetaData(String name) {

This directory contains JLine native libraries extracted from JLine JAR.

You can add your own build for platforms not natively supported by JLine.
See here [1] on how to compile for your platform and here [2] how libraries
follow JLine's directory and filename conventions.

[1] https://github.com/jline/jline3/tree/master/native

    /**
     * Returns the Java module name of the dependency at the given path.
     * The given dependency should be one of the paths returned by {@link #getDependencies()}.
     * The module name is extracted from the {@code module-info.class} file if present, otherwise from
     * the {@code "Automatic-Module-Name"} attribute of the {@code META-INF/MANIFEST.MF} file if present.
     *

                    throw new MaxLengthExceededException("Extracted size is " + contentSize + " > " + maxContentSize);
                }
                final String filename = entry.getName();
                final String mimeType = mimeTypeHelper.getContentType(null, filename);
                if (mimeType != null) {
                    final Extractor extractor = extractorFactory.getExtractor(mimeType);

                    throw new MaxLengthExceededException("Extracted size is " + contentSize + " > " + maxContentSize);
                }
                final String filename = entry.getName();
                final String mimeType = mimeTypeHelper.getContentType(null, filename);
                if (mimeType != null) {
                    final Extractor extractor = extractorFactory.getExtractor(mimeType);

                    throw new MaxLengthExceededException("Extracted size is " + contentSize + " > " + maxContentSize);
                }
                final String filename = head.getPath();
                final String mimeType = mimeTypeHelper.getContentType(null, filename);
                if (mimeType != null) {
                    final Extractor extractor = extractorFactory.getExtractor(mimeType);

Using the below example document:
<img width="85%" src="https://bradley.codes/static/img/jstream-levels.gif" alt="jstream"/>

we can choose to extract and act only the objects within the top-level array:
```go
f, _ := os.Open("input.json")
decoder := jstream.NewDecoder(f, 1) // extract JSON values at a depth level of 1
for mv := range decoder.Stream() {
  fmt.Printf("%v\n ", mv.Value)
}
```

output:
```

	return metadata
}

// ParseMetadata extracts all SSE-C related values from the object metadata
// and checks whether they are well-formed. It returns the sealed object key
// on success.
func (ssec) ParseMetadata(metadata map[string]string) (sealedKey SealedKey, err error) {
	// Extract all required values from object metadata
	b64IV, ok := metadata[MetaIV]
	if !ok {