diff --git a/io.js b/io.js
deleted file mode 100644
index e044ed1..0000000
--- a/io.js
+++ /dev/null
@@ -1,483 +0,0 @@
-/*
- * io.js
- *
- * Provides readers for bit/byte streams (reading) and a byte buffer (writing).
- *
- * Licensed under the MIT License
- *
- * Copyright(c) 2011 Google Inc.
- * Copyright(c) 2011 antimatter15
- */
-
-var bitjs = bitjs || {};
-bitjs.io = bitjs.io || {};
-
-(function() {
-
-// mask for getting the Nth bit (zero-based)
-bitjs.BIT = [ 0x01, 0x02, 0x04, 0x08, 
-    0x10, 0x20, 0x40, 0x80,
-    0x100, 0x200, 0x400, 0x800, 
-    0x1000, 0x2000, 0x4000, 0x8000];
-
-// mask for getting N number of bits (0-8)
-var BITMASK = [0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF ];
-
-
-/**
- * This bit stream peeks and consumes bits out of a binary stream.
- *
- * @param {ArrayBuffer} ab An ArrayBuffer object or a Uint8Array.
- * @param {boolean} rtl Whether the stream reads bits from the byte starting
- *     from bit 7 to 0 (true) or bit 0 to 7 (false).
- * @param {Number} opt_offset The offset into the ArrayBuffer
- * @param {Number} opt_length The length of this BitStream
- */
-bitjs.io.BitStream = function(ab, rtl, opt_offset, opt_length) {
-  if (!ab || !ab.toString || ab.toString() !== "[object ArrayBuffer]") {
-    throw "Error! BitArray constructed with an invalid ArrayBuffer object";
-  }
-
-  var offset = opt_offset || 0;
-  var length = opt_length || ab.byteLength;
-  this.bytes = new Uint8Array(ab, offset, length);
-  this.bytePtr = 0; // tracks which byte we are on
-  this.bitPtr = 0; // tracks which bit we are on (can have values 0 through 7)
-  this.peekBits = rtl ? this.peekBits_rtl : this.peekBits_ltr;
-};
-
-
-/**
- *   byte0      byte1      byte2      byte3
- * 7......0 | 7......0 | 7......0 | 7......0
- * 
- * The bit pointer starts at bit0 of byte0 and moves left until it reaches
- * bit7 of byte0, then jumps to bit0 of byte1, etc.
- * @param {number} n The number of bits to peek.
- * @param {boolean=} movePointers Whether to move the pointer, defaults false.
- * @return {number} The peeked bits, as an unsigned number.
- */
-bitjs.io.BitStream.prototype.peekBits_ltr = function(n, movePointers) {
-  if (n <= 0 || typeof n != typeof 1) {
-    return 0;
-  }
-
-  var movePointers = movePointers || false,
-    bytePtr = this.bytePtr,
-    bitPtr = this.bitPtr,
-    result = 0,
-    bitsIn = 0,
-    bytes = this.bytes;
-
-  // keep going until we have no more bits left to peek at
-  // TODO: Consider putting all bits from bytes we will need into a variable and then
-  //       shifting/masking it to just extract the bits we want.
-  //       This could be considerably faster when reading more than 3 or 4 bits at a time.
-  while (n > 0) {
-    if (bytePtr >= bytes.length) {
-      throw "Error!  Overflowed the bit stream! n=" + n + ", bytePtr=" + bytePtr + ", bytes.length=" +
-        bytes.length + ", bitPtr=" + bitPtr;
-      return -1;
-    }
-
-    var numBitsLeftInThisByte = (8 - bitPtr);
-    if (n >= numBitsLeftInThisByte) {
-      var mask = (BITMASK[numBitsLeftInThisByte] << bitPtr);
-      result |= (((bytes[bytePtr] & mask) >> bitPtr) << bitsIn);
-
-      bytePtr++;
-      bitPtr = 0;
-      bitsIn += numBitsLeftInThisByte;
-      n -= numBitsLeftInThisByte;
-    }
-    else {
-      var mask = (BITMASK[n] << bitPtr);
-      result |= (((bytes[bytePtr] & mask) >> bitPtr) << bitsIn);
-
-      bitPtr += n;
-      bitsIn += n;
-      n = 0;
-    }
-  }
-
-  if (movePointers) {
-    this.bitPtr = bitPtr;
-    this.bytePtr = bytePtr;
-  }
-
-  return result;
-};
-
-
-/**
- *   byte0      byte1      byte2      byte3
- * 7......0 | 7......0 | 7......0 | 7......0
- *
- * The bit pointer starts at bit7 of byte0 and moves right until it reaches
- * bit0 of byte0, then goes to bit7 of byte1, etc.
- * @param {number} n The number of bits to peek.
- * @param {boolean=} movePointers Whether to move the pointer, defaults false.
- * @return {number} The peeked bits, as an unsigned number.
- */
-bitjs.io.BitStream.prototype.peekBits_rtl = function(n, movePointers) {
-  if (n <= 0 || typeof n != typeof 1) {
-    return 0;
-  }
-
-  var movePointers = movePointers || false,
-    bytePtr = this.bytePtr,
-    bitPtr = this.bitPtr,
-    result = 0,
-    bytes = this.bytes;
-
-  // keep going until we have no more bits left to peek at
-  // TODO: Consider putting all bits from bytes we will need into a variable and then
-  //       shifting/masking it to just extract the bits we want.
-  //       This could be considerably faster when reading more than 3 or 4 bits at a time.
-  while (n > 0) {
-  
-    if (bytePtr >= bytes.length) {
-      throw "Error!  Overflowed the bit stream! n=" + n + ", bytePtr=" + bytePtr + ", bytes.length=" +
-        bytes.length + ", bitPtr=" + bitPtr;
-      return -1;
-    }
-
-    var numBitsLeftInThisByte = (8 - bitPtr);
-    if (n >= numBitsLeftInThisByte) {
-      result <<= numBitsLeftInThisByte;
-      result |= (BITMASK[numBitsLeftInThisByte] & bytes[bytePtr]);
-      bytePtr++;
-      bitPtr = 0;
-      n -= numBitsLeftInThisByte;
-    }
-    else {
-      result <<= n;
-      result |= ((bytes[bytePtr] & (BITMASK[n] << (8 - n - bitPtr))) >> (8 - n - bitPtr));
-
-      bitPtr += n;
-      n = 0;
-    }
-  }
-
-  if (movePointers) {
-    this.bitPtr = bitPtr;
-    this.bytePtr = bytePtr;
-  }
-
-  return result;
-};
-
-
-/**
- * Some voodoo magic.
- */
-bitjs.io.BitStream.prototype.getBits = function() {
-  return (((((this.bytes[this.bytePtr] & 0xff) << 16) +
-              ((this.bytes[this.bytePtr+1] & 0xff) << 8) +
-              ((this.bytes[this.bytePtr+2] & 0xff))) >>> (8-this.bitPtr)) & 0xffff);
-};
-
-
-/**
- * Reads n bits out of the stream, consuming them (moving the bit pointer).
- * @param {number} n The number of bits to read.
- * @return {number} The read bits, as an unsigned number.
- */
-bitjs.io.BitStream.prototype.readBits = function(n) {
-  return this.peekBits(n, true);
-};
-
-
-/**
- * This returns n bytes as a sub-array, advancing the pointer if movePointers
- * is true.  Only use this for uncompressed blocks as this throws away remaining
- * bits in the current byte.
- * @param {number} n The number of bytes to peek.
- * @param {boolean=} movePointers Whether to move the pointer, defaults false.
- * @return {Uint8Array} The subarray.
- */
-bitjs.io.BitStream.prototype.peekBytes = function(n, movePointers) {
-  if (n <= 0 || typeof n != typeof 1) {
-    return 0;
-  }
-
-  // from http://tools.ietf.org/html/rfc1951#page-11
-  // "Any bits of input up to the next byte boundary are ignored."
-  while (this.bitPtr != 0) {
-    this.readBits(1);
-  }
-
-  var movePointers = movePointers || false;
-  var bytePtr = this.bytePtr,
-      bitPtr = this.bitPtr;
-
-  var result = this.bytes.subarray(bytePtr, bytePtr + n);
-
-  if (movePointers) {
-    this.bytePtr += n;
-  }
-
-  return result;
-};
-
-
-/**
- * @param {number} n The number of bytes to read.
- * @return {Uint8Array} The subarray.
- */
-bitjs.io.BitStream.prototype.readBytes = function(n) {
-  return this.peekBytes(n, true);
-};
-
-
-/**
- * This object allows you to peek and consume bytes as numbers and strings
- * out of an ArrayBuffer.  In this buffer, everything must be byte-aligned.
- *
- * @param {ArrayBuffer} ab The ArrayBuffer object.
- * @param {number=} opt_offset The offset into the ArrayBuffer
- * @param {number=} opt_length The length of this BitStream
- * @constructor
- */
-bitjs.io.ByteStream = function(ab, opt_offset, opt_length) {
-  var offset = opt_offset || 0;
-  var length = opt_length || ab.byteLength;
-  this.bytes = new Uint8Array(ab, offset, length);
-  this.ptr = 0;
-};
-
-
-/**
- * Peeks at the next n bytes as an unsigned number but does not advance the
- * pointer
- * TODO: This apparently cannot read more than 4 bytes as a number?
- * @param {number} n The number of bytes to peek at.
- * @return {number} The n bytes interpreted as an unsigned number.
- */
-bitjs.io.ByteStream.prototype.peekNumber = function(n) {
-  // TODO: return error if n would go past the end of the stream?
-  if (n <= 0 || typeof n != typeof 1)
-    return -1;
-
-  var result = 0;
-  // read from last byte to first byte and roll them in
-  var curByte = this.ptr + n - 1;
-  while (curByte >= this.ptr) {
-    result <<= 8;
-    result |= this.bytes[curByte];
-    --curByte;
-  }
-  return result;
-};
-
-
-/**
- * Returns the next n bytes as an unsigned number (or -1 on error)
- * and advances the stream pointer n bytes.
- * @param {number} n The number of bytes to read.
- * @return {number} The n bytes interpreted as an unsigned number.
- */
-bitjs.io.ByteStream.prototype.readNumber = function(n) {
-  var num = this.peekNumber( n );
-  this.ptr += n;
-  return num;
-};
-
-
-/**
- * Returns the next n bytes as a signed number but does not advance the
- * pointer.
- * @param {number} n The number of bytes to read.
- * @return {number} The bytes interpreted as a signed number.
- */
-bitjs.io.ByteStream.prototype.peekSignedNumber = function(n) {
-  var num = this.peekNumber(n);
-  var HALF = Math.pow(2, (n * 8) - 1);
-  var FULL = HALF * 2;
-
-  if (num >= HALF) num -= FULL;
-
-  return num;
-};
-
-
-/**
- * Returns the next n bytes as a signed number and advances the stream pointer.
- * @param {number} n The number of bytes to read.
- * @return {number} The bytes interpreted as a signed number.
- */
-bitjs.io.ByteStream.prototype.readSignedNumber = function(n) {
-  var num = this.peekSignedNumber(n);
-  this.ptr += n;
-  return num;
-};
-
-
-/**
- * This returns n bytes as a sub-array, advancing the pointer if movePointers
- * is true.
- * @param {number} n The number of bytes to read.
- * @param {boolean} movePointers Whether to move the pointers.
- * @return {Uint8Array} The subarray.
- */
-bitjs.io.ByteStream.prototype.peekBytes = function(n, movePointers) {
-  if (n <= 0 || typeof n != typeof 1) {
-    return null;
-  }
-
-  var result = this.bytes.subarray(this.ptr, this.ptr + n);
-
-  if (movePointers) {
-    this.ptr += n;
-  }
-
-  return result;
-};
-
-
-/**
- * Reads the next n bytes as a sub-array.
- * @param {number} n The number of bytes to read.
- * @return {Uint8Array} The subarray.
- */
-bitjs.io.ByteStream.prototype.readBytes = function(n) {
-  return this.peekBytes(n, true);
-};
-
-
-/**
- * Peeks at the next n bytes as a string but does not advance the pointer.
- * @param {number} n The number of bytes to peek at.
- * @return {string} The next n bytes as a string.
- */
-bitjs.io.ByteStream.prototype.peekString = function(n) {
-  if (n <= 0 || typeof n != typeof 1) {
-    return "";
-  }
-
-  var result = "";
-  for (var p = this.ptr, end = this.ptr + n; p < end; ++p) {
-    result += String.fromCharCode(this.bytes[p]);
-  }
-  return result;
-};
-
-
-/**
- * Returns the next n bytes as an ASCII string and advances the stream pointer
- * n bytes.
- * @param {number} n The number of bytes to read.
- * @return {string} The next n bytes as a string.
- */
-bitjs.io.ByteStream.prototype.readString = function(n) {
-  var strToReturn = this.peekString(n);
-  this.ptr += n;
-  return strToReturn;
-};
-
-
-/**
- * A write-only Byte buffer which uses a Uint8 Typed Array as a backing store.
- * @param {number} numBytes The number of bytes to allocate.
- * @constructor
- */
-bitjs.io.ByteBuffer = function(numBytes) {
-  if (typeof numBytes != typeof 1 || numBytes <= 0) {
-    throw "Error! ByteBuffer initialized with '" + numBytes + "'";
-  }
-  this.data = new Uint8Array(numBytes);
-  this.ptr = 0;
-};
-
-
-/**
- * @param {number} b The byte to insert.
- */
-bitjs.io.ByteBuffer.prototype.insertByte = function(b) {
-  // TODO: throw if byte is invalid?
-  this.data[this.ptr++] = b;
-};
-
-
-/**
- * @param {Array.<number>|Uint8Array|Int8Array} bytes The bytes to insert.
- */
-bitjs.io.ByteBuffer.prototype.insertBytes = function(bytes) {
-  // TODO: throw if bytes is invalid?
-  this.data.set(bytes, this.ptr);
-  this.ptr += bytes.length;
-};
-
-
-/**
- * Writes an unsigned number into the next n bytes.  If the number is too large
- * to fit into n bytes or is negative, an error is thrown.
- * @param {number} num The unsigned number to write.
- * @param {number} numBytes The number of bytes to write the number into.
- */
-bitjs.io.ByteBuffer.prototype.writeNumber = function(num, numBytes) {
-  if (numBytes < 1) {
-    throw 'Trying to write into too few bytes: ' + numBytes;
-  }
-  if (num < 0) {
-    throw 'Trying to write a negative number (' + num +
-        ') as an unsigned number to an ArrayBuffer';
-  }
-  if (num > (Math.pow(2, numBytes * 8) - 1)) {
-    throw 'Trying to write ' + num + ' into only ' + numBytes + ' bytes';
-  }
-
-  // Roll 8-bits at a time into an array of bytes.
-  var bytes = [];
-  while (numBytes-- > 0) {
-    var eightBits = num & 255;
-    bytes.push(eightBits);
-    num >>= 8;
-  }
-
-  this.insertBytes(bytes);
-};
-
-
-/**
- * Writes a signed number into the next n bytes.  If the number is too large
- * to fit into n bytes, an error is thrown.
- * @param {number} num The signed number to write.
- * @param {number} numBytes The number of bytes to write the number into.
- */
-bitjs.io.ByteBuffer.prototype.writeSignedNumber = function(num, numBytes) {
-  if (numBytes < 1) {
-    throw 'Trying to write into too few bytes: ' + numBytes;
-  }
-
-  var HALF = Math.pow(2, (numBytes * 8) - 1);
-  if (num >= HALF || num < -HALF) {
-    throw 'Trying to write ' + num + ' into only ' + numBytes + ' bytes';
-  }
-
-  // Roll 8-bits at a time into an array of bytes.
-  var bytes = [];
-  while (numBytes-- > 0) {
-    var eightBits = num & 255;
-    bytes.push(eightBits);
-    num >>= 8;
-  }
-
-  this.insertBytes(bytes);
-};
-
-
-/**
- * @param {string} str The ASCII string to write.
- */
-bitjs.io.ByteBuffer.prototype.writeASCIIString = function(str) {
-  for (var i = 0; i < str.length; ++i) {
-    var curByte = str.charCodeAt(i);
-    if (curByte < 0 || curByte > 255) {
-      throw 'Trying to write a non-ASCII string!';
-    }
-    this.insertByte(curByte);
-  }
-};
-
-})();
diff --git a/io/bitstream.js b/io/bitstream.js
new file mode 100644
index 0000000..f4e6b89
--- /dev/null
+++ b/io/bitstream.js
@@ -0,0 +1,232 @@
+/*
+ * bitstream.js
+ *
+ * Provides readers for bitstreams.
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ * Copyright(c) 2011 antimatter15
+ */
+
+var bitjs = bitjs || {};
+bitjs.io = bitjs.io || {};
+
+(function() {
+
+// mask for getting the Nth bit (zero-based)
+bitjs.BIT = [ 0x01, 0x02, 0x04, 0x08, 
+    0x10, 0x20, 0x40, 0x80,
+    0x100, 0x200, 0x400, 0x800, 
+    0x1000, 0x2000, 0x4000, 0x8000];
+
+// mask for getting N number of bits (0-8)
+var BITMASK = [0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF ];
+
+
+/**
+ * This bit stream peeks and consumes bits out of a binary stream.
+ *
+ * @param {ArrayBuffer} ab An ArrayBuffer object or a Uint8Array.
+ * @param {boolean} rtl Whether the stream reads bits from the byte starting
+ *     from bit 7 to 0 (true) or bit 0 to 7 (false).
+ * @param {Number} opt_offset The offset into the ArrayBuffer
+ * @param {Number} opt_length The length of this BitStream
+ */
+bitjs.io.BitStream = function(ab, rtl, opt_offset, opt_length) {
+  if (!ab || !ab.toString || ab.toString() !== "[object ArrayBuffer]") {
+    throw "Error! BitArray constructed with an invalid ArrayBuffer object";
+  }
+
+  var offset = opt_offset || 0;
+  var length = opt_length || ab.byteLength;
+  this.bytes = new Uint8Array(ab, offset, length);
+  this.bytePtr = 0; // tracks which byte we are on
+  this.bitPtr = 0; // tracks which bit we are on (can have values 0 through 7)
+  this.peekBits = rtl ? this.peekBits_rtl : this.peekBits_ltr;
+};
+
+
+/**
+ *   byte0      byte1      byte2      byte3
+ * 7......0 | 7......0 | 7......0 | 7......0
+ *
+ * The bit pointer starts at bit0 of byte0 and moves left until it reaches
+ * bit7 of byte0, then jumps to bit0 of byte1, etc.
+ * @param {number} n The number of bits to peek.
+ * @param {boolean=} movePointers Whether to move the pointer, defaults false.
+ * @return {number} The peeked bits, as an unsigned number.
+ */
+bitjs.io.BitStream.prototype.peekBits_ltr = function(n, movePointers) {
+  if (n <= 0 || typeof n != typeof 1) {
+    return 0;
+  }
+
+  var movePointers = movePointers || false,
+    bytePtr = this.bytePtr,
+    bitPtr = this.bitPtr,
+    result = 0,
+    bitsIn = 0,
+    bytes = this.bytes;
+
+  // keep going until we have no more bits left to peek at
+  // TODO: Consider putting all bits from bytes we will need into a variable and then
+  //       shifting/masking it to just extract the bits we want.
+  //       This could be considerably faster when reading more than 3 or 4 bits at a time.
+  while (n > 0) {
+    if (bytePtr >= bytes.length) {
+      throw "Error!  Overflowed the bit stream! n=" + n + ", bytePtr=" + bytePtr + ", bytes.length=" +
+        bytes.length + ", bitPtr=" + bitPtr;
+      return -1;
+    }
+
+    var numBitsLeftInThisByte = (8 - bitPtr);
+    if (n >= numBitsLeftInThisByte) {
+      var mask = (BITMASK[numBitsLeftInThisByte] << bitPtr);
+      result |= (((bytes[bytePtr] & mask) >> bitPtr) << bitsIn);
+
+      bytePtr++;
+      bitPtr = 0;
+      bitsIn += numBitsLeftInThisByte;
+      n -= numBitsLeftInThisByte;
+    }
+    else {
+      var mask = (BITMASK[n] << bitPtr);
+      result |= (((bytes[bytePtr] & mask) >> bitPtr) << bitsIn);
+
+      bitPtr += n;
+      bitsIn += n;
+      n = 0;
+    }
+  }
+
+  if (movePointers) {
+    this.bitPtr = bitPtr;
+    this.bytePtr = bytePtr;
+  }
+
+  return result;
+};
+
+
+/**
+ *   byte0      byte1      byte2      byte3
+ * 7......0 | 7......0 | 7......0 | 7......0
+ *
+ * The bit pointer starts at bit7 of byte0 and moves right until it reaches
+ * bit0 of byte0, then goes to bit7 of byte1, etc.
+ * @param {number} n The number of bits to peek.
+ * @param {boolean=} movePointers Whether to move the pointer, defaults false.
+ * @return {number} The peeked bits, as an unsigned number.
+ */
+bitjs.io.BitStream.prototype.peekBits_rtl = function(n, movePointers) {
+  if (n <= 0 || typeof n != typeof 1) {
+    return 0;
+  }
+
+  var movePointers = movePointers || false,
+    bytePtr = this.bytePtr,
+    bitPtr = this.bitPtr,
+    result = 0,
+    bytes = this.bytes;
+
+  // keep going until we have no more bits left to peek at
+  // TODO: Consider putting all bits from bytes we will need into a variable and then
+  //       shifting/masking it to just extract the bits we want.
+  //       This could be considerably faster when reading more than 3 or 4 bits at a time.
+  while (n > 0) {
+
+    if (bytePtr >= bytes.length) {
+      throw "Error!  Overflowed the bit stream! n=" + n + ", bytePtr=" + bytePtr + ", bytes.length=" +
+        bytes.length + ", bitPtr=" + bitPtr;
+      return -1;
+    }
+
+    var numBitsLeftInThisByte = (8 - bitPtr);
+    if (n >= numBitsLeftInThisByte) {
+      result <<= numBitsLeftInThisByte;
+      result |= (BITMASK[numBitsLeftInThisByte] & bytes[bytePtr]);
+      bytePtr++;
+      bitPtr = 0;
+      n -= numBitsLeftInThisByte;
+    }
+    else {
+      result <<= n;
+      result |= ((bytes[bytePtr] & (BITMASK[n] << (8 - n - bitPtr))) >> (8 - n - bitPtr));
+
+      bitPtr += n;
+      n = 0;
+    }
+  }
+
+  if (movePointers) {
+    this.bitPtr = bitPtr;
+    this.bytePtr = bytePtr;
+  }
+
+  return result;
+};
+
+
+/**
+ * Some voodoo magic.
+ */
+bitjs.io.BitStream.prototype.getBits = function() {
+  return (((((this.bytes[this.bytePtr] & 0xff) << 16) +
+              ((this.bytes[this.bytePtr+1] & 0xff) << 8) +
+              ((this.bytes[this.bytePtr+2] & 0xff))) >>> (8-this.bitPtr)) & 0xffff);
+};
+
+
+/**
+ * Reads n bits out of the stream, consuming them (moving the bit pointer).
+ * @param {number} n The number of bits to read.
+ * @return {number} The read bits, as an unsigned number.
+ */
+bitjs.io.BitStream.prototype.readBits = function(n) {
+  return this.peekBits(n, true);
+};
+
+
+/**
+ * This returns n bytes as a sub-array, advancing the pointer if movePointers
+ * is true.  Only use this for uncompressed blocks as this throws away remaining
+ * bits in the current byte.
+ * @param {number} n The number of bytes to peek.
+ * @param {boolean=} movePointers Whether to move the pointer, defaults false.
+ * @return {Uint8Array} The subarray.
+ */
+bitjs.io.BitStream.prototype.peekBytes = function(n, movePointers) {
+  if (n <= 0 || typeof n != typeof 1) {
+    return 0;
+  }
+
+  // from http://tools.ietf.org/html/rfc1951#page-11
+  // "Any bits of input up to the next byte boundary are ignored."
+  while (this.bitPtr != 0) {
+    this.readBits(1);
+  }
+
+  var movePointers = movePointers || false;
+  var bytePtr = this.bytePtr,
+      bitPtr = this.bitPtr;
+
+  var result = this.bytes.subarray(bytePtr, bytePtr + n);
+
+  if (movePointers) {
+    this.bytePtr += n;
+  }
+
+  return result;
+};
+
+
+/**
+ * @param {number} n The number of bytes to read.
+ * @return {Uint8Array} The subarray.
+ */
+bitjs.io.BitStream.prototype.readBytes = function(n) {
+  return this.peekBytes(n, true);
+};
+
+})();
diff --git a/io/bytebuffer.js b/io/bytebuffer.js
new file mode 100644
index 0000000..811d0ab
--- /dev/null
+++ b/io/bytebuffer.js
@@ -0,0 +1,122 @@
+/*
+ * bytestream.js
+ *
+ * Provides a writer for bytes.
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ * Copyright(c) 2011 antimatter15
+ */
+
+var bitjs = bitjs || {};
+bitjs.io = bitjs.io || {};
+
+(function() {
+
+
+/**
+ * A write-only Byte buffer which uses a Uint8 Typed Array as a backing store.
+ * @param {number} numBytes The number of bytes to allocate.
+ * @constructor
+ */
+bitjs.io.ByteBuffer = function(numBytes) {
+  if (typeof numBytes != typeof 1 || numBytes <= 0) {
+    throw "Error! ByteBuffer initialized with '" + numBytes + "'";
+  }
+  this.data = new Uint8Array(numBytes);
+  this.ptr = 0;
+};
+
+
+/**
+ * @param {number} b The byte to insert.
+ */
+bitjs.io.ByteBuffer.prototype.insertByte = function(b) {
+  // TODO: throw if byte is invalid?
+  this.data[this.ptr++] = b;
+};
+
+
+/**
+ * @param {Array.<number>|Uint8Array|Int8Array} bytes The bytes to insert.
+ */
+bitjs.io.ByteBuffer.prototype.insertBytes = function(bytes) {
+  // TODO: throw if bytes is invalid?
+  this.data.set(bytes, this.ptr);
+  this.ptr += bytes.length;
+};
+
+
+/**
+ * Writes an unsigned number into the next n bytes.  If the number is too large
+ * to fit into n bytes or is negative, an error is thrown.
+ * @param {number} num The unsigned number to write.
+ * @param {number} numBytes The number of bytes to write the number into.
+ */
+bitjs.io.ByteBuffer.prototype.writeNumber = function(num, numBytes) {
+  if (numBytes < 1) {
+    throw 'Trying to write into too few bytes: ' + numBytes;
+  }
+  if (num < 0) {
+    throw 'Trying to write a negative number (' + num +
+        ') as an unsigned number to an ArrayBuffer';
+  }
+  if (num > (Math.pow(2, numBytes * 8) - 1)) {
+    throw 'Trying to write ' + num + ' into only ' + numBytes + ' bytes';
+  }
+
+  // Roll 8-bits at a time into an array of bytes.
+  var bytes = [];
+  while (numBytes-- > 0) {
+    var eightBits = num & 255;
+    bytes.push(eightBits);
+    num >>= 8;
+  }
+
+  this.insertBytes(bytes);
+};
+
+
+/**
+ * Writes a signed number into the next n bytes.  If the number is too large
+ * to fit into n bytes, an error is thrown.
+ * @param {number} num The signed number to write.
+ * @param {number} numBytes The number of bytes to write the number into.
+ */
+bitjs.io.ByteBuffer.prototype.writeSignedNumber = function(num, numBytes) {
+  if (numBytes < 1) {
+    throw 'Trying to write into too few bytes: ' + numBytes;
+  }
+
+  var HALF = Math.pow(2, (numBytes * 8) - 1);
+  if (num >= HALF || num < -HALF) {
+    throw 'Trying to write ' + num + ' into only ' + numBytes + ' bytes';
+  }
+
+  // Roll 8-bits at a time into an array of bytes.
+  var bytes = [];
+  while (numBytes-- > 0) {
+    var eightBits = num & 255;
+    bytes.push(eightBits);
+    num >>= 8;
+  }
+
+  this.insertBytes(bytes);
+};
+
+
+/**
+ * @param {string} str The ASCII string to write.
+ */
+bitjs.io.ByteBuffer.prototype.writeASCIIString = function(str) {
+  for (var i = 0; i < str.length; ++i) {
+    var curByte = str.charCodeAt(i);
+    if (curByte < 0 || curByte > 255) {
+      throw 'Trying to write a non-ASCII string!';
+    }
+    this.insertByte(curByte);
+  }
+};
+
+})();
diff --git a/io/bytestream.js b/io/bytestream.js
new file mode 100644
index 0000000..a67a712
--- /dev/null
+++ b/io/bytestream.js
@@ -0,0 +1,164 @@
+/*
+ * bytestream.js
+ *
+ * Provides readers for byte streams.
+ *
+ * Licensed under the MIT License
+ *
+ * Copyright(c) 2011 Google Inc.
+ * Copyright(c) 2011 antimatter15
+ */
+
+var bitjs = bitjs || {};
+bitjs.io = bitjs.io || {};
+
+(function() {
+
+
+/**
+ * This object allows you to peek and consume bytes as numbers and strings
+ * out of an ArrayBuffer.  In this buffer, everything must be byte-aligned.
+ *
+ * @param {ArrayBuffer} ab The ArrayBuffer object.
+ * @param {number=} opt_offset The offset into the ArrayBuffer
+ * @param {number=} opt_length The length of this BitStream
+ * @constructor
+ */
+bitjs.io.ByteStream = function(ab, opt_offset, opt_length) {
+  var offset = opt_offset || 0;
+  var length = opt_length || ab.byteLength;
+  this.bytes = new Uint8Array(ab, offset, length);
+  this.ptr = 0;
+};
+
+
+/**
+ * Peeks at the next n bytes as an unsigned number but does not advance the
+ * pointer
+ * TODO: This apparently cannot read more than 4 bytes as a number?
+ * @param {number} n The number of bytes to peek at.
+ * @return {number} The n bytes interpreted as an unsigned number.
+ */
+bitjs.io.ByteStream.prototype.peekNumber = function(n) {
+  // TODO: return error if n would go past the end of the stream?
+  if (n <= 0 || typeof n != typeof 1)
+    return -1;
+
+  var result = 0;
+  // read from last byte to first byte and roll them in
+  var curByte = this.ptr + n - 1;
+  while (curByte >= this.ptr) {
+    result <<= 8;
+    result |= this.bytes[curByte];
+    --curByte;
+  }
+  return result;
+};
+
+
+/**
+ * Returns the next n bytes as an unsigned number (or -1 on error)
+ * and advances the stream pointer n bytes.
+ * @param {number} n The number of bytes to read.
+ * @return {number} The n bytes interpreted as an unsigned number.
+ */
+bitjs.io.ByteStream.prototype.readNumber = function(n) {
+  var num = this.peekNumber( n );
+  this.ptr += n;
+  return num;
+};
+
+
+/**
+ * Returns the next n bytes as a signed number but does not advance the
+ * pointer.
+ * @param {number} n The number of bytes to read.
+ * @return {number} The bytes interpreted as a signed number.
+ */
+bitjs.io.ByteStream.prototype.peekSignedNumber = function(n) {
+  var num = this.peekNumber(n);
+  var HALF = Math.pow(2, (n * 8) - 1);
+  var FULL = HALF * 2;
+
+  if (num >= HALF) num -= FULL;
+
+  return num;
+};
+
+
+/**
+ * Returns the next n bytes as a signed number and advances the stream pointer.
+ * @param {number} n The number of bytes to read.
+ * @return {number} The bytes interpreted as a signed number.
+ */
+bitjs.io.ByteStream.prototype.readSignedNumber = function(n) {
+  var num = this.peekSignedNumber(n);
+  this.ptr += n;
+  return num;
+};
+
+
+/**
+ * This returns n bytes as a sub-array, advancing the pointer if movePointers
+ * is true.
+ * @param {number} n The number of bytes to read.
+ * @param {boolean} movePointers Whether to move the pointers.
+ * @return {Uint8Array} The subarray.
+ */
+bitjs.io.ByteStream.prototype.peekBytes = function(n, movePointers) {
+  if (n <= 0 || typeof n != typeof 1) {
+    return null;
+  }
+
+  var result = this.bytes.subarray(this.ptr, this.ptr + n);
+
+  if (movePointers) {
+    this.ptr += n;
+  }
+
+  return result;
+};
+
+
+/**
+ * Reads the next n bytes as a sub-array.
+ * @param {number} n The number of bytes to read.
+ * @return {Uint8Array} The subarray.
+ */
+bitjs.io.ByteStream.prototype.readBytes = function(n) {
+  return this.peekBytes(n, true);
+};
+
+
+/**
+ * Peeks at the next n bytes as a string but does not advance the pointer.
+ * @param {number} n The number of bytes to peek at.
+ * @return {string} The next n bytes as a string.
+ */
+bitjs.io.ByteStream.prototype.peekString = function(n) {
+  if (n <= 0 || typeof n != typeof 1) {
+    return "";
+  }
+
+  var result = "";
+  for (var p = this.ptr, end = this.ptr + n; p < end; ++p) {
+    result += String.fromCharCode(this.bytes[p]);
+  }
+  return result;
+};
+
+
+/**
+ * Returns the next n bytes as an ASCII string and advances the stream pointer
+ * n bytes.
+ * @param {number} n The number of bytes to read.
+ * @return {string} The next n bytes as a string.
+ */
+bitjs.io.ByteStream.prototype.readString = function(n) {
+  var strToReturn = this.peekString(n);
+  this.ptr += n;
+  return strToReturn;
+};
+
+
+})();
diff --git a/io_test.html b/io/io_test.html
similarity index 92%
rename from io_test.html
rename to io/io_test.html
index 65429b9..a5413b8 100644
--- a/io_test.html
+++ b/io/io_test.html
@@ -2,8 +2,10 @@
 <html>
 <head>
     <title>Unit tests for bitjs.io.ByteStream and bitjs.io.ByteBuffer</title>
-    <script src="muther.js"></script>
-    <script src="io.js"></script>
+    <script src="../muther.js"></script>
+    <script src="bitstream.js"></script>
+    <script src="bytebuffer.js"></script>
+    <script src="bytestream.js"></script>
 </head>
 <body>
 <script>
diff --git a/unrar.js b/unrar.js
index 15273cd..bab0ddc 100644
--- a/unrar.js
+++ b/unrar.js
@@ -10,7 +10,8 @@
  */
 
 // This file expects to be invoked as a Worker (see onmessage below).
-importScripts('io.js');
+importScripts('io/bitstream.js');
+importScripts('io/bytebuffer.js');
 importScripts('archive.js');
 
 // Progress variables.
@@ -865,7 +866,7 @@ var unrar = function(arrayBuffer) {
         // extract the number at the end of both filenames
 			  /*
 			  var aindex = aname.length, bindex = bname.length;
-        
+
 			  // Find the last number character from the back of the filename.
 			  while (aname[aindex-1] < '0' || aname[aindex-1] > '9') --aindex;
 			  while (bname[bindex-1] < '0' || bname[bindex-1] > '9') --bindex;
@@ -873,7 +874,7 @@ var unrar = function(arrayBuffer) {
 			  // Find the first number character from the back of the filename
 			  while (aname[aindex-1] >= '0' && aname[aindex-1] <= '9') --aindex;
 			  while (bname[bindex-1] >= '0' && bname[bindex-1] <= '9') --bindex;
-			
+
 			  // parse them into numbers and return comparison
 			  var anum = parseInt(aname.substr(aindex), 10),
 				  bnum = parseInt(bname.substr(bindex), 10);
diff --git a/untar.js b/untar.js
index e95f416..cafd675 100644
--- a/untar.js
+++ b/untar.js
@@ -9,7 +9,7 @@
  */
 
 // This file expects to be invoked as a Worker (see onmessage below).
-importScripts('io.js');
+importScripts('io/bytestream.js');
 importScripts('archive.js');
 
 // Progress variables.
diff --git a/unzip.js b/unzip.js
index c346d7f..fc0ce3c 100644
--- a/unzip.js
+++ b/unzip.js
@@ -11,7 +11,9 @@
  */
 
 // This file expects to be invoked as a Worker (see onmessage below).
-importScripts('io.js');
+importScripts('io/bitstream.js');
+importScripts('io/bytebuffer.js');
+importScripts('io/bytestream.js');
 importScripts('archive.js');
 
 // Progress variables.
@@ -51,7 +53,7 @@ var ZipLocalFile = function(bstream) {
     if (typeof bstream != typeof {} || !bstream.readNumber || typeof bstream.readNumber != typeof function(){}) {
         return null;
     }
-    
+
     bstream.readNumber(4); // swallow signature
     this.version = bstream.readNumber(2);
     this.generalPurpose = bstream.readNumber(2);
@@ -63,12 +65,12 @@ var ZipLocalFile = function(bstream) {
     this.uncompressedSize = bstream.readNumber(4);
     this.fileNameLength = bstream.readNumber(2);
     this.extraFieldLength = bstream.readNumber(2);
-    
+
     this.filename = null;
     if (this.fileNameLength > 0) {
         this.filename = bstream.readString(this.fileNameLength);
     }
-    
+
     info("Zip Local File Header:");
     info(" version=" + this.version);
     info(" general purpose=" + this.generalPurpose);
@@ -81,20 +83,20 @@ var ZipLocalFile = function(bstream) {
     info(" file name length=" + this.fileNameLength);
     info(" extra field length=" + this.extraFieldLength);
     info(" filename = '" + this.filename + "'");
-    
+
     this.extraField = null;
     if (this.extraFieldLength > 0) {
         this.extraField = bstream.readString(this.extraFieldLength);
          info(" extra field=" + this.extraField);
     }
-    
+
     // read in the compressed data
     this.fileData = null;
     if (this.compressedSize > 0) {
         this.fileData = new Uint8Array(bstream.bytes.buffer, bstream.ptr, this.compressedSize);
         bstream.ptr += this.compressedSize;
     }
-    
+
     // TODO: deal with data descriptor if present (we currently assume no data descriptor!)
     // "This descriptor exists only if bit 3 of the general purpose bit flag is set"
     // But how do you figure out how big the file data is if you don't know the compressedSize
@@ -155,7 +157,7 @@ var unzip = function(arrayBuffer) {
             }
         }
         totalFilesInArchive = localFiles.length;
-        
+
         // got all local files, now sort them
         localFiles.sort(function(a,b) {
             var aname = a.filename;
@@ -175,7 +177,7 @@ var unzip = function(arrayBuffer) {
             // Find the first number character from the back of the filename
             while (aname[aindex-1] >= '0' && aname[aindex-1] <= '9') --aindex;
             while (bname[bindex-1] >= '0' && bname[bindex-1] <= '9') --bindex;
-            
+
             // parse them into numbers and return comparison
             var anum = parseInt(aname.substr(aindex), 10),
                 bnum = parseInt(bname.substr(bindex), 10);
@@ -192,7 +194,7 @@ var unzip = function(arrayBuffer) {
             var archiveExtraFieldLength = bstream.readNumber(4);
             bstream.readString(archiveExtraFieldLength);
         }
-        
+
         // central directory structure
         // TODO: handle the rest of the structures (Zip64 stuff)
         if (bstream.peekNumber(4) == zCentralFileHeaderSignature) {
@@ -217,13 +219,13 @@ var unzip = function(arrayBuffer) {
                 bstream.readNumber(2); // internal file attributes
                 bstream.readNumber(4); // external file attributes
                 bstream.readNumber(4); // relative offset of local header
-                
+
                 bstream.readString(fileNameLength); // file name
                 bstream.readString(extraFieldLength); // extra field
-                bstream.readString(fileCommentLength); // file comment              
+                bstream.readString(fileCommentLength); // file comment
             }
         }
-        
+
         // digital signature
         if (bstream.peekNumber(4) == zDigitalSignatureSignature) {
             info(" Found a Digital Signature");
@@ -232,24 +234,24 @@ var unzip = function(arrayBuffer) {
             var sizeOfSignature = bstream.readNumber(2);
             bstream.readString(sizeOfSignature); // digital signature data
         }
-        
+
         // report # files and total length
         if (localFiles.length > 0) {
             postProgress();
         }
-        
+
         // now do the unzipping of each file
         for (var i = 0; i < localFiles.length; ++i) {
             var localfile = localFiles[i];
-            
-            // update progress 
+
+            // update progress
             currentFilename = localfile.filename;
             currentFileNumber = i;
             currentBytesUnarchivedInFile = 0;
-            
+
             // actually do the unzipping
             localfile.unzip();
-            
+
             if (localfile.fileData != null) {
                 postMessage(new bitjs.archive.UnarchiveExtractEvent(localfile));
                 postProgress();
@@ -269,12 +271,12 @@ function getHuffmanCodes(bitLengths) {
         err("Error! getHuffmanCodes() called with an invalid array");
         return null;
     }
-    
+
     // Reference: http://tools.ietf.org/html/rfc1951#page-8
     var numLengths = bitLengths.length,
         bl_count = [],
         MAX_BITS = 1;
-    
+
     // Step 1: count up how many codes of each length we have
     for (var i = 0; i < numLengths; ++i) {
         var length = bitLengths[i];
@@ -287,10 +289,10 @@ function getHuffmanCodes(bitLengths) {
         if (bl_count[length] == undefined) bl_count[length] = 0;
         // a length of zero means this symbol is not participating in the huffman coding
         if (length > 0) bl_count[length]++;
-        
+
         if (length > MAX_BITS) MAX_BITS = length;
     }
-    
+
     // Step 2: Find the numerical value of the smallest code for each code length
     var next_code = [],
         code = 0;
@@ -301,7 +303,7 @@ function getHuffmanCodes(bitLengths) {
         code = (code + bl_count[bits-1]) << 1;
         next_code[bits] = code;
     }
-    
+
     // Step 3: Assign numerical values to all codes
     var table = {}, tableLength = 0;
     for (var n = 0; n < numLengths; ++n) {
@@ -313,7 +315,7 @@ function getHuffmanCodes(bitLengths) {
         }
     }
     table.maxLength = tableLength;
-    
+
     return table;
 }
 
@@ -321,7 +323,7 @@ function getHuffmanCodes(bitLengths) {
      The Huffman codes for the two alphabets are fixed, and are not
      represented explicitly in the data.  The Huffman code lengths
      for the literal/length alphabet are:
-    
+
                Lit Value    Bits        Codes
                ---------    ----        -----
                  0 - 143     8          00110000 through
@@ -344,18 +346,19 @@ function getFixedLiteralTable() {
         for (i = 144; i <= 255; ++i) bitlengths[i] = 9;
         for (i = 256; i <= 279; ++i) bitlengths[i] = 7;
         for (i = 280; i <= 287; ++i) bitlengths[i] = 8;
-        
+
         // get huffman code table
         fixedHCtoLiteral = getHuffmanCodes(bitlengths);
     }
     return fixedHCtoLiteral;
 }
+
 function getFixedDistanceTable() {
     // create once
     if (!fixedHCtoDistance) {
         var bitlengths = new Array(32);
         for (var i = 0; i < 32; ++i) { bitlengths[i] = 5; }
-        
+
         // get huffman code table
         fixedHCtoDistance = getHuffmanCodes(bitlengths);
     }
@@ -367,21 +370,20 @@ function getFixedDistanceTable() {
 function decodeSymbol(bstream, hcTable) {
     var code = 0, len = 0;
     var match = false;
-    
+
     // loop until we match
     for (;;) {
         // read in next bit
         var bit = bstream.readBits(1);
         code = (code<<1) | bit;
         ++len;
-        
+
         // check against Huffman Code table and break if found
         if (hcTable.hasOwnProperty(code) && hcTable[code].length == len) {
-        
             break;
         }
         if (len > hcTable.maxLength) {
-            err("Bit stream out of sync, didn't find a Huffman Code, length was " + len + 
+            err("Bit stream out of sync, didn't find a Huffman Code, length was " + len +
                 " and table only max code length of " + hcTable.maxLength);
             break;
         }
@@ -405,7 +407,6 @@ var CodeLengthCodeOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2
      264   0    10       274   3   43-50     284   5  227-257
      265   1  11,12      275   3   51-58     285   0    258
      266   1  13,14      276   3   59-66
-     
     */
 var LengthLookupTable = [
         [0,3], [0,4], [0,5], [0,6],
@@ -488,13 +489,13 @@ function inflateBlockData(bstream, hcLiteralTable, hcDistanceTable, buffer) {
                 // now apply length and distance appropriately and copy to output
 
                 // TODO: check that backward distance < data.length?
-                
+
                 // http://tools.ietf.org/html/rfc1951#page-11
                 // "Note also that the referenced string may overlap the current
                 //  position; for example, if the last 2 bytes decoded have values
                 //  X and Y, a string reference with <length = 5, distance = 2>
                 //  adds X,Y,X,Y,X to the output stream."
-                // 
+                //
                 // loop for each character
                 var ch = buffer.ptr - distance;
                 blockSize += length;
@@ -506,7 +507,6 @@ function inflateBlockData(bstream, hcLiteralTable, hcDistanceTable, buffer) {
                 } else {
                   buffer.insertBytes(buffer.data.subarray(ch, ch + length))
                 }
-                
             } // length-distance pair
         } // length-distance pair or end-of-block
     } // loop until we reach end of block
@@ -538,7 +538,6 @@ function inflate(compressedData, numDecompressedBytes) {
             var len = bstream.readBits(16),
                 nlen = bstream.readBits(16);
             // TODO: check if nlen is the ones-complement of len?
-            
             if(len > 0) buffer.insertBytes(bstream.readBytes(len));
             blockSize = len;
         }
@@ -551,17 +550,17 @@ function inflate(compressedData, numDecompressedBytes) {
             var numLiteralLengthCodes = bstream.readBits(5) + 257;
             var numDistanceCodes = bstream.readBits(5) + 1,
                 numCodeLengthCodes = bstream.readBits(4) + 4;
-                
-            // populate the array of code length codes (first de-compaction)        
+
+            // populate the array of code length codes (first de-compaction)
             var codeLengthsCodeLengths = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
             for (var i = 0; i < numCodeLengthCodes; ++i) {
                 codeLengthsCodeLengths[ CodeLengthCodeOrder[i] ] = bstream.readBits(3);
             }
-            
+
             // get the Huffman Codes for the code lengths
             var codeLengthsCodes = getHuffmanCodes(codeLengthsCodeLengths);
-            
-            // now follow this mapping 
+
+            // now follow this mapping
             /*
                0 - 15: Represent code lengths of 0 - 15
                    16: Copy the previous code length 3 - 6 times.
@@ -604,10 +603,10 @@ function inflate(compressedData, numDecompressedBytes) {
                     }
                 }
             }
-            
+
             // now split the distance code lengths out of the literal code array
             var distanceCodeLengths = literalCodeLengths.splice(numLiteralLengthCodes, numDistanceCodes);
-            
+
             // now generate the true Huffman Code tables using these code lengths
             var hcLiteralTable = getHuffmanCodes(literalCodeLengths),
                 hcDistanceTable = getHuffmanCodes(distanceCodeLengths);
@@ -623,10 +622,9 @@ function inflate(compressedData, numDecompressedBytes) {
         currentBytesUnarchivedInFile += blockSize;
         currentBytesUnarchived += blockSize;
         postProgress();
-
   } while (bFinal != 1);
   // we are done reading blocks if the bFinal bit was set for this block
-    
+
   // return the buffer data bytes
   return buffer.data;
 }