openJarFile(jar).run {
            getJarEntry(classFilePath)?.let { jarEntry ->
                { getInputStream(jarEntry).use { jarInput -> jarInput.readBytes() } }
            }
        }
    }

    private
    fun directoryClassBytesIndexFor(dir: File): ClassBytesIndex = { classFilePath ->
        dir.resolve(classFilePath).takeIf { it.isFile }?.let { classFile -> { classFile.readBytes() } }
    }

    private

    const termynalActivateClass = "termy";
    let termynals = [];

    function createTermynals() {
        document
            .querySelectorAll(`.${termynalActivateClass} .highlight code`)
            .forEach(node => {
                const text = node.textContent;
                const lines = text.split("\n");
                const useLines = [];
                let buffer = [];
                function saveBuffer() {

        this.container.innerHTML = '';
        for (let line of this.lines) {
            line.style.visibility = 'visible'
        }
        this.start();
    }

    /**
     * Start the animation and rener the lines depending on their data attributes.
     */
    async start() {
        this.addFinish()
        await this._wait(this.startDelay);

        for (let line of this.lines) {

            }
        }

    private
    fun apiSourceFileFor(member: JApiCompatibility): ApiSourceFile =
        member.jApiClass.let { declaringClass ->
            sources.sourceFileAndSourceRootFor(declaringClass.sourceFilePath).let { (sourceFile, sourceRoot) ->
                if (declaringClass.isKotlin) ApiSourceFile.Kotlin(sourceFile, sourceRoot)
                else ApiSourceFile.Java(sourceFile, sourceRoot)
            }
        }

  return request.build()
}

private fun Main.mediaType(): MediaType? {
  val mimeType =
    headers?.let {
      for (header in it) {
        val parts = header.split(':', limit = 2)
        if ("Content-Type".equals(parts[0], ignoreCase = true)) {
          return@let parts[1].trim()
        }
      }
      return@let null
    } ?: "application/x-www-form-urlencoded"

  return mimeType.toMediaTypeOrNull()
}

        buildReceiptString()
            ?.let(BuildReceipt::readBuildReceiptFromString)
            ?.let { buildReceipt ->
                buildReceipt["buildTimestamp"] as String
            }
    }

    override fun getDisplayName(): String =
        "the build timestamp extracted from the build receipt".let {
            when {

        ctClass.metadata
            ?.let { KotlinClassMetadata.readStrict(it) }
            ?.let { query(it) }
            ?: false

    private
    val CtClass.metadata: Metadata?
        get() = ctAnnotation<Metadata>()?.let { annotation ->
            Metadata(
                kind = annotation.getMemberValue("k")?.intValue ?: 1,

plugins {
    id("gradlebuild.integration-tests")
}

tasks.withType<IntegrationTest>().configureEach {
    // See AbstractKotlinIntegrationTest
    "kotlinDslTestsExtraRepo".let { propName ->
        System.getProperty(propName)?.let { systemProperty(propName, it) }
    }
}

dependencies {
    integTestRuntimeOnly(project(":kotlin-dsl-plugins")) {

                    }
                    return null
                }
            }
        )

    fun getSince(member: JApiCompatibility): JavaSourceQuery<SinceTagStatus> =
        member.jApiClass.simpleName.let { declaringClassSimpleName ->
            JavaSourceQuery(
                SinceTagStatus.Missing,
                when (member) {
                    is JApiClass -> getSinceJavaClassVisitorFor(declaringClassSimpleName)

            .accept(query.visitor, null)
            ?: query.defaultValue


    fun <T : Any?> executeQuery(apiSourceFile: ApiSourceFile.Kotlin, transform: (KtFile) -> T): T =
        apiSourceFile.normalizedPath.let { sourceNormalizedPath ->
            openKotlinCompilationUnitsByRoot
                .computeIfAbsent(apiSourceFile.currentSourceRoot) {
                    KotlinSourceParser().parseSourceRoots(