           if (bytes[bytes.length - 1] & 0x80) == 0x80
             top = bytes.length - 1
             for i in [0...top]
-              value += (~bytes[i] & 0xff)  * Math.pow(256, i)
+              value += (~bytes[i] & 0xff) * Math.pow(256, i)
             # To get the two's compliment as a positive value you use
             # `~1 & 0xff == 254`. For exmaple: `~1 == -2`.
             value += (~(bytes[top] & 0x7f) & 0xff & 0x7f) * Math.pow(256, top)

      # array elements, we repeat the current field type.
      if ++@index <  @repeat
        @nextValue()
      else
        # Push the field value after running it through the pipeline.
        if part.endianness isnt "x"
          # If the field is a packed field, unpack the value.
          if packing = part.packing
            # Loop through the packed fields, unpacking the values.
            for pack, i in packing
              if pack.endianness is "b"
                sum = 0

                unpacked = Math.floor(value / Math.pow(2, sum))
                unpacked = unpacked % Math.pow(2, pack.bits)
                @_fields.push(unpacked)

          # If the value is a length encoding, we set the repeat value for the
          # subsequent array of values. If we have a zero length encoding, we
          # push an empty array through the pipeline, and skip the repeated type.
          else if part.lengthEncoding
            if (@pattern[@patternIndex + 1].repeat = value) is 0
              @_fields.push(@pipeline(part, []))
              @patternIndex++

          # Otherwise, the value is what it is, so run it through the user
          # supplied tranformation pipeline, and push it onto the list of fields.
          else
            value = @_arrayed if part.arrayed
            @_fields.push(@pipeline(part, value))
