 
  o  Message fragments MUST be delivered to the recipient in the order
  sent by the sender.
+
+
+
+
+
+
+ Fette & Melnikov             Standards Track                   [Page 34]
+
+ RFC 6455                 The WebSocket Protocol            December 2011
+
+
+ o  The fragments of one message MUST NOT be interleaved between the
+ fragments of another message unless an extension has been
+ negotiated that can interpret the interleaving.
+
+ o  An endpoint MUST be capable of handling control frames in the
+ middle of a fragmented message.
+
+ o  A sender MAY create fragments of any size for non-control
+ messages.
+
+ o  Clients and servers MUST support receiving both fragmented and
+ unfragmented messages.
+
+ o  As control frames cannot be fragmented, an intermediary MUST NOT
+ attempt to change the fragmentation of a control frame.
+
+ o  An intermediary MUST NOT change the fragmentation of a message if
+ any reserved bit values are used and the meaning of these values
+ is not known to the intermediary.
+
+ o  An intermediary MUST NOT change the fragmentation of any message
+ in the context of a connection where extensions have been
+ negotiated and the intermediary is not aware of the semantics of
+ the negotiated extensions.  Similarly, an intermediary that didn't
+ see the WebSocket handshake (and wasn't notified about its
+ content) that resulted in a WebSocket connection MUST NOT change
+ the fragmentation of any message of such connection.
+
+ o  As a consequence of these rules, all fragments of a message are of
+ the same type, as set by the first fragment's opcode.  Since
+ control frames cannot be fragmented, the type for all fragments in
+ a message MUST be either text, binary, or one of the reserved
+ opcodes.
  */
 
 extension WebSocketMessage {
     var isFragment: Bool {
         /*
          An unfragmented message consists of a single frame with the FIN
-         bit set (Section 5.2) and an opcode other than 0. 
+         bit set (Section 5.2) and an opcode other than 0.
          */
         if !header.fin || header.opCode == .continuation {
             return true

            }
        }
    }
    enum ControlFrame {
        case b, c, d, e, f
        init<I: UnsignedInteger>(_ i: I) throws {
            switch i {

    case continuation
    case text
    case binary
    case nonControlExtension(NonControlFrameExtension)
    case connectionClose
    case ping
    case pong
    case controlExtension(ControlFrameExtension)

    // 4 bytes
    init(_ i: Byte) throws {
