while (bytesLeft > 0) {
      if (bytesWrittenSinceLastDelay == bytesPerPeriod) {
        flush()
        sleepNanos(periodDelayNanos)
        bytesWrittenSinceLastDelay = 0
      }

      val toWrite = minOf(bytesLeft, bytesPerPeriod - bytesWrittenSinceLastDelay)
      bytesWrittenSinceLastDelay += toWrite
      bytesLeft -= toWrite
      delegate.write(source, toWrite)
    }
  }

    byteCount: Long,
  ) {
    if (byteCount == 0L) return // Avoid double-triggering.

    if (bytesWritten == triggerByteCount) {
      source.skip(byteCount)
      return
    }

    val toWrite = minOf(byteCount, triggerByteCount - bytesWritten)
    bytesWritten += toWrite

    delegate.write(source, toWrite)

    if (bytesWritten == triggerByteCount) {
      trigger()
    }

          val bytesToRead = minOf(byteCount, upstreamPos - sourcePos)
          buffer.copyTo(sink, sourcePos - bufferPos, bytesToRead)
          sourcePos += bytesToRead
          return bytesToRead
        }

      // Read from the file.
      if (source == SOURCE_FILE) {
        val bytesToRead = minOf(byteCount, upstreamPos - sourcePos)

      source.require(crlfDashDashBoundary.size.toLong())

      return when (val delimiterIndex = source.buffer.indexOf(crlfDashDashBoundary)) {
        -1L -> minOf(maxResult, source.buffer.size - crlfDashDashBoundary.size + 1)
        else -> minOf(maxResult, delimiterIndex)
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return
      closed = true

      byteCount: Long,
    ): Long {
      require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
      check(!closed) { "closed" }
      if (bytesRemaining == 0L) return -1

      val read = super.read(sink, minOf(bytesRemaining, byteCount))
      if (read == -1L) {
        carrier.noNewExchanges() // The server didn't supply the promised content length.
        val e = ProtocolException("unexpected end of stream")

    requestHeaders: List<Header>,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      hpackWriter.writeHeaders(requestHeaders)

      val byteCount = hpackBuffer.size
      val length = minOf(maxFrameSize - 4L, byteCount).toInt()
      frameHeader(
        streamId = streamId,
        length = length + 4,
        type = TYPE_PUSH_PROMISE,

@Throws(IOException::class)
fun Response.commonPeekBody(byteCount: Long): ResponseBody {
  val peeked = body.source().peek()
  val buffer = Buffer()
  peeked.request(byteCount)
  buffer.write(peeked, minOf(byteCount, peeked.buffer.size))
  return buffer.asResponseBody(body.contentType(), buffer.size)
}

fun Response.commonNewBuilder(): Response.Builder = Response.Builder(this)

val Response.commonIsRedirect: Boolean

    append("-----END CERTIFICATE-----\n")
  }
}

internal fun StringBuilder.encodeBase64Lines(data: ByteString) {
  val base64 = data.base64()
  for (i in 0 until base64.length step 64) {
    append(base64, i, minOf(i + 64, base64.length)).append('\n')
  }

      var i = 0
      val length = logMessage.length
      while (i < length) {
        var newline = logMessage.indexOf('\n', i)
        newline = if (newline != -1) newline else length
        do {
          val end = minOf(newline, i + MAX_LOG_LENGTH)
          Log.println(logLevel, tag, logMessage.substring(i, end))
          i = end
        } while (i < newline)
        i++
      }
    }
  }

      val ageMillis = cacheResponseAge()
      var freshMillis = computeFreshnessLifetime()

      if (requestCaching.maxAgeSeconds != -1) {
        freshMillis = minOf(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds.toLong()))
      }

      var minFreshMillis: Long = 0
      if (requestCaching.minFreshSeconds != -1) {