docs: def readline(self, limit=-1):
          """Read and return a line from the stream.
  
          If limit is specified, at most limit bytes will be read.
          """
  
          if not self._universal and limit < 0:
              # Shortcut common case - newline found in buffer.
              i = self._readbuffer.find(b'\n', self._offset) + 1
              if i > 0:
                  line = self._readbuffer[self._offset: i]
                  self._offset = i
                  return line
  
          if not self._universal:
              return io.BufferedIOBase.readline(self, limit)
  
          line = b''
          while limit < 0 or len(line) < limit:
              readahead = self.peek(2)
              if readahead == b'':
                  return line
  
              #
              # Search for universal newlines or line chunks.
              #
              # The pattern returns either a line chunk or a newline, but not
              # both. Combined with peek(2), we are assured that the sequence
              # '\r\n' is always retrieved completely and never split into
              # separate newlines - '\r', '\n' due to coincidental readaheads.
              #
              match = self.PATTERN.search(readahead)
              newline = match.group('newline')
              if newline is not None:
                  if self.newlines is None:
                      self.newlines = []
                  if newline not in self.newlines:
                      self.newlines.append(newline)
                  self._offset += len(newline)
                  return line + b'\n'
  
              chunk = match.group('chunk')
              if limit >= 0:
                  chunk = chunk[: limit - len(line)]
  
              self._offset += len(chunk)
              line += chunk
  
          return line