/files/peerjs/0.3.9/peer.js

/*! peerjs.js build:0.3.9, development. Copyright(c) 2013 Michelle Bu <michelle@michellebu.com> */
(function(exports){
var binaryFeatures = {};

binaryFeatures.useBlobBuilder = (function(){

  try {

    new Blob([]);

    return false;

  } catch (e) {

    return true;

  }

})();



binaryFeatures.useArrayBufferView = !binaryFeatures.useBlobBuilder && (function(){

  try {

    return (new Blob([new Uint8Array([])])).size === 0;

  } catch (e) {

    return true;

  }

})();



exports.binaryFeatures = binaryFeatures;

exports.BlobBuilder = window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder || window.BlobBuilder;



function BufferBuilder(){

  this._pieces = [];

  this._parts = [];

}



BufferBuilder.prototype.append = function(data) {

  if(typeof data === 'number') {

    this._pieces.push(data);

  } else {

    this.flush();

    this._parts.push(data);

  }

};



BufferBuilder.prototype.flush = function() {

  if (this._pieces.length > 0) {

    var buf = new Uint8Array(this._pieces);

    if(!binaryFeatures.useArrayBufferView) {

      buf = buf.buffer;

    }

    this._parts.push(buf);

    this._pieces = [];

  }

};



BufferBuilder.prototype.getBuffer = function() {

  this.flush();

  if(binaryFeatures.useBlobBuilder) {

    var builder = new BlobBuilder();

    for(var i = 0, ii = this._parts.length; i < ii; i++) {

      builder.append(this._parts[i]);

    }

    return builder.getBlob();

  } else {

    return new Blob(this._parts);

  }

};

exports.BinaryPack = {

  unpack: function(data){

    var unpacker = new Unpacker(data);

    return unpacker.unpack();

  },

  pack: function(data){

    var packer = new Packer();

    packer.pack(data);

    var buffer = packer.getBuffer();

    return buffer;

  }

};



function Unpacker (data){

  // Data is ArrayBuffer

  this.index = 0;

  this.dataBuffer = data;

  this.dataView = new Uint8Array(this.dataBuffer);

  this.length = this.dataBuffer.byteLength;

}





Unpacker.prototype.unpack = function(){

  var type = this.unpack_uint8();

  if (type < 0x80){

    var positive_fixnum = type;

    return positive_fixnum;

  } else if ((type ^ 0xe0) < 0x20){

    var negative_fixnum = (type ^ 0xe0) - 0x20;

    return negative_fixnum;

  }

  var size;

  if ((size = type ^ 0xa0) <= 0x0f){

    return this.unpack_raw(size);

  } else if ((size = type ^ 0xb0) <= 0x0f){

    return this.unpack_string(size);

  } else if ((size = type ^ 0x90) <= 0x0f){

    return this.unpack_array(size);

  } else if ((size = type ^ 0x80) <= 0x0f){

    return this.unpack_map(size);

  }

  switch(type){

    case 0xc0:

      return null;

    case 0xc1:

      return undefined;

    case 0xc2:

      return false;

    case 0xc3:

      return true;

    case 0xca:

      return this.unpack_float();

    case 0xcb:

      return this.unpack_double();

    case 0xcc:

      return this.unpack_uint8();

    case 0xcd:

      return this.unpack_uint16();

    case 0xce:

      return this.unpack_uint32();

    case 0xcf:

      return this.unpack_uint64();

    case 0xd0:

      return this.unpack_int8();

    case 0xd1:

      return this.unpack_int16();

    case 0xd2:

      return this.unpack_int32();

    case 0xd3:

      return this.unpack_int64();

    case 0xd4:

      return undefined;

    case 0xd5:

      return undefined;

    case 0xd6:

      return undefined;

    case 0xd7:

      return undefined;

    case 0xd8:

      size = this.unpack_uint16();

      return this.unpack_string(size);

    case 0xd9:

      size = this.unpack_uint32();

      return this.unpack_string(size);

    case 0xda:

      size = this.unpack_uint16();

      return this.unpack_raw(size);

    case 0xdb:

      size = this.unpack_uint32();

      return this.unpack_raw(size);

    case 0xdc:

      size = this.unpack_uint16();

      return this.unpack_array(size);

    case 0xdd:

      size = this.unpack_uint32();

      return this.unpack_array(size);

    case 0xde:

      size = this.unpack_uint16();

      return this.unpack_map(size);

    case 0xdf:

      size = this.unpack_uint32();

      return this.unpack_map(size);

  }

}



Unpacker.prototype.unpack_uint8 = function(){

  var byte = this.dataView[this.index] & 0xff;

  this.index++;

  return byte;

};



Unpacker.prototype.unpack_uint16 = function(){

  var bytes = this.read(2);

  var uint16 =

    ((bytes[0] & 0xff) * 256) + (bytes[1] & 0xff);

  this.index += 2;

  return uint16;

}



Unpacker.prototype.unpack_uint32 = function(){

  var bytes = this.read(4);

  var uint32 =

     ((bytes[0]  * 256 +

       bytes[1]) * 256 +

       bytes[2]) * 256 +

       bytes[3];

  this.index += 4;

  return uint32;

}



Unpacker.prototype.unpack_uint64 = function(){

  var bytes = this.read(8);

  var uint64 =

   ((((((bytes[0]  * 256 +

       bytes[1]) * 256 +

       bytes[2]) * 256 +

       bytes[3]) * 256 +

       bytes[4]) * 256 +

       bytes[5]) * 256 +

       bytes[6]) * 256 +

       bytes[7];

  this.index += 8;

  return uint64;

}





Unpacker.prototype.unpack_int8 = function(){

  var uint8 = this.unpack_uint8();

  return (uint8 < 0x80 ) ? uint8 : uint8 - (1 << 8);

};



Unpacker.prototype.unpack_int16 = function(){

  var uint16 = this.unpack_uint16();

  return (uint16 < 0x8000 ) ? uint16 : uint16 - (1 << 16);

}



Unpacker.prototype.unpack_int32 = function(){

  var uint32 = this.unpack_uint32();

  return (uint32 < Math.pow(2, 31) ) ? uint32 :

    uint32 - Math.pow(2, 32);

}



Unpacker.prototype.unpack_int64 = function(){

  var uint64 = this.unpack_uint64();

  return (uint64 < Math.pow(2, 63) ) ? uint64 :

    uint64 - Math.pow(2, 64);

}



Unpacker.prototype.unpack_raw = function(size){

  if ( this.length < this.index + size){

    throw new Error('BinaryPackFailure: index is out of range'

      + ' ' + this.index + ' ' + size + ' ' + this.length);

  }

  var buf = this.dataBuffer.slice(this.index, this.index + size);

  this.index += size;



    //buf = util.bufferToString(buf);



  return buf;

}



Unpacker.prototype.unpack_string = function(size){

  var bytes = this.read(size);

  var i = 0, str = '', c, code;

  while(i < size){

    c = bytes[i];

    if ( c < 128){

      str += String.fromCharCode(c);

      i++;

    } else if ((c ^ 0xc0) < 32){

      code = ((c ^ 0xc0) << 6) | (bytes[i+1] & 63);

      str += String.fromCharCode(code);

      i += 2;

    } else {

      code = ((c & 15) << 12) | ((bytes[i+1] & 63) << 6) |

        (bytes[i+2] & 63);

      str += String.fromCharCode(code);

      i += 3;

    }

  }

  this.index += size;

  return str;

}



Unpacker.prototype.unpack_array = function(size){

  var objects = new Array(size);

  for(var i = 0; i < size ; i++){

    objects[i] = this.unpack();

  }

  return objects;

}



Unpacker.prototype.unpack_map = function(size){

  var map = {};

  for(var i = 0; i < size ; i++){

    var key  = this.unpack();

    var value = this.unpack();

    map[key] = value;

  }

  return map;

}



Unpacker.prototype.unpack_float = function(){

  var uint32 = this.unpack_uint32();

  var sign = uint32 >> 31;

  var exp  = ((uint32 >> 23) & 0xff) - 127;

  var fraction = ( uint32 & 0x7fffff ) | 0x800000;

  return (sign == 0 ? 1 : -1) *

    fraction * Math.pow(2, exp - 23);

}



Unpacker.prototype.unpack_double = function(){

  var h32 = this.unpack_uint32();

  var l32 = this.unpack_uint32();

  var sign = h32 >> 31;

  var exp  = ((h32 >> 20) & 0x7ff) - 1023;

  var hfrac = ( h32 & 0xfffff ) | 0x100000;

  var frac = hfrac * Math.pow(2, exp - 20) +

    l32   * Math.pow(2, exp - 52);

  return (sign == 0 ? 1 : -1) * frac;

}



Unpacker.prototype.read = function(length){

  var j = this.index;

  if (j + length <= this.length) {

    return this.dataView.subarray(j, j + length);

  } else {

    throw new Error('BinaryPackFailure: read index out of range');

  }

}



function Packer(){

  this.bufferBuilder = new BufferBuilder();

}



Packer.prototype.getBuffer = function(){

  return this.bufferBuilder.getBuffer();

}



Packer.prototype.pack = function(value){

  var type = typeof(value);

  if (type == 'string'){

    this.pack_string(value);

  } else if (type == 'number'){

    if (Math.floor(value) === value){

      this.pack_integer(value);

    } else{

      this.pack_double(value);

    }

  } else if (type == 'boolean'){

    if (value === true){

      this.bufferBuilder.append(0xc3);

    } else if (value === false){

      this.bufferBuilder.append(0xc2);

    }

  } else if (type == 'undefined'){

    this.bufferBuilder.append(0xc0);

  } else if (type == 'object'){

    if (value === null){

      this.bufferBuilder.append(0xc0);

    } else {

      var constructor = value.constructor;

      if (constructor == Array){

        this.pack_array(value);

      } else if (constructor == Blob || constructor == File) {

        this.pack_bin(value);

      } else if (constructor == ArrayBuffer) {

        if(binaryFeatures.useArrayBufferView) {

          this.pack_bin(new Uint8Array(value));

        } else {

          this.pack_bin(value);

        }

      } else if ('BYTES_PER_ELEMENT' in value){

        if(binaryFeatures.useArrayBufferView) {

          this.pack_bin(new Uint8Array(value.buffer));

        } else {

          this.pack_bin(value.buffer);

        }

      } else if (constructor == Object){

        this.pack_object(value);

      } else if (constructor == Date){

        this.pack_string(value.toString());

      } else if (typeof value.toBinaryPack == 'function'){

        this.bufferBuilder.append(value.toBinaryPack());

      } else {

        throw new Error('Type "' + constructor.toString() + '" not yet supported');

      }

    }

  } else {

    throw new Error('Type "' + type + '" not yet supported');

  }

  this.bufferBuilder.flush();

}





Packer.prototype.pack_bin = function(blob){

  var length = blob.length || blob.byteLength || blob.size;

  if (length <= 0x0f){

    this.pack_uint8(0xa0 + length);

  } else if (length <= 0xffff){

    this.bufferBuilder.append(0xda) ;

    this.pack_uint16(length);

  } else if (length <= 0xffffffff){

    this.bufferBuilder.append(0xdb);

    this.pack_uint32(length);

  } else{

    throw new Error('Invalid length');

    return;

  }

  this.bufferBuilder.append(blob);

}



Packer.prototype.pack_string = function(str){

  var length = utf8Length(str);



  if (length <= 0x0f){

    this.pack_uint8(0xb0 + length);

  } else if (length <= 0xffff){

    this.bufferBuilder.append(0xd8) ;

    this.pack_uint16(length);

  } else if (length <= 0xffffffff){

    this.bufferBuilder.append(0xd9);

    this.pack_uint32(length);

  } else{

    throw new Error('Invalid length');

    return;

  }

  this.bufferBuilder.append(str);

}



Packer.prototype.pack_array = function(ary){

  var length = ary.length;

  if (length <= 0x0f){

    this.pack_uint8(0x90 + length);

  } else if (length <= 0xffff){

    this.bufferBuilder.append(0xdc)

    this.pack_uint16(length);

  } else if (length <= 0xffffffff){

    this.bufferBuilder.append(0xdd);

    this.pack_uint32(length);

  } else{

    throw new Error('Invalid length');

  }

  for(var i = 0; i < length ; i++){

    this.pack(ary[i]);

  }

}



Packer.prototype.pack_integer = function(num){

  if ( -0x20 <= num && num <= 0x7f){

    this.bufferBuilder.append(num & 0xff);

  } else if (0x00 <= num && num <= 0xff){

    this.bufferBuilder.append(0xcc);

    this.pack_uint8(num);

  } else if (-0x80 <= num && num <= 0x7f){

    this.bufferBuilder.append(0xd0);

    this.pack_int8(num);

  } else if ( 0x0000 <= num && num <= 0xffff){

    this.bufferBuilder.append(0xcd);

    this.pack_uint16(num);

  } else if (-0x8000 <= num && num <= 0x7fff){

    this.bufferBuilder.append(0xd1);

    this.pack_int16(num);

  } else if ( 0x00000000 <= num && num <= 0xffffffff){

    this.bufferBuilder.append(0xce);

    this.pack_uint32(num);

  } else if (-0x80000000 <= num && num <= 0x7fffffff){

    this.bufferBuilder.append(0xd2);

    this.pack_int32(num);

  } else if (-0x8000000000000000 <= num && num <= 0x7FFFFFFFFFFFFFFF){

    this.bufferBuilder.append(0xd3);

    this.pack_int64(num);

  } else if (0x0000000000000000 <= num && num <= 0xFFFFFFFFFFFFFFFF){

    this.bufferBuilder.append(0xcf);

    this.pack_uint64(num);

  } else{

    throw new Error('Invalid integer');

  }

}



Packer.prototype.pack_double = function(num){

  var sign = 0;

  if (num < 0){

    sign = 1;

    num = -num;

  }

  var exp  = Math.floor(Math.log(num) / Math.LN2);

  var frac0 = num / Math.pow(2, exp) - 1;

  var frac1 = Math.floor(frac0 * Math.pow(2, 52));

  var b32   = Math.pow(2, 32);

  var h32 = (sign << 31) | ((exp+1023) << 20) |

      (frac1 / b32) & 0x0fffff;

  var l32 = frac1 % b32;

  this.bufferBuilder.append(0xcb);

  this.pack_int32(h32);

  this.pack_int32(l32);

}



Packer.prototype.pack_object = function(obj){

  var keys = Object.keys(obj);

  var length = keys.length;

  if (length <= 0x0f){

    this.pack_uint8(0x80 + length);

  } else if (length <= 0xffff){

    this.bufferBuilder.append(0xde);

    this.pack_uint16(length);

  } else if (length <= 0xffffffff){

    this.bufferBuilder.append(0xdf);

    this.pack_uint32(length);

  } else{

    throw new Error('Invalid length');

  }

  for(var prop in obj){

    if (obj.hasOwnProperty(prop)){

      this.pack(prop);

      this.pack(obj[prop]);

    }

  }

}



Packer.prototype.pack_uint8 = function(num){

  this.bufferBuilder.append(num);

}



Packer.prototype.pack_uint16 = function(num){

  this.bufferBuilder.append(num >> 8);

  this.bufferBuilder.append(num & 0xff);

}



Packer.prototype.pack_uint32 = function(num){

  var n = num & 0xffffffff;

  this.bufferBuilder.append((n & 0xff000000) >>> 24);

  this.bufferBuilder.append((n & 0x00ff0000) >>> 16);

  this.bufferBuilder.append((n & 0x0000ff00) >>>  8);

  this.bufferBuilder.append((n & 0x000000ff));

}



Packer.prototype.pack_uint64 = function(num){

  var high = num / Math.pow(2, 32);

  var low  = num % Math.pow(2, 32);

  this.bufferBuilder.append((high & 0xff000000) >>> 24);

  this.bufferBuilder.append((high & 0x00ff0000) >>> 16);

  this.bufferBuilder.append((high & 0x0000ff00) >>>  8);

  this.bufferBuilder.append((high & 0x000000ff));

  this.bufferBuilder.append((low  & 0xff000000) >>> 24);

  this.bufferBuilder.append((low  & 0x00ff0000) >>> 16);

  this.bufferBuilder.append((low  & 0x0000ff00) >>>  8);

  this.bufferBuilder.append((low  & 0x000000ff));

}



Packer.prototype.pack_int8 = function(num){

  this.bufferBuilder.append(num & 0xff);

}



Packer.prototype.pack_int16 = function(num){

  this.bufferBuilder.append((num & 0xff00) >> 8);

  this.bufferBuilder.append(num & 0xff);

}



Packer.prototype.pack_int32 = function(num){

  this.bufferBuilder.append((num >>> 24) & 0xff);

  this.bufferBuilder.append((num & 0x00ff0000) >>> 16);

  this.bufferBuilder.append((num & 0x0000ff00) >>> 8);

  this.bufferBuilder.append((num & 0x000000ff));

}



Packer.prototype.pack_int64 = function(num){

  var high = Math.floor(num / Math.pow(2, 32));

  var low  = num % Math.pow(2, 32);

  this.bufferBuilder.append((high & 0xff000000) >>> 24);

  this.bufferBuilder.append((high & 0x00ff0000) >>> 16);

  this.bufferBuilder.append((high & 0x0000ff00) >>>  8);

  this.bufferBuilder.append((high & 0x000000ff));

  this.bufferBuilder.append((low  & 0xff000000) >>> 24);

  this.bufferBuilder.append((low  & 0x00ff0000) >>> 16);

  this.bufferBuilder.append((low  & 0x0000ff00) >>>  8);

  this.bufferBuilder.append((low  & 0x000000ff));

}



function _utf8Replace(m){

  var code = m.charCodeAt(0);



  if(code <= 0x7ff) return '00';

  if(code <= 0xffff) return '000';

  if(code <= 0x1fffff) return '0000';

  if(code <= 0x3ffffff) return '00000';

  return '000000';

}



function utf8Length(str){

  if (str.length > 600) {

    // Blob method faster for large strings

    return (new Blob([str])).size;

  } else {

    return str.replace(/[^\u0000-\u007F]/g, _utf8Replace).length;

  }

}

/**
 * Light EventEmitter. Ported from Node.js/events.js
 * Eric Zhang
 */

/**
 * EventEmitter class
 * Creates an object with event registering and firing methods
 */
function EventEmitter() {
  // Initialise required storage variables
  this._events = {};
}

var isArray = Array.isArray;


EventEmitter.prototype.addListener = function(type, listener, scope, once) {
  if ('function' !== typeof listener) {
    throw new Error('addListener only takes instances of Function');
  }
  
  // To avoid recursion in the case that type == "newListeners"! Before
  // adding it to the listeners, first emit "newListeners".
  this.emit('newListener', type, typeof listener.listener === 'function' ?
            listener.listener : listener);
            
  if (!this._events[type]) {
    // Optimize the case of one listener. Don't need the extra array object.
    this._events[type] = listener;
  } else if (isArray(this._events[type])) {

    // If we've already got an array, just append.
    this._events[type].push(listener);

  } else {
    // Adding the second element, need to change to array.
    this._events[type] = [this._events[type], listener];
  }
  return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type, listener, scope) {
  if ('function' !== typeof listener) {
    throw new Error('.once only takes instances of Function');
  }

  var self = this;
  function g() {
    self.removeListener(type, g);
    listener.apply(this, arguments);
  };

  g.listener = listener;
  self.on(type, g);

  return this;
};

EventEmitter.prototype.removeListener = function(type, listener, scope) {
  if ('function' !== typeof listener) {
    throw new Error('removeListener only takes instances of Function');
  }

  // does not use listeners(), so no side effect of creating _events[type]
  if (!this._events[type]) return this;

  var list = this._events[type];

  if (isArray(list)) {
    var position = -1;
    for (var i = 0, length = list.length; i < length; i++) {
      if (list[i] === listener ||
          (list[i].listener && list[i].listener === listener))
      {
        position = i;
        break;
      }
    }

    if (position < 0) return this;
    list.splice(position, 1);
    if (list.length == 0)
      delete this._events[type];
  } else if (list === listener ||
             (list.listener && list.listener === listener))
  {
    delete this._events[type];
  }

  return this;
};


EventEmitter.prototype.off = EventEmitter.prototype.removeListener;


EventEmitter.prototype.removeAllListeners = function(type) {
  if (arguments.length === 0) {
    this._events = {};
    return this;
  }

  // does not use listeners(), so no side effect of creating _events[type]
  if (type && this._events && this._events[type]) this._events[type] = null;
  return this;
};

EventEmitter.prototype.listeners = function(type) {
  if (!this._events[type]) this._events[type] = [];
  if (!isArray(this._events[type])) {
    this._events[type] = [this._events[type]];
  }
  return this._events[type];
};

EventEmitter.prototype.emit = function(type) {
  var type = arguments[0];
  var handler = this._events[type];
  if (!handler) return false;

  if (typeof handler == 'function') {
    switch (arguments.length) {
      // fast cases
      case 1:
        handler.call(this);
        break;
      case 2:
        handler.call(this, arguments[1]);
        break;
      case 3:
        handler.call(this, arguments[1], arguments[2]);
        break;
      // slower
      default:
        var l = arguments.length;
        var args = new Array(l - 1);
        for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
        handler.apply(this, args);
    }
    return true;

  } else if (isArray(handler)) {
    var l = arguments.length;
    var args = new Array(l - 1);
    for (var i = 1; i < l; i++) args[i - 1] = arguments[i];

    var listeners = handler.slice();
    for (var i = 0, l = listeners.length; i < l; i++) {
      listeners[i].apply(this, args);
    }
    return true;
  } else {
    return false;
  }
};



/**
 * Reliable transfer for Chrome Canary DataChannel impl.
 * Author: @michellebu
 */
function Reliable(dc, debug) {
  if (!(this instanceof Reliable)) return new Reliable(dc);
  this._dc = dc;

  util.debug = debug;

  // Messages sent/received so far.
  // id: { ack: n, chunks: [...] }
  this._outgoing = {};
  // id: { ack: ['ack', id, n], chunks: [...] }
  this._incoming = {};
  this._received = {};

  // Window size.
  this._window = 1000;
  // MTU.
  this._mtu = 500;
  // Interval for setInterval. In ms.
  this._interval = 0;

  // Messages sent.
  this._count = 0;

  // Outgoing message queue.
  this._queue = [];

  this._setupDC();
};

// Send a message reliably.
Reliable.prototype.send = function(msg) {
  // Determine if chunking is necessary.
  var bl = util.pack(msg);
  if (bl.size < this._mtu) {
    this._handleSend(['no', bl]);
    return;
  }

  this._outgoing[this._count] = {
    ack: 0,
    chunks: this._chunk(bl)
  };

  if (util.debug) {
    this._outgoing[this._count].timer = new Date();
  }

  // Send prelim window.
  this._sendWindowedChunks(this._count);
  this._count += 1;
};

// Set up interval for processing queue.
Reliable.prototype._setupInterval = function() {
  // TODO: fail gracefully.

  var self = this;
  this._timeout = setInterval(function() {
    // FIXME: String stuff makes things terribly async.
    var msg = self._queue.shift();
    if (msg._multiple) {
      for (var i = 0, ii = msg.length; i < ii; i += 1) {
        self._intervalSend(msg[i]);
      }
    } else {
      self._intervalSend(msg);
    }
  }, this._interval);
};

Reliable.prototype._intervalSend = function(msg) {
  var self = this;
  msg = util.pack(msg);
  util.blobToBinaryString(msg, function(str) {
    self._dc.send(str);
  });
  if (self._queue.length === 0) {
    clearTimeout(self._timeout);
    self._timeout = null;
    //self._processAcks();
  }
};

// Go through ACKs to send missing pieces.
Reliable.prototype._processAcks = function() {
  for (var id in this._outgoing) {
    if (this._outgoing.hasOwnProperty(id)) {
      this._sendWindowedChunks(id);
    }
  }
};

// Handle sending a message.
// FIXME: Don't wait for interval time for all messages...
Reliable.prototype._handleSend = function(msg) {
  var push = true;
  for (var i = 0, ii = this._queue.length; i < ii; i += 1) {
    var item = this._queue[i];
    if (item === msg) {
      push = false;
    } else if (item._multiple && item.indexOf(msg) !== -1) {
      push = false;
    }
  }
  if (push) {
    this._queue.push(msg);
    if (!this._timeout) {
      this._setupInterval();
    }
  }
};

// Set up DataChannel handlers.
Reliable.prototype._setupDC = function() {
  // Handle various message types.
  var self = this;
  this._dc.onmessage = function(e) {
    var msg = e.data;
    var datatype = msg.constructor;
    // FIXME: msg is String until binary is supported.
    // Once that happens, this will have to be smarter.
    if (datatype === String) {
      var ab = util.binaryStringToArrayBuffer(msg);
      msg = util.unpack(ab);
      self._handleMessage(msg);
    }
  };
};

// Handles an incoming message.
Reliable.prototype._handleMessage = function(msg) {
  var id = msg[1];
  var idata = this._incoming[id];
  var odata = this._outgoing[id];
  var data;
  switch (msg[0]) {
    // No chunking was done.
    case 'no':
      var message = id;
      if (!!message) {
        this.onmessage(util.unpack(message));
      }
      break;
    // Reached the end of the message.
    case 'end':
      data = idata;

      // In case end comes first.
      this._received[id] = msg[2];

      if (!data) {
        break;
      }

      this._ack(id);
      break;
    case 'ack':
      data = odata;
      if (!!data) {
        var ack = msg[2];
        // Take the larger ACK, for out of order messages.
        data.ack = Math.max(ack, data.ack);

        // Clean up when all chunks are ACKed.
        if (data.ack >= data.chunks.length) {
          util.log('Time: ', new Date() - data.timer);
          delete this._outgoing[id];
        } else {
          this._processAcks();
        }
      }
      // If !data, just ignore.
      break;
    // Received a chunk of data.
    case 'chunk':
      // Create a new entry if none exists.
      data = idata;
      if (!data) {
        var end = this._received[id];
        if (end === true) {
          break;
        }
        data = {
          ack: ['ack', id, 0],
          chunks: []
        };
        this._incoming[id] = data;
      }

      var n = msg[2];
      var chunk = msg[3];
      data.chunks[n] = new Uint8Array(chunk);

      // If we get the chunk we're looking for, ACK for next missing.
      // Otherwise, ACK the same N again.
      if (n === data.ack[2]) {
        this._calculateNextAck(id);
      }
      this._ack(id);
      break;
    default:
      // Shouldn't happen, but would make sense for message to just go
      // through as is.
      this._handleSend(msg);
      break;
  }
};

// Chunks BL into smaller messages.
Reliable.prototype._chunk = function(bl) {
  var chunks = [];
  var size = bl.size;
  var start = 0;
  while (start < size) {
    var end = Math.min(size, start + this._mtu);
    var b = bl.slice(start, end);
    var chunk = {
      payload: b
    }
    chunks.push(chunk);
    start = end;
  }
  util.log('Created', chunks.length, 'chunks.');
  return chunks;
};

// Sends ACK N, expecting Nth blob chunk for message ID.
Reliable.prototype._ack = function(id) {
  var ack = this._incoming[id].ack;

  // if ack is the end value, then call _complete.
  if (this._received[id] === ack[2]) {
    this._complete(id);
    this._received[id] = true;
  }

  this._handleSend(ack);
};

// Calculates the next ACK number, given chunks.
Reliable.prototype._calculateNextAck = function(id) {
  var data = this._incoming[id];
  var chunks = data.chunks;
  for (var i = 0, ii = chunks.length; i < ii; i += 1) {
    // This chunk is missing!!! Better ACK for it.
    if (chunks[i] === undefined) {
      data.ack[2] = i;
      return;
    }
  }
  data.ack[2] = chunks.length;
};

// Sends the next window of chunks.
Reliable.prototype._sendWindowedChunks = function(id) {
  util.log('sendWindowedChunks for: ', id);
  var data = this._outgoing[id];
  var ch = data.chunks;
  var chunks = [];
  var limit = Math.min(data.ack + this._window, ch.length);
  for (var i = data.ack; i < limit; i += 1) {
    if (!ch[i].sent || i === data.ack) {
      ch[i].sent = true;
      chunks.push(['chunk', id, i, ch[i].payload]);
    }
  }
  if (data.ack + this._window >= ch.length) {
    chunks.push(['end', id, ch.length])
  }
  chunks._multiple = true;
  this._handleSend(chunks);
};

// Puts together a message from chunks.
Reliable.prototype._complete = function(id) {
  util.log('Completed called for', id);
  var self = this;
  var chunks = this._incoming[id].chunks;
  var bl = new Blob(chunks);
  util.blobToArrayBuffer(bl, function(ab) {
    self.onmessage(util.unpack(ab));
  });
  delete this._incoming[id];
};

// Ups bandwidth limit on SDP. Meant to be called during offer/answer.
Reliable.higherBandwidthSDP = function(sdp) {
  // AS stands for Application-Specific Maximum.
  // Bandwidth number is in kilobits / sec.
  // See RFC for more info: http://www.ietf.org/rfc/rfc2327.txt

  // Chrome 31+ doesn't want us munging the SDP, so we'll let them have their
  // way.
  var version = navigator.appVersion.match(/Chrome\/(.*?) /);
  if (version) {
    version = parseInt(version[1].split('.').shift());
    if (version < 31) {
      var parts = sdp.split('b=AS:30');
      var replace = 'b=AS:102400'; // 100 Mbps
      if (parts.length > 1) {
        return parts[0] + replace + parts[1];
      }
    }
  }

  return sdp;
};

// Overwritten, typically.
Reliable.prototype.onmessage = function(msg) {};

exports.Reliable = Reliable;
exports.RTCSessionDescription = window.RTCSessionDescription || window.mozRTCSessionDescription;
exports.RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection;
exports.RTCIceCandidate = window.RTCIceCandidate || window.mozRTCIceCandidate;
var defaultConfig = {'iceServers': [{ 'url': 'stun:stun.l.google.com:19302' }]};
var dataCount = 1;

var util = {
  noop: function() {},

  CLOUD_HOST: '0.peerjs.com',
  CLOUD_PORT: 9000,

  // Browsers that need chunking:
  chunkedBrowsers: {'Chrome': 1},
  chunkedMTU: 16300, // The original 60000 bytes setting does not work when sending data from Firefox to Chrome, which is "cut off" after 16384 bytes and delivered individually.

  // Logging logic
  logLevel: 0,
  setLogLevel: function(level) {
    var debugLevel = parseInt(level, 10);
    if (!isNaN(parseInt(level, 10))) {
      util.logLevel = debugLevel;
    } else {
      // If they are using truthy/falsy values for debug
      util.logLevel = level ? 3 : 0;
    }
    util.log = util.warn = util.error = util.noop;
    if (util.logLevel > 0) {
      util.error = util._printWith('ERROR');
    }
    if (util.logLevel > 1) {
      util.warn = util._printWith('WARNING');
    }
    if (util.logLevel > 2) {
      util.log = util._print;
    }
  },
  setLogFunction: function(fn) {
    if (fn.constructor !== Function) {
      util.warn('The log function you passed in is not a function. Defaulting to regular logs.');
    } else {
      util._print = fn;
    }
  },

  _printWith: function(prefix) {
    return function() {
      var copy = Array.prototype.slice.call(arguments);
      copy.unshift(prefix);
      util._print.apply(util, copy);
    };
  },
  _print: function () {
    var err = false;
    var copy = Array.prototype.slice.call(arguments);
    copy.unshift('PeerJS: ');
    for (var i = 0, l = copy.length; i < l; i++){
      if (copy[i] instanceof Error) {
        copy[i] = '(' + copy[i].name + ') ' + copy[i].message;
        err = true;
      }
    }
    err ? console.error.apply(console, copy) : console.log.apply(console, copy);  
  },
  //

  // Returns browser-agnostic default config
  defaultConfig: defaultConfig,
  //

  // Returns the current browser.
  browser: (function() {
    if (window.mozRTCPeerConnection) {
      return 'Firefox';
    } else if (window.webkitRTCPeerConnection) {
      return 'Chrome';
    } else if (window.RTCPeerConnection) {
      return 'Supported';
    } else {
      return 'Unsupported';
    }
  })(),
  //

  // Lists which features are supported
  supports: (function() {
    if (typeof RTCPeerConnection === 'undefined') {
      return {};
    }

    var data = true;
    var audioVideo = true;

    var binaryBlob = false;
    var sctp = false;
    var onnegotiationneeded = !!window.webkitRTCPeerConnection;

    var pc, dc;
    try {
      pc = new RTCPeerConnection(defaultConfig, {optional: [{RtpDataChannels: true}]});
    } catch (e) {
      data = false;
      audioVideo = false;
    }

    if (data) {
      try {
        dc = pc.createDataChannel('_PEERJSTEST');
      } catch (e) {
        data = false;
      }
    }

    if (data) {
      // Binary test
      try {
        dc.binaryType = 'blob';
        binaryBlob = true;
      } catch (e) {
      }

      // Reliable test.
      // Unfortunately Chrome is a bit unreliable about whether or not they
      // support reliable.
      var reliablePC = new RTCPeerConnection(defaultConfig, {});
      try {
        var reliableDC = reliablePC.createDataChannel('_PEERJSRELIABLETEST', {});
        sctp = reliableDC.reliable;
      } catch (e) {
      }
      reliablePC.close();
    }

    // FIXME: not really the best check...
    if (audioVideo) {
      audioVideo = !!pc.addStream;
    }

    // FIXME: this is not great because in theory it doesn't work for
    // av-only browsers (?).
    if (!onnegotiationneeded && data) {
      // sync default check.
      var negotiationPC = new RTCPeerConnection(defaultConfig, {optional: [{RtpDataChannels: true}]});
      negotiationPC.onnegotiationneeded = function() {
        onnegotiationneeded = true;
        // async check.
        if (util && util.supports) {
          util.supports.onnegotiationneeded = true;
        }
      };
      var negotiationDC = negotiationPC.createDataChannel('_PEERJSNEGOTIATIONTEST');

      setTimeout(function() {
        negotiationPC.close();
      }, 1000);
    }

    if (pc) {
      pc.close();
    }

    return {
      audioVideo: audioVideo,
      data: data,
      binaryBlob: binaryBlob,
      binary: sctp, // deprecated; sctp implies binary support.
      reliable: sctp, // deprecated; sctp implies reliable data.
      sctp: sctp,
      onnegotiationneeded: onnegotiationneeded
    };
  }()),
  //

  // Ensure alphanumeric ids
  validateId: function(id) {
    // Allow empty ids
    return !id || /^[A-Za-z0-9]+(?:[ _-][A-Za-z0-9]+)*$/.exec(id);
  },

  validateKey: function(key) {
    // Allow empty keys
    return !key || /^[A-Za-z0-9]+(?:[ _-][A-Za-z0-9]+)*$/.exec(key);
  },


  debug: false,

  inherits: function(ctor, superCtor) {
    ctor.super_ = superCtor;
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  },
  extend: function(dest, source) {
    for(var key in source) {
      if(source.hasOwnProperty(key)) {
        dest[key] = source[key];
      }
    }
    return dest;
  },
  pack: BinaryPack.pack,
  unpack: BinaryPack.unpack,

  log: function () {
    if (util.debug) {
      var err = false;
      var copy = Array.prototype.slice.call(arguments);
      copy.unshift('PeerJS: ');
      for (var i = 0, l = copy.length; i < l; i++){
        if (copy[i] instanceof Error) {
          copy[i] = '(' + copy[i].name + ') ' + copy[i].message;
          err = true;
        }
      }
      err ? console.error.apply(console, copy) : console.log.apply(console, copy);
    }
  },

  setZeroTimeout: (function(global) {
    var timeouts = [];
    var messageName = 'zero-timeout-message';

    // Like setTimeout, but only takes a function argument.	 There's
    // no time argument (always zero) and no arguments (you have to
    // use a closure).
    function setZeroTimeoutPostMessage(fn) {
      timeouts.push(fn);
      global.postMessage(messageName, '*');
    }

    function handleMessage(event) {
      if (event.source == global && event.data == messageName) {
        if (event.stopPropagation) {
          event.stopPropagation();
        }
        if (timeouts.length) {
          timeouts.shift()();
        }
      }
    }
    if (global.addEventListener) {
      global.addEventListener('message', handleMessage, true);
    } else if (global.attachEvent) {
      global.attachEvent('onmessage', handleMessage);
    }
    return setZeroTimeoutPostMessage;
  }(this)),

  // Binary stuff

  // chunks a blob.
  chunk: function(bl) {
    var chunks = [];
    var size = bl.size;
    var start = index = 0;
    var total = Math.ceil(size / util.chunkedMTU);
    while (start < size) {
      var end = Math.min(size, start + util.chunkedMTU);
      var b = bl.slice(start, end);

      var chunk = {
        __peerData: dataCount,
        n: index,
        data: b,
        total: total
      };

      chunks.push(chunk);

      start = end;
      index += 1;
    }
    dataCount += 1;
    return chunks;
  },

  blobToArrayBuffer: function(blob, cb){
    var fr = new FileReader();
    fr.onload = function(evt) {
      cb(evt.target.result);
    };
    fr.readAsArrayBuffer(blob);
  },
  blobToBinaryString: function(blob, cb){
    var fr = new FileReader();
    fr.onload = function(evt) {
      cb(evt.target.result);
    };
    fr.readAsBinaryString(blob);
  },
  binaryStringToArrayBuffer: function(binary) {
    var byteArray = new Uint8Array(binary.length);
    for (var i = 0; i < binary.length; i++) {
      byteArray[i] = binary.charCodeAt(i) & 0xff;
    }
    return byteArray.buffer;
  },
  randomToken: function () {
    return Math.random().toString(36).substr(2);
  },
  //

  isSecure: function() {
    return location.protocol === 'https:';
  }
};

exports.util = util;
/**
 * A peer who can initiate connections with other peers.
 */
function Peer(id, options) {
  if (!(this instanceof Peer)) return new Peer(id, options);
  EventEmitter.call(this);

  // Deal with overloading
  if (id && id.constructor == Object) {
    options = id;
    id = undefined;
  } else if (id) {
    // Ensure id is a string
    id = id.toString();
  }
  //

  // Configurize options
  options = util.extend({
    debug: 0, // 1: Errors, 2: Warnings, 3: All logs
    host: util.CLOUD_HOST,
    port: util.CLOUD_PORT,
    key: 'peerjs',
    path: '/',
    token: util.randomToken(),
    config: util.defaultConfig
  }, options);
  this.options = options;
  // Detect relative URL host.
  if (options.host === '/') {
    options.host = window.location.hostname;
  }
  // Set path correctly.
  if (options.path[0] !== '/') {
    options.path = '/' + options.path;
  }
  if (options.path[options.path.length - 1] !== '/') {
    options.path += '/';
  }

  // Set whether we use SSL to same as current host
  if (options.secure === undefined && options.host !== util.CLOUD_HOST) {
    options.secure = util.isSecure();
  }
  // Set a custom log function if present
  if (options.logFunction) {
    util.setLogFunction(options.logFunction);
  }
  util.setLogLevel(options.debug);
  //

  // Sanity checks
  // Ensure WebRTC supported
  if (!util.supports.audioVideo && !util.supports.data ) {
    this._delayedAbort('browser-incompatible', 'The current browser does not support WebRTC');
    return;
  }
  // Ensure alphanumeric id
  if (!util.validateId(id)) {
    this._delayedAbort('invalid-id', 'ID "' + id + '" is invalid');
    return;
  }
  // Ensure valid key
  if (!util.validateKey(options.key)) {
    this._delayedAbort('invalid-key', 'API KEY "' + options.key + '" is invalid');
    return;
  }
  // Ensure not using unsecure cloud server on SSL page
  if (options.secure && options.host === '0.peerjs.com') {
    this._delayedAbort('ssl-unavailable',
      'The cloud server currently does not support HTTPS. Please run your own PeerServer to use HTTPS.');
    return;
  }
  //

  // States.
  this.destroyed = false; // Connections have been killed
  this.disconnected = false; // Connection to PeerServer killed but P2P connections still active
  this.open = false; // Sockets and such are not yet open.
  //

  // References
  this.connections = {}; // DataConnections for this peer.
  this._lostMessages = {}; // src => [list of messages]
  //

  // Start the server connection
  this._initializeServerConnection();
  if (id) {
    this._initialize(id);
  } else {
    this._retrieveId();
  }
  //
};

util.inherits(Peer, EventEmitter);

// Initialize the 'socket' (which is actually a mix of XHR streaming and
// websockets.)
Peer.prototype._initializeServerConnection = function() {
  var self = this;
  this.socket = new Socket(this.options.secure, this.options.host, this.options.port, this.options.path, this.options.key);
  this.socket.on('message', function(data) {
    self._handleMessage(data);
  });
  this.socket.on('error', function(error) {
    self._abort('socket-error', error);
  });
  this.socket.on('disconnected', function() {
    // If we haven't explicitly disconnected, emit error and disconnect.
    if (!self.disconnected) {
      self.emitError('network', 'Lost connection to server.')
      self.disconnect();
    }
  });
  this.socket.on('close', function() {
    // If we haven't explicitly disconnected, emit error.
    if (!self.disconnected) {
      self._abort('socket-closed', 'Underlying socket is already closed.');
    }
  });
};

/** Get a unique ID from the server via XHR. */
Peer.prototype._retrieveId = function(cb) {
  var self = this;
  var http = new XMLHttpRequest();
  var protocol = this.options.secure ? 'https://' : 'http://';
  var url = protocol + this.options.host + ':' + this.options.port
    + this.options.path + this.options.key + '/id';
  var queryString = '?ts=' + new Date().getTime() + '' + Math.random();
  url += queryString;

  // If there's no ID we need to wait for one before trying to init socket.
  http.open('get', url, true);
  http.onerror = function(e) {
    util.error('Error retrieving ID', e);
    var pathError = '';
    if (self.options.path === '/' && self.options.host !== util.CLOUD_HOST) {
      pathError = ' If you passed in a `path` to your self-hosted PeerServer, '
        + 'you\'ll also need to pass in that same path when creating a new'
        + ' Peer.';
    }
    self._abort('server-error', 'Could not get an ID from the server.' + pathError);
  }
  http.onreadystatechange = function() {
    if (http.readyState !== 4) {
      return;
    }
    if (http.status !== 200) {
      http.onerror();
      return;
    }
    self._initialize(http.responseText);
  };
  http.send(null);
};

/** Initialize a connection with the server. */
Peer.prototype._initialize = function(id) {
  this.id = id;
  this.socket.start(this.id, this.options.token);
}

/** Handles messages from the server. */
Peer.prototype._handleMessage = function(message) {
  var type = message.type;
  var payload = message.payload;
  var peer = message.src;

  switch (type) {
    case 'OPEN': // The connection to the server is open.
      this.emit('open', this.id);
      this.open = true;
      break;
    case 'ERROR': // Server error.
      this._abort('server-error', payload.msg);
      break;
    case 'ID-TAKEN': // The selected ID is taken.
      this._abort('unavailable-id', 'ID `' + this.id + '` is taken');
      break;
    case 'INVALID-KEY': // The given API key cannot be found.
      this._abort('invalid-key', 'API KEY "' + this.options.key + '" is invalid');
      break;

    //
    case 'LEAVE': // Another peer has closed its connection to this peer.
      util.log('Received leave message from', peer);
      this._cleanupPeer(peer);
      break;

    case 'EXPIRE': // The offer sent to a peer has expired without response.
      this.emitError('peer-unavailable', 'Could not connect to peer ' + peer);
      break;
    case 'OFFER': // we should consider switching this to CALL/CONNECT, but this is the least breaking option.
      var connectionId = payload.connectionId;
      var connection = this.getConnection(peer, connectionId);

      if (connection) {
        util.warn('Offer received for existing Connection ID:', connectionId);
        //connection.handleMessage(message);
      } else {
        // Create a new connection.
        if (payload.type === 'media') {
          var connection = new MediaConnection(peer, this, {
            connectionId: connectionId,
            _payload: payload,
            metadata: payload.metadata
          });
          this._addConnection(peer, connection);
          this.emit('call', connection);
        } else if (payload.type === 'data') {
          connection = new DataConnection(peer, this, {
            connectionId: connectionId,
            _payload: payload,
            metadata: payload.metadata,
            label: payload.label,
            serialization: payload.serialization,
            reliable: payload.reliable
          });
          this._addConnection(peer, connection);
          this.emit('connection', connection);
        } else {
          util.warn('Received malformed connection type:', payload.type);
          return;
        }
        // Find messages.
        var messages = this._getMessages(connectionId);
        for (var i = 0, ii = messages.length; i < ii; i += 1) {
          connection.handleMessage(messages[i]);
        }
      }
      break;
    default:
      if (!payload) {
        util.warn('You received a malformed message from ' + peer + ' of type ' + type);
        return;
      }

      var id = payload.connectionId;
      var connection = this.getConnection(peer, id);

      if (connection && connection.pc) {
        // Pass it on.
        connection.handleMessage(message);
      } else if (id) {
        // Store for possible later use
        this._storeMessage(id, message);
      } else {
        util.warn('You received an unrecognized message:', message);
      }
      break;
  }
}

/** Stores messages without a set up connection, to be claimed later. */
Peer.prototype._storeMessage = function(connectionId, message) {
  if (!this._lostMessages[connectionId]) {
    this._lostMessages[connectionId] = [];
  }
  this._lostMessages[connectionId].push(message);
}

/** Retrieve messages from lost message store */
Peer.prototype._getMessages = function(connectionId) {
  var messages = this._lostMessages[connectionId];
  if (messages) {
    delete this._lostMessages[connectionId];
    return messages;
  } else {
    return [];
  }
}

/**
 * Returns a DataConnection to the specified peer. See documentation for a
 * complete list of options.
 */
Peer.prototype.connect = function(peer, options) {
  if (this.disconnected) {
    util.warn('You cannot connect to a new Peer because you called '
        + '.disconnect() on this Peer and ended your connection with the'
        + ' server. You can create a new Peer to reconnect, or call reconnect'
        + ' on this peer if you believe its ID to still be available.');
    this.emitError('disconnected', 'Cannot connect to new Peer after disconnecting from server.');
    return;
  }
  var connection = new DataConnection(peer, this, options);
  this._addConnection(peer, connection);
  return connection;
}

/**
 * Returns a MediaConnection to the specified peer. See documentation for a
 * complete list of options.
 */
Peer.prototype.call = function(peer, stream, options) {
  if (this.disconnected) {
    util.warn('You cannot connect to a new Peer because you called '
        + '.disconnect() on this Peer and ended your connection with the'
        + ' server. You can create a new Peer to reconnect.');
    this.emitError('disconnected', 'Cannot connect to new Peer after disconnecting from server.');
    return;
  }
  if (!stream) {
    util.error('To call a peer, you must provide a stream from your browser\'s `getUserMedia`.');
    return;
  }
  options = options || {};
  options._stream = stream;
  var call = new MediaConnection(peer, this, options);
  this._addConnection(peer, call);
  return call;
}

/** Add a data/media connection to this peer. */
Peer.prototype._addConnection = function(peer, connection) {
  if (!this.connections[peer]) {
    this.connections[peer] = [];
  }
  this.connections[peer].push(connection);
}

/** Retrieve a data/media connection for this peer. */
Peer.prototype.getConnection = function(peer, id) {
  var connections = this.connections[peer];
  if (!connections) {
    return null;
  }
  for (var i = 0, ii = connections.length; i < ii; i++) {
    if (connections[i].id === id) {
      return connections[i];
    }
  }
  return null;
}

Peer.prototype._delayedAbort = function(type, message) {
  var self = this;
  util.setZeroTimeout(function(){
    self._abort(type, message);
  });
}

/**
 * Destroys the Peer and emits an error message.
 * The Peer is not destroyed if it's in a disconnected state, in which case
 * it retains its disconnected state and its existing connections.
 */
Peer.prototype._abort = function(type, message) {
  util.error('Aborting!');
  if (!this._lastServerId) {
    this.destroy();
  } else {
    this.disconnect();
  }
  this.emitError(type, message);
};

/** Emits a typed error message. */
Peer.prototype.emitError = function(type, err) {
  util.error('Error:', err);
  if (typeof err === 'string') {
    err = new Error(err);
  }
  err.type = type;
  this.emit('error', err);
};

/**
 * Destroys the Peer: closes all active connections as well as the connection
 *  to the server.
 * Warning: The peer can no longer create or accept connections after being
 *  destroyed.
 */
Peer.prototype.destroy = function() {
  if (!this.destroyed) {
    this._cleanup();
    this.disconnect();
    this.destroyed = true;
  }
}


/** Disconnects every connection on this peer. */
Peer.prototype._cleanup = function() {
  if (this.connections) {
    var peers = Object.keys(this.connections);
    for (var i = 0, ii = peers.length; i < ii; i++) {
      this._cleanupPeer(peers[i]);
    }
  }
  this.emit('close');
}

/** Closes all connections to this peer. */
Peer.prototype._cleanupPeer = function(peer) {
  var connections = this.connections[peer];
  for (var j = 0, jj = connections.length; j < jj; j += 1) {
    connections[j].close();
  }
}

/**
 * Disconnects the Peer's connection to the PeerServer. Does not close any
 *  active connections.
 * Warning: The peer can no longer create or accept connections after being
 *  disconnected. It also cannot reconnect to the server.
 */
Peer.prototype.disconnect = function() {
  var self = this;
  util.setZeroTimeout(function(){
    if (!self.disconnected) {
      self.disconnected = true;
      self.open = false;
      if (self.socket) {
        self.socket.close();
      }
      self.emit('disconnected', self.id);
      self._lastServerId = self.id;
      self.id = null;
    }
  });
}

/** Attempts to reconnect with the same ID. */
Peer.prototype.reconnect = function() {
  if (this.disconnected && !this.destroyed) {
    util.log('Attempting reconnection to server with ID ' + this._lastServerId);
    this.disconnected = false;
    this._initializeServerConnection();
    this._initialize(this._lastServerId);
  } else if (this.destroyed) {
    throw new Error('This peer cannot reconnect to the server. It has already been destroyed.');
  } else if (!this.disconnected && !this.open) {
    // Do nothing. We're still connecting the first time.
    util.error('In a hurry? We\'re still trying t