From e3ad57821ba0d09b0040874978fe737557278a26 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Thu, 11 Aug 2011 19:35:56 -0500
Subject: [PATCH 01/19] Add simple test runner.

---
 test/index.js | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 test/index.js

diff --git a/test/index.js b/test/index.js
new file mode 100644
index 0000000..c362d60
--- /dev/null
+++ b/test/index.js
@@ -0,0 +1,48 @@
+var exp = {};
+var merge = function(what) {
+  Object.keys(what).forEach(function(key) {
+    exp[key] = what[key]
+  })
+}
+merge(require('./delta_test'))
+merge(require('./diff_test'))
+merge(require('./http_remote_test'))
+merge(require('./jsgit_test'))
+merge(require('./memory_repo_test'))
+merge(require('./object_test'))
+merge(require('./pack_file_test'))
+merge(require('./pack_index_test'))
+merge(require('./remote_test'))
+merge(require('./smart_http_remote_test'))
+
+var assert = require('assert');
+
+var tests = Object.keys(exp).map(function(key) {
+    return Object.keys(this[key]).map(function(test) {
+      return [key + ' / '+ test, this[test].bind(this, assert)];
+    }, this[key]);
+}, exp).reduce(function(lhs, rhs) {
+  return lhs.concat(rhs);
+}, []);
+
+
+var recurse = function() {
+  if(!tests.length)
+    return;
+  else {
+    try {
+      tests.shift()[1]()
+    } catch(err) {
+      process.stderr.write('F');
+      recurse()
+    }
+  }
+};
+
+assert.equals = assert.equal
+assert.done = function() {
+  process.stderr.write('.');
+  recurse();
+};
+
+recurse()

From 12fdf26942eb0c74b7c7644bfc81f6db557874e6 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Thu, 11 Aug 2011 20:12:21 -0500
Subject: [PATCH 02/19] Tests run using 'node test/index.js' now.

---
 test/diff_test.js        | 34 ++++++++++++++++----------------
 test/index.js            | 42 ++++++++++++++++++++++++++++++++++++----
 test/memory_repo_test.js | 10 +++++++---
 3 files changed, 62 insertions(+), 24 deletions(-)

diff --git a/test/diff_test.js b/test/diff_test.js
index 568c3c5..59a40f1 100644
--- a/test/diff_test.js
+++ b/test/diff_test.js
@@ -5,7 +5,7 @@ exports.NullEndpoints = {
   "null start": function(test) {
     var file1 = ""
     var file2 = ["a", "b", "c"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -19,7 +19,7 @@ exports.NullEndpoints = {
   "null end": function(test) {
     var file1 = ["a", "b", "c"].join("\n")
     var file2 = ""
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -36,7 +36,7 @@ exports.SingleHunk = {
   "additions at end": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "c", "d", "e", "f", "g", "h"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 7, 
@@ -53,7 +53,7 @@ exports.SingleHunk = {
   "additions at beginning": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["0", "1", "a", "b", "c", "d", "e", "f"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -70,7 +70,7 @@ exports.SingleHunk = {
   "additions in middle": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "c", "0", "1", "d", "e", "f"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 4, 
@@ -90,7 +90,7 @@ exports.SingleHunk = {
   "removals at end": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "c", "d"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 5, 
@@ -107,7 +107,7 @@ exports.SingleHunk = {
   "removals at beginning": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["c", "d", "e", "f"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -124,7 +124,7 @@ exports.SingleHunk = {
   "removals in middle": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "e", "f"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -142,7 +142,7 @@ exports.SingleHunk = {
   "added and removed in middle of same length": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "0", "1", "e", "f"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -162,7 +162,7 @@ exports.SingleHunk = {
   "more added than removed": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "0", "1", "2", "3", "e", "f"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -184,7 +184,7 @@ exports.SingleHunk = {
   "more removed than added": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "0", "1", "f"].join("\n")
-    var diff = new Git.Diff(file1, file2)
+    var diff = new Git.FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -206,7 +206,7 @@ exports.MultipleSeparateHunks = {
   "added then added": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy4567zq89".split("").join("\n")
-    var diff = new Git.Diff(file1, file2, {context: 1})
+    var diff = new Git.FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 4, 
@@ -231,7 +231,7 @@ exports.MultipleSeparateHunks = {
   "removed then removed": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "1345689".split("").join("\n")
-    var diff = new Git.Diff(file1, file2, {context: 1})
+    var diff = new Git.FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 2, 
@@ -254,7 +254,7 @@ exports.MultipleSeparateHunks = {
   "added then removed": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy45689".split("").join("\n")
-    var diff = new Git.Diff(file1, file2, {context: 1})
+    var diff = new Git.FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 4, 
@@ -278,7 +278,7 @@ exports.MultipleSeparateHunks = {
   "removed then added": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "134567xq89".split("").join("\n")
-    var diff = new Git.Diff(file1, file2, {context: 1})
+    var diff = new Git.FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 2, 
@@ -304,7 +304,7 @@ exports.MultipleConnectedHunks = {
   "overlap by 1": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy4zq56789".split("").join("\n")
-    var diff = new Git.Diff(file1, file2, {context: 1})
+    var diff = new Git.FileDiff(file1, file2, {context: 1})
     test.equal(diff.info.length, 1)
     test.deepEqual(
       diff.info[0], 
@@ -324,7 +324,7 @@ exports.MultipleConnectedHunks = {
   "overlap by 2": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy4zq56789".split("").join("\n")
-    var diff = new Git.Diff(file1, file2, {context: 2})
+    var diff = new Git.FileDiff(file1, file2, {context: 2})
     test.equal(diff.info.length, 1)
     test.deepEqual(
       diff.info[0], 
diff --git a/test/index.js b/test/index.js
index c362d60..3f772b6 100644
--- a/test/index.js
+++ b/test/index.js
@@ -15,7 +15,9 @@ merge(require('./pack_index_test'))
 merge(require('./remote_test'))
 merge(require('./smart_http_remote_test'))
 
+var trace = require('tracejs').trace;
 var assert = require('assert');
+var errors = [];
 
 var tests = Object.keys(exp).map(function(key) {
     return Object.keys(this[key]).map(function(test) {
@@ -25,15 +27,47 @@ var tests = Object.keys(exp).map(function(key) {
   return lhs.concat(rhs);
 }, []);
 
+var total = tests.length;
+var start = Date.now();
+
+var finish = function() {
+  process.stderr.write('\n');
+  var last = null;
+  errors.forEach(function(error) {
+    var name  = error[0]
+      , err   = error[1];
+
+    if(last !== name) {
+      console.error(' in '+name+':');
+      last = name;
+    }
+
+    var stack = trace(err);
+    process.stderr.write('\t'+err+'\n');
+    stack.frames.forEach(function(frame) {
+      if(frame) {
+        process.stderr.write(frame.filename.replace(process.cwd(), '.')+' on line '+frame.line+' \n')
+        process.stderr.write(frame.get_lines(1,1).replace(/\n/g, '\t\n')+'\n')
+      }
+    });
+  });
+
+  process.stderr.write('\n('+(total-errors.length)+' / '+total+') in '+(Date.now() - start)+'ms\n');
+  return process.exit(errors.length)
+};
 
 var recurse = function() {
   if(!tests.length)
-    return;
+    return finish();
   else {
+    var next = tests.shift()
+      , name = next[0]
+      , test = next[1];
     try {
-      tests.shift()[1]()
+      test()
     } catch(err) {
-      process.stderr.write('F');
+      process.stderr.write('F')
+      errors.push([name, err])
       recurse()
     }
   }
@@ -45,4 +79,4 @@ assert.done = function() {
   recurse();
 };
 
-recurse()
+return recurse()
diff --git a/test/memory_repo_test.js b/test/memory_repo_test.js
index e2e6ab6..8284b38 100644
--- a/test/memory_repo_test.js
+++ b/test/memory_repo_test.js
@@ -41,8 +41,12 @@ exports.MemoryRepo = {
     repo.makeAndAddObject("asdfasdf", "blob", "Hello World!")
     
     test.equals(repo.objectCount(), 1)
-    test.deepEqual(repo.getObject("asdfasdf").type, "blob")
-    test.deepEqual(repo.getObject("asdfasdf").data, "Hello World!")
+    repo.getObject("asdfasdf", function(err, obj) {
+      test.deepEqual(obj.type, "blob"); 
+    })
+    repo.getObject("asdfasdf", function(err, obj) {
+      test.deepEqual(obj.data, 'Hello World!');      
+    })
     test.done()
   }
 }
@@ -66,4 +70,4 @@ exports.GithubProxyRepo = {
     test.done()
   },
   
-}
\ No newline at end of file
+}

From 65eee205d8e83715e1778c1e6221b821831e2a89 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Thu, 11 Aug 2011 21:17:17 -0500
Subject: [PATCH 03/19] Add package.json.

---
 package.json | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 package.json

diff --git a/package.json b/package.json
new file mode 100644
index 0000000..3a0c94f
--- /dev/null
+++ b/package.json
@@ -0,0 +1,29 @@
+
+{
+    "name" : "git.js",
+    "version" : "0.0.1",
+    "description" : "pure javascript implementation of git",
+    "directories" : {
+        "lib" : ".",
+        "test" : "test"
+    },
+    "dependencies" : {
+    },
+    "devDependencies" : {
+        "tracejs" : "0.X.X"
+    },
+    "scripts" : {
+        "test" : "node test/index.js"
+    },
+    "repository" : {
+        "type" : "git",
+        "url" : "http://github.com/danlucraft/git.js.git"
+    },
+    "keywords" : [
+        "git",
+        "client",
+        "server"
+    ],
+    "license" : "MIT",
+    "engine" : { "node" : ">=0.4" }
+}

From 3927842f6ec15847e773edf3c5cebe2b67426b68 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Thu, 11 Aug 2011 21:25:48 -0500
Subject: [PATCH 04/19] Remove deprecated 'require.paths' modification, change
 to relative paths for require.

---
 lib/git-server.js | 46 ++++++++++++++++++++++------------------------
 1 file changed, 22 insertions(+), 24 deletions(-)

diff --git a/lib/git-server.js b/lib/git-server.js
index a244225..587e4d0 100644
--- a/lib/git-server.js
+++ b/lib/git-server.js
@@ -1,7 +1,5 @@
 var path = require('path')
 
-require.paths.unshift(__dirname)
-
 window = global
 jsGitInNode = true
 
@@ -12,28 +10,28 @@ require('../vendor/sha1')
 require('../vendor/sha2')
 require('../vendor/md5')
 require('../vendor/diff')
-require('string_helpers')
-require('binary_file')
-require('git')
-require('git/upload_pack_parser')
-require('git/pack')
-require('git/remote')
-require('git/http_remote')
-require('git/smart_http_remote')
-require('git/objects')
-require('git/file-diff')
-require('git/tree-diff')
-require('git/delta')
-require('git/pack_index')
-require('git/cli')
-require('git/memory_repo')
+require('./string_helpers')
+require('./binary_file')
+require('./git')
+require('./git/upload_pack_parser')
+require('./git/pack')
+require('./git/remote')
+require('./git/http_remote')
+require('./git/smart_http_remote')
+require('./git/objects')
+require('./git/file-diff')
+require('./git/tree-diff')
+require('./git/delta')
+require('./git/pack_index')
+require('./git/cli')
+require('./git/memory_repo')
 
 // Only for server
-require('git/repo')
-require('git/command-runner')
-require('git/commands/show-command')
-require('git/commands/branch-command')
-require('git/commands/log-command')
-require('git/commands/diff-command')
-require('git/pack-file')
+require('./git/repo')
+require('./git/command-runner')
+require('./git/commands/show-command')
+require('./git/commands/branch-command')
+require('./git/commands/log-command')
+require('./git/commands/diff-command')
+require('./git/pack-file')
 

From 8b9fd6ebc027bc40546878d6df093ebb65b3e0de Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Fri, 12 Aug 2011 01:46:49 -0500
Subject: [PATCH 05/19] Refactor to use CommonJS idioms.

    - Holy god, I'm sorry for this patchbomb.
    - This also includes some other fixes. Sorry.

        * the author parser in lib/git/objects.js only matched one side of UTC (+0000 vs -0000).
        * the repo branch collector failed on branch names that contain a slash (e.g, "feature/refactor", etc).

    - All tests pass.
    - All client commands seem to still work.
---
 bin/git.js                         |   4 +-
 lib/binary_file.js                 | 198 +++++-----
 lib/git-server.js                  |   4 +-
 lib/git.js                         |  97 +++--
 lib/git/cli.js                     |  91 ++---
 lib/git/command-runner.js          |  49 +--
 lib/git/commands/branch-command.js |   6 +-
 lib/git/commands/diff-command.js   |  46 ++-
 lib/git/commands/log-command.js    |   9 +-
 lib/git/commands/show-command.js   |   6 +-
 lib/git/delta.js                   |  14 +-
 lib/git/file-diff.js               | 242 ++++++------
 lib/git/github_repo.js             |  10 +
 lib/git/http_remote.js             |  46 +--
 lib/git/memory_repo.js             | 169 ++++-----
 lib/git/objects.js                 |  19 +-
 lib/git/pack-file.js               |  75 ++--
 lib/git/pack.js                    | 573 +++++++++++++++--------------
 lib/git/pack_index.js              | 209 ++++++-----
 lib/git/remote.js                  | 134 +++----
 lib/git/repo.js                    | 307 +++++++++-------
 lib/git/smart_http_remote.js       |  33 +-
 lib/git/tree-diff.js               | 386 +++++++++----------
 lib/git/upload_pack_parser.js      |  22 +-
 lib/git/utils.js                   |  52 +++
 test/delta_test.js                 |   8 +-
 test/diff_test.js                  |  37 +-
 test/http_remote_test.js           |  11 +-
 test/index.js                      |   8 +-
 test/jsgit_test.js                 |  25 +-
 test/memory_repo_test.js           |  15 +-
 test/object_test.js                |  20 +-
 test/pack_file_test.js             |  10 +-
 test/pack_index_test.js            |  27 +-
 test/remote_test.js                |  22 +-
 test/smart_http_remote_test.js     |   7 +-
 vendor/diff.js                     |   4 +-
 vendor/js-deflate/rawdeflate.js    |   3 +-
 vendor/js-deflate/rawinflate.js    |   3 +-
 vendor/sha1.js                     |   5 +-
 vendor/sha2.js                     |   2 +-
 41 files changed, 1546 insertions(+), 1462 deletions(-)
 create mode 100644 lib/git/github_repo.js
 create mode 100644 lib/git/utils.js

diff --git a/bin/git.js b/bin/git.js
index e48bdde..5126de6 100755
--- a/bin/git.js
+++ b/bin/git.js
@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
-require('../lib/git-server')
+var Cli = require('../lib/git/cli')
 
 // Get rid of process runner ('node' in most cases)
 var arg, args = [], argv = process.argv.slice(2);
 
-var cli = new Git.Cli(argv)
+var cli = new Cli(argv)
 cli.run()
 
diff --git a/lib/binary_file.js b/lib/binary_file.js
index d66dbf9..38d7cac 100644
--- a/lib/binary_file.js
+++ b/lib/binary_file.js
@@ -1,99 +1,117 @@
+var btoa = this.btoa || require('./btoa');
 
-BinaryFile = function(strData, iDataOffset, iDataLength) {
-	var data = strData;
-	var dataOffset = iDataOffset || 0;
-	var dataLength = 0;
+// these are created (dynamically!) via
+// a <script type="text/vbscript"> insertion.
+var IEBinary_getLength = this.IEBinary_getLength
+ ,  IEBinary_getByteAt = this.IEBinary_getByteAt;
 
-	this.getRawData = function() {
-		return data;
-	}
-  
-  this.slice = function(begin, optionalEnd) {
-    var arr = [];
-    var end = optionalEnd || this.getLength();
-    var i;
-    for (i = begin; i < end; i++) {
-      arr.push(this.getByteAt(i));
-    }
-    return arr;
-  }
+BinaryFile = function(strData, iDataOffset, iDataLength) {
+	this.data = strData;
+	this.dataOffset = iDataOffset || 0;
+	this.dataLength = 0;
   
   if (typeof strData == "string") {
-		dataLength = iDataLength || data.length;
-
-		this.getByteAt = function(iOffset) {
-			return data.charCodeAt(iOffset + dataOffset) & 0xFF;
-		}
+		this.dataLength = iDataLength || this.data.length;
+		this.getByteAt = this.getByteAt_CharCode;
 	} else if (typeof strData == "unknown") {
-		dataLength = iDataLength || IEBinary_getLength(data);
-
-		this.getByteAt = function(iOffset) {
-			return IEBinary_getByteAt(data, iOffset + dataOffset);
-		}
+		this.dataLength = iDataLength || IEBinary_getLength(this.data);
+    this.getByteAt = this.getByteAt_IEBinary;
   } else {
-    throw(Error("BinaryFile was given a " + (typeof strData) + " and doesn't know what to do with it"))
+    throw new Error(
+      "BinaryFile was given a " + (typeof strData) + " and doesn't know what to do with it"
+    );
   }
+};
 
-	this.getLength = function() {
-		return dataLength;
-	}
-
-	this.getSByteAt = function(iOffset) {
-		var iByte = this.getByteAt(iOffset);
-		if (iByte > 127)
-			return iByte - 256;
-		else
-			return iByte;
-	}
-
-	this.getShortAt = function(iOffset, bBigEndian) {
-		var iShort = bBigEndian ? 
-			(this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1)
-			: (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset)
-		if (iShort < 0) iShort += 65536;
-		return iShort;
-	}
-	this.getSShortAt = function(iOffset, bBigEndian) {
-		var iUShort = this.getShortAt(iOffset, bBigEndian);
-		if (iUShort > 32767)
-			return iUShort - 65536;
-		else
-			return iUShort;
-	}
-	this.getLongAt = function(iOffset, bBigEndian) {
-		var iByte1 = this.getByteAt(iOffset),
-			iByte2 = this.getByteAt(iOffset + 1),
-			iByte3 = this.getByteAt(iOffset + 2),
-			iByte4 = this.getByteAt(iOffset + 3);
-
-		var iLong = bBigEndian ? 
-			(((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4
-			: (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1;
-		if (iLong < 0) iLong += 4294967296;
-		return iLong;
-	}
-	this.getSLongAt = function(iOffset, bBigEndian) {
-		var iULong = this.getLongAt(iOffset, bBigEndian);
-		if (iULong > 2147483647)
-			return iULong - 4294967296;
-		else
-			return iULong;
-	}
-	this.getStringAt = function(iOffset, iLength) {
-		var aStr = [];
-		for (var i=iOffset,j=0;i<iOffset+iLength;i++,j++) {
-			aStr[j] = String.fromCharCode(this.getByteAt(i));
-		}
-		return aStr.join("");
-	}
-
-	this.getCharAt = function(iOffset) {
-		return String.fromCharCode(this.getByteAt(iOffset));
-	}
-	this.toBase64 = function() {
-		return window.btoa(data);
-	}
-	this.fromBase64 = function(strBase64) {
-		data = window.atob(strBase64);
-	}
+BinaryFile.prototype.getByteAt_CharCode = function(iOffset) {
+  return this.data.charCodeAt(iOffset + this.dataOffset) & 0xFF;
 };
+
+BinaryFile.prototype.getByteAt_IEBinary = function(iOffset) {
+  return IEBinary_getByteAt(this.data, iOffset + this.dataOffset);
+};
+
+BinaryFile.prototype.getRawData = function() {
+  return this.data;
+}
+
+BinaryFile.prototype.slice = function(begin, optionalEnd) {
+  var arr = [];
+  var end = optionalEnd || this.getLength();
+  var i;
+  for (i = begin; i < end; i++) {
+    arr.push(this.getByteAt(i));
+  }
+  return arr;
+}
+
+BinaryFile.prototype.getLength = function() {
+  return this.dataLength;
+}
+
+BinaryFile.prototype.getSByteAt = function(iOffset) {
+  var iByte = this.getByteAt(iOffset);
+  if (iByte > 127)
+    return iByte - 256;
+  else
+    return iByte;
+}
+
+BinaryFile.prototype.getShortAt = function(iOffset, bBigEndian) {
+  var iShort = bBigEndian ? 
+    (this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1)
+    : (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset)
+  if (iShort < 0) iShort += 65536;
+  return iShort;
+}
+
+BinaryFile.prototype.getSShortAt = function(iOffset, bBigEndian) {
+  var iUShort = this.getShortAt(iOffset, bBigEndian);
+  if (iUShort > 32767)
+    return iUShort - 65536;
+  else
+    return iUShort;
+}
+
+BinaryFile.prototype.getLongAt = function(iOffset, bBigEndian) {
+  var iByte1 = this.getByteAt(iOffset),
+    iByte2 = this.getByteAt(iOffset + 1),
+    iByte3 = this.getByteAt(iOffset + 2),
+    iByte4 = this.getByteAt(iOffset + 3);
+
+  var iLong = bBigEndian ? 
+    (((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4
+    : (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1;
+  if (iLong < 0) iLong += 4294967296;
+  return iLong;
+}
+
+BinaryFile.prototype.getSLongAt = function(iOffset, bBigEndian) {
+  var iULong = this.getLongAt(iOffset, bBigEndian);
+  if (iULong > 2147483647)
+    return iULong - 4294967296;
+  else
+    return iULong;
+}
+
+BinaryFile.prototype.getStringAt = function(iOffset, iLength) {
+  var aStr = [];
+  for (var i=iOffset,j=0;i<iOffset+iLength;i++,j++) {
+    aStr[j] = String.fromCharCode(this.getByteAt(i));
+  }
+  return aStr.join("");
+}
+
+BinaryFile.prototype.getCharAt = function(iOffset) {
+  return String.fromCharCode(this.getByteAt(iOffset));
+}
+
+BinaryFile.prototype.toBase64 = function() {
+  return btoa(this.data);
+}
+
+BinaryFile.prototype.fromBase64 = function(strBase64) {
+  data = window.atob(strBase64);
+}
+
+module.exports = exports = BinaryFile;
diff --git a/lib/git-server.js b/lib/git-server.js
index 587e4d0..cba92c0 100644
--- a/lib/git-server.js
+++ b/lib/git-server.js
@@ -7,12 +7,10 @@ _ = require('../vendor/underscore-min')
 require('../vendor/js-deflate/rawdeflate')
 require('../vendor/js-deflate/rawinflate')
 require('../vendor/sha1')
-require('../vendor/sha2')
 require('../vendor/md5')
 require('../vendor/diff')
 require('./string_helpers')
 require('./binary_file')
-require('./git')
 require('./git/upload_pack_parser')
 require('./git/pack')
 require('./git/remote')
@@ -35,3 +33,5 @@ require('./git/commands/log-command')
 require('./git/commands/diff-command')
 require('./git/pack-file')
 
+var Git = require('./git')
+module.exports = exports = new Git
diff --git a/lib/git.js b/lib/git.js
index 70303bb..5e86578 100644
--- a/lib/git.js
+++ b/lib/git.js
@@ -1,64 +1,59 @@
 
 /* Main object */
-Git = {
-  OBJECT_TYPES: ["tag", "commit", "tree", "blob"],
-  REMOTE_TYPE: "HttpRemote",
-  
-  // Print an error either to the console if in node, or to div#jsgit-errors
-  // if in the client.
-  handleError: function(message) {
-    if (jsGitInNode) {
-      console.log(message)
-    }
-    else {
-      $('#jsgit-errors').append(message)
-    }
-  },
-  
-  // Turn an array of bytes into a String
-  bytesToString: function(bytes) {
-    var result = "";
+
+var Git = function() {
+
+};
+
+// constants
+
+Git.OBJECT_TYPES  = ["tag", "commit", "tree", "blob"]
+Git.REMOTE_TYPE   = 'HttpRemote'
+
+Git.prototype.handleError = typeof console !== 'undefined' ?
+    function() { console.log.apply(console, arguments) } :
+    function() { (this._logs || []).push([].slice.call(arguments)) }
+
+// Turn an array of bytes into a String
+Git.prototype.bytesToString = function(bytes) {
+    var result = [];
     var i;
     for (i = 0; i < bytes.length; i++) {
-      result = result.concat(String.fromCharCode(bytes[i]));
+      result.push(String.fromCharCode(bytes[i]));
     }
-    return result;
-  },
-  
-  stringToBytes: function(string) {
+    return result.join('');
+};
+
+Git.prototype.stringToBytes = function(string) {
     var bytes = []; 
     var i; 
     for(i = 0; i < string.length; i++) {
       bytes.push(string.charCodeAt(i) & 0xff);
     }
     return bytes;
-  },
-    
-  toBinaryString: function(binary) {
-    if (Array.isArray(binary)) {
-      return Git.bytesToString(binary)
-    }
-    else {
-      return binary
-    }
-  },
-    
-  // returns the next pkt-line
-  nextPktLine: function(data) {
-    var length = parseInt(data.substring(0, 4), 16);
-    return data.substring(4, length);
-  },
-  
-  // zlib files contain a two byte header. (RFC 1950)
-  stripZlibHeader: function(zlib) {
-    return zlib.slice(2)
-  },
-  
-  escapeHTML: function(s) {
-    return s
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;');
-  }
+};
+
+Git.prototype.toBinaryString = function(binary) {
+  return (binary instanceof Array) ?
+          this.bytesToString(binary) :
+          binary
+};
+
+Git.prototype.nextPktLine = function(data) {
+  var len = parseInt(data.slice(0, 4), 16);
+  return data.slice(4, len);
+};
+ 
+Git.prototype.stripZlibHeader = function(zlib) {
+  return zlib.slice(2);
 }
+ 
+Git.prototype.escapeHTML = function(str) {
+    return str.replace(/\&/g, '&amp;')
+              .replace(/</g, '&lt;')
+              .replace(/>/g, '&gt;')
+              .replace(/"/g, '&quot;')
+               replace(/'/g, '&#39;');
+};
 
+module.exports = exports = Git
diff --git a/lib/git/cli.js b/lib/git/cli.js
index a152342..f168d7f 100644
--- a/lib/git/cli.js
+++ b/lib/git/cli.js
@@ -1,54 +1,61 @@
 var path = require('path')
-var sys  = require('sys')
-Git.Cli = function(args, commandRunner) {
-  var that           = this
-  
-  that.args          = args || []
-  that.gitDir        = path.join(process.cwd(), ".git")
-  that.commandRunner = commandRunner || new Git.CommandRunner()
-  that.argsWithoutOptions = []
-  that.argOptions = []
-  
-  that.args.forEach(function(arg) {
-    if (!/^-/.exec(arg)) that.argsWithoutOptions.push(arg)
-    
+  , sys  = require('sys')
+  , Repo = require('./repo')
+  , CommandRunner = require('./command-runner')
+  , helpers = require('../string_helpers')
+
+var Cli = function(args, commandRunner) {
+  this.args          = args || []
+  this.gitDir        = path.join(process.cwd(), ".git")
+  this.commandRunner = commandRunner || new CommandRunner()
+  this.argsWithoutOptions = []
+  this.argOptions = []
+  this.args.forEach(function(arg) {
+    if (!/^-/.exec(arg)) this.argsWithoutOptions.push(arg)
+
     var result = /^--git-dir=(.*)$/.exec(arg)
     if (result) {
-      if (result[1][0] == "/") { 
-        that.gitDir = result[1] 
+      if (result[1][0] == "/") {
+        this.gitDir = result[1]
       } else {
-        that.gitDir = path.join(process.cwd(), result[1])
+        this.gitDir = path.join(process.cwd(), result[1])
       }
     } else {
       result = /^(--.*)/.exec(arg)
       if (result) {
-        that.argOptions.push(result[1])
+        this.argOptions.push(result[1])
       }
     }
-  })
-  that.commandName = that.argsWithoutOptions[0]
-  
-  that.repo = function() {
-    return new Git.Repo(that.gitDir)
+  }, this)
+  this.commandName = this.argsWithoutOptions[0]
+}
+
+Cli.prototype.repo = function() {
+  return new Repo(this.gitDir)
+}
+
+Cli.prototype.commandResultHandler = function(err, output) {
+  if (err) {
+    process.stderr.write(err)
+    if(!process.stderr.flush())
+      process.stderr.on('drain', process.exit.bind(process, 1))
   }
-  
-  that.commandResultHandler = function(err, output) {
-    if (err) return sys.puts(err)
-    
-    sys.puts(output + "\n")
+
+  process.stdout.write(output + "\n")
+}
+
+Cli.prototype.run = function() {
+  if (this.commandName == "show") {
+    this.commandRunner.show(this.repo(), this.argsWithoutOptions.slice(1), this.argOptions, this.commandResultHandler)
+  } else if (this.commandName == "log") {
+    this.commandRunner.log(this.repo(), this.commandResultHandler)
+  } else if (this.commandName == "branch") {
+    this.commandRunner.branch(this.repo(), this.commandResultHandler)
+  } else if (this.commandName == "diff") {
+    this.commandRunner.diff(this.repo(), this.argsWithoutOptions.slice(1), this.argOptions, this.commandResultHandler)
+  } else {
+    sys.print("git.js: '" + this.commandName + "' is not a supported git command. See 'git.js --help'.\n")
   }
-  
-  that.run = function() {
-    if (that.commandName == "show") {
-      that.commandRunner.show(that.repo(), that.argsWithoutOptions.slice(1), that.argOptions, that.commandResultHandler)
-    } else if (that.commandName == "log") {
-      that.commandRunner.log(that.repo(), that.commandResultHandler)
-    } else if (that.commandName == "branch") {
-      that.commandRunner.branch(that.repo(), that.commandResultHandler)
-    } else if (that.commandName == "diff") {
-      that.commandRunner.diff(that.repo(), that.argsWithoutOptions.slice(1), that.argOptions, that.commandResultHandler)
-    } else {
-      sys.print("git.js: '" + that.commandName + "' is not a supported git command. See 'git.js --help'.\n")
-    }
-  }
-}
\ No newline at end of file
+}
+
+module.exports = exports = Cli
diff --git a/lib/git/command-runner.js b/lib/git/command-runner.js
index afd7288..e1192c3 100644
--- a/lib/git/command-runner.js
+++ b/lib/git/command-runner.js
@@ -1,22 +1,29 @@
+var ShowCommand = require('./commands/show-command')
+  , DiffCommand = require('./commands/diff-command')
+  , BranchCommand = require('./commands/branch-command')
+  , LogCommand = require('./commands/log-command')
 
-Git.CommandRunner = function() {
-  this.show = function(repo, shas, options, callback) {
-    var cmd = new Git.commands.ShowCommand(repo, shas, options)
-    cmd.run(callback)
-  }
-  
-  this.log = function(repo, cb) {
-    var cmd = new Git.commands.LogCommand(repo)
-    cmd.run(cb)
-  }
-  
-  this.branch = function(repo, cb) {
-    var cmd = new Git.commands.BranchCommand(repo)
-    cmd.run(cb)
-  }
-  
-  this.diff = function(repo, shas, options, cb) {
-    var cmd = new Git.commands.DiffCommand(repo, shas, options)
-    cmd.run(cb)
-  }
-}
\ No newline at end of file
+var CommandRunner = function() {
+};
+
+CommandRunner.prototype.show = function(repo, shas, options, callback) {
+  var cmd = new ShowCommand(repo, shas, options)
+  cmd.run(callback)
+}
+
+CommandRunner.prototype.log = function(repo, cb) {
+  var cmd = new LogCommand(repo)
+  cmd.run(cb)
+}
+
+CommandRunner.prototype.branch = function(repo, cb) {
+  var cmd = new BranchCommand(repo)
+  cmd.run(cb)
+}
+
+CommandRunner.prototype.diff = function(repo, shas, options, cb) {
+  var cmd = new DiffCommand(repo, shas, options)
+  cmd.run(cb)
+}
+
+module.exports = exports = CommandRunner
diff --git a/lib/git/commands/branch-command.js b/lib/git/commands/branch-command.js
index 9177670..6c34aed 100644
--- a/lib/git/commands/branch-command.js
+++ b/lib/git/commands/branch-command.js
@@ -1,6 +1,4 @@
-if (!Git.commands) Git.commands = {}
-
-Git.commands.BranchCommand = function(repo, options) {
+module.exports = function(repo, options) {
   this.run = function(cb) {
     repo.getBranches(function(err, branches) {
       if (err) return cb(err)
@@ -17,4 +15,4 @@ Git.commands.BranchCommand = function(repo, options) {
       })
     })
   }
-}
\ No newline at end of file
+}
diff --git a/lib/git/commands/diff-command.js b/lib/git/commands/diff-command.js
index 6ffad5e..6005734 100644
--- a/lib/git/commands/diff-command.js
+++ b/lib/git/commands/diff-command.js
@@ -1,25 +1,31 @@
-if (!Git.commands) Git.commands = {}
+var TreeDiff = require('../tree-diff')
 
-Git.commands.DiffCommand = function(repo, shas, options) {
-  var that    = this
-  var fromCommitSha = shas && shas[0]
-  var toCommitSha   = shas && shas[1]
-  
-  that.toString = function() {
-    return "git diff " + options.join(" ") + " " + shas.join(" ")
+var DiffCommand = function(repo, shas, options) {
+  this.fromCommitSha = shas && shas[0]
+  this.toCommitSha   = shas && shas[1]
+ 
+  this.repo = repo
+  this.shas = shas
+  this.options = options 
+}
+
+DiffCommand.prototype.toString = function() {
+  return "git diff " + this.options.join(" ") + " " + this.shas.join(" ")
+}
+
+DiffCommand.prototype.run = function(cb) {
+  var self = this
+  if (!self.fromCommitSha || !self.toCommitSha) {
+    return cb("git.js diff currently requires two commits exactly")
   }
-  
-  that.run = function(cb) {
-    if (!fromCommitSha || !toCommitSha) {
-      return cb("git.js diff currently requires two commits exactly")
-    }
-    repo.getObject(fromCommitSha, function(err, fromCommit) {
+  self.repo.getObject(self.fromCommitSha, function(err, fromCommit) {
+    if (err) return cb(err)
+    self.repo.getObject(self.toCommitSha, function(err, toCommit) {
       if (err) return cb(err)
-      repo.getObject(toCommitSha, function(err, toCommit) {
-        if (err) return cb(err)
-        var treeDiff = new Git.TreeDiff(repo, fromCommit.tree, toCommit.tree)
-        treeDiff.toStat(cb)
-      })
+      var treeDiff = new TreeDiff(self.repo, fromCommit.tree, toCommit.tree)
+      treeDiff.toStat(cb)
     })
-  }
+  })
 }
+
+module.exports = exports = DiffCommand
diff --git a/lib/git/commands/log-command.js b/lib/git/commands/log-command.js
index af144db..cdedaeb 100644
--- a/lib/git/commands/log-command.js
+++ b/lib/git/commands/log-command.js
@@ -1,6 +1,4 @@
-if (!Git.commands) Git.commands = {}
-
-Git.commands.LogCommand = function(repo, options) {
+module.exports = function(repo, options) {
   var that = this
   
   that.maxCommits = 10
@@ -10,11 +8,10 @@ Git.commands.LogCommand = function(repo, options) {
     var result = result || {done: false, commits: []}
     
     if (result.done) return
-    
+   
     repo.getObject(commitSha, function(err, commit) {
       if (result.done) return
       if (err) return callback(err)
-      
       result.commits.push(commit)
       
       if (result.commits.length == that.maxCommits) {
@@ -40,7 +37,7 @@ Git.commands.LogCommand = function(repo, options) {
   that.run = function(cb) {
     repo.getHead(function(err, head) {
       if (err) return cb(err)
-      
+
       repo.getBranches(function(err, branches) {
         if (err) return cb(err)
         if (branches.branchNames.length == 0) return cb("No branches found to log")
diff --git a/lib/git/commands/show-command.js b/lib/git/commands/show-command.js
index 1726864..37c7203 100644
--- a/lib/git/commands/show-command.js
+++ b/lib/git/commands/show-command.js
@@ -1,6 +1,4 @@
-if (!Git.commands) Git.commands = {}
-
-Git.commands.ShowCommand = function(repo, shas, options) {
+module.exports = function(repo, shas, options) {
   this.run = function(callback) {
     var sha = shas[0]
     repo.getObject(sha, function(err, object) {
@@ -9,4 +7,4 @@ Git.commands.ShowCommand = function(repo, shas, options) {
       callback(null, object.toString())
     })
   }
-}
\ No newline at end of file
+}
diff --git a/lib/git/delta.js b/lib/git/delta.js
index 888a452..dc1b2d2 100644
--- a/lib/git/delta.js
+++ b/lib/git/delta.js
@@ -1,5 +1,7 @@
+var utils = require('./utils')
+var _ = require('underscore')
 
-Git.applyDelta = (function() {
+module.exports = (function() {
   var matchLength = function(stream) {
     var data = stream.data
     var offset = stream.offset
@@ -21,12 +23,12 @@ Git.applyDelta = (function() {
   }
   
   return function(baseDataString, delta) {
-    var baseData = Git.stringToBytes(baseDataString)
+    var baseData = utils.stringToBytes(baseDataString)
     var stream = {data: delta, offset: 0, length: delta.length}
     
     var baseLength = matchLength(stream)
     if (baseLength != baseData.length) {
-      throw (Error("Delta Error: base length not equal to length of given base data"))
+      throw new Error("Delta Error: base length not equal to length of given base data")
     }
     
     var resultLength = matchLength(stream)
@@ -71,16 +73,16 @@ Git.applyDelta = (function() {
         
         // TODO: check if this is a version 2 packfile and apply copyFromResult if so
         copyFromResult = (opcode & 0x01)
-        resultData += Git.bytesToString(baseData.slice(copyOffset, copyOffset + copyLength))
+        resultData += utils.bytesToString(baseData.slice(copyOffset, copyOffset + copyLength))
         
       } else if ((opcode & 0x80) == 0) {
-        resultData += Git.bytesToString(stream.data.slice(stream.offset, stream.offset + opcode))
+        resultData += utils.bytesToString(stream.data.slice(stream.offset, stream.offset + opcode))
         stream.offset += opcode
       }
     }
     
     if (resultLength != resultData.length) {
-      throw (Error("Delta Error: got result length " + resultData.length + ", expected " + resultLength))
+      throw new Error("Delta Error: got result length " + resultData.length + ", expected " + resultLength)
     }
     return resultData
   }
diff --git a/lib/git/file-diff.js b/lib/git/file-diff.js
index 4e32e22..621c6fa 100644
--- a/lib/git/file-diff.js
+++ b/lib/git/file-diff.js
@@ -1,136 +1,140 @@
+var Diff = require('../../vendor/diff')
+  , _ = require('underscore')
 
-
-Git.FileDiff = function(file1, file2, options) {
+var FileDiff = function(file1, file2, options) {
+  this.file1 = file1
+  this.file2 = file2
   this.lines1 = file1.split("\n")
   this.lines2 = file2.split("\n")
   this.diffChunks = Diff.diff_patch(this.lines1, this.lines2)
   var options = options || {}
   this.contextLength = options.context || 3
-  
-  this.toInfo = function() {
-    if (file1 === "") {
-      var infoChunk = {offset: 1, lines:[]}
-      _(this.lines2).each(function(line, i) {
-        infoChunk.lines.push({oldIndex: null, newIndex:(i + 1), line: line, type:"added"})
-      })
-      return [infoChunk]
-    }
-    if (file2 === "") {
-      var infoChunk = {offset: 1, lines:[]}
-      _(this.lines1).each(function(line, i) {
-        infoChunk.lines.push({oldIndex: (i + 1), newIndex:null, line: line, type:"removed"})
-      })
-      return [infoChunk]
-    }
-    var infos = []
-    var diff = this
-    var totalAdded = 0
-    var totalRemoved = 0
-    var lastInfoChunk = null
-    var infoChunk = null
-    _(this.diffChunks).each(function(chunk) {
-      var removed = chunk.file1
-      var added   = chunk.file2
-      infoChunk = null
-      var removeContext = null
-      var overlapLength = null
-      var lastLineNewIndex = null
-      if (lastInfoChunk) {
-        var lastLine = lastInfoChunk.lines[lastInfoChunk.lines.length - 1]
-        if (lastLine.oldIndex >= Math.max(removed.offset - diff.contextLength, 0)) {
-          infoChunk = lastInfoChunk
-          overlapLength = lastLine.oldIndex - Math.max(removed.offset - diff.contextLength, 0)
-          removeContext = Math.min(overlapLength, diff.contextLength)
-          lastInfoChunk.lines = lastInfoChunk.lines.slice(0, lastInfoChunk.lines.length - removeContext)
-          lastLineNewIndex = lastInfoChunk.lines[lastInfoChunk.lines.length - 1].newIndex
-        }
+  this.info = this.toInfo()
+}
+
+FileDiff.prototype.toString = function() {
+  return '<FileDiff>'
+}
+
+FileDiff.prototype.toHtml = function() {
+  var str = []
+  str.push("  <div class='diff'>")
+  var diff = this
+  _(this.info).each(function(chunk) {
+    _(chunk.lines).each(function(line) {
+      var truncatedLine = Git.escapeHTML(line.line.slice(0, FileDiff.MAX_LINE_CHARS))
+      if (line.type == "context") {
+        var oldIx = line.oldIndex.toString().rjust(2, " ")
+        var newIx = line.newIndex.toString().rjust(2, " ")
+        str.push("<pre class='context'>" + oldIx + " " + newIx + "  " + truncatedLine + "</pre>")
+      } else if (line.type == "added") {
+        var newIx = line.newIndex.toString().rjust(2, " ")
+        str.push("<pre class='added'>" + "   " + newIx + " +" + truncatedLine + "</pre>")
+      } else if (line.type == "removed") {
+        var oldIx = line.oldIndex.toString().rjust(2, " ")
+        str.push("<pre class='removed'>" + oldIx + "    -" + truncatedLine + "</pre>")
       }
-      infoChunk = infoChunk || {offset: added.offset + 1, lines:[]}
-      var preContextRange = [Math.max(removed.offset - diff.contextLength, 0), Math.max(removed.offset, 0)]
-      var preContext = diff.lines1.slice(preContextRange[0], preContextRange[1])
-      _(preContext).each(function(line, i) {
-        var oldIx = preContextRange[0] + i + 1
-        var newIx = oldIx + totalAdded - totalRemoved
-        if (newIx > lastLineNewIndex) {
-          infoChunk.lines.push({oldIndex: oldIx, newIndex:newIx, line: line, type:"context"})
-        }
-      })
-      
-      if (removed.length > 0) {
-        _(removed.chunk).each(function(line, i) {
-          var oldIx = removed.offset + i + 1
-          infoChunk.lines.push({oldIndex: oldIx, newIndex:null, line: line, type:"removed"})
-        })
+    })
+  })
+  str.push("</div>")
+  return str.join("\n")
+}
+
+FileDiff.prototype.stat = function() {
+  var result = {insertions: 0, deletions: 0}
+  _(this.info).each(function(chunk) {
+    _(chunk.lines).each(function(line) {
+      if (line.type == "context") {
+      } else if (line.type == "added") {
+        result.insertions += 1
+      } else if (line.type == "removed") {
+        result.deletions += 1
       }
-      
-      if (added.length > 0) {
-        _(added.chunk).each(function(line, i) {
-          var newIx = added.offset + i + 1
-          infoChunk.lines.push({oldIndex: null, newIndex:newIx, line: line, type:"added"})
-        })
+    })
+  })
+  return result
+}
+
+FileDiff.prototype.toInfo = function() {
+  if (this.file1 === "") {
+    var infoChunk = {offset: 1, lines:[]}
+    _(this.lines2).each(function(line, i) {
+      infoChunk.lines.push({oldIndex: null, newIndex:(i + 1), line: line, type:"added"})
+    })
+    return [infoChunk]
+  }
+  if (this.file2 === "") {
+    var infoChunk = {offset: 1, lines:[]}
+    _(this.lines1).each(function(line, i) {
+      infoChunk.lines.push({oldIndex: (i + 1), newIndex:null, line: line, type:"removed"})
+    })
+    return [infoChunk]
+  }
+  var infos = []
+  var diff = this
+  var totalAdded = 0
+  var totalRemoved = 0
+  var lastInfoChunk = null
+  var infoChunk = null
+  _(this.diffChunks).each(function(chunk) {
+    var removed = chunk.file1
+    var added   = chunk.file2
+    infoChunk = null
+    var removeContext = null
+    var overlapLength = null
+    var lastLineNewIndex = null
+    if (lastInfoChunk) {
+      var lastLine = lastInfoChunk.lines[lastInfoChunk.lines.length - 1]
+      if (lastLine.oldIndex >= Math.max(removed.offset - diff.contextLength, 0)) {
+        infoChunk = lastInfoChunk
+        overlapLength = lastLine.oldIndex - Math.max(removed.offset - diff.contextLength, 0)
+        removeContext = Math.min(overlapLength, diff.contextLength)
+        lastInfoChunk.lines = lastInfoChunk.lines.slice(0, lastInfoChunk.lines.length - removeContext)
+        lastLineNewIndex = lastInfoChunk.lines[lastInfoChunk.lines.length - 1].newIndex
       }
-      
-      var postContextRange = [(added.offset - totalAdded + totalRemoved) + removed.length, (added.offset - totalAdded + totalRemoved) + diff.contextLength + removed.length]
-      var postContext = diff.lines1.slice(postContextRange[0], postContextRange[1])
-      _(postContext).each(function(line, i) {
-        var oldIx = postContextRange[0] + i + 1
-        var newIx = oldIx + added.length - removed.length + totalAdded - totalRemoved
+    }
+    infoChunk = infoChunk || {offset: added.offset + 1, lines:[]}
+    var preContextRange = [Math.max(removed.offset - diff.contextLength, 0), Math.max(removed.offset, 0)]
+    var preContext = diff.lines1.slice(preContextRange[0], preContextRange[1])
+    _(preContext).each(function(line, i) {
+      var oldIx = preContextRange[0] + i + 1
+      var newIx = oldIx + totalAdded - totalRemoved
+      if (newIx > lastLineNewIndex) {
         infoChunk.lines.push({oldIndex: oldIx, newIndex:newIx, line: line, type:"context"})
-      })
-      totalAdded += added.length
-      totalRemoved += removed.length
-      if (infoChunk !== lastInfoChunk) {
-        infos.push(infoChunk)
       }
-      lastInfoChunk = infoChunk
     })
-    return infos
-  }
-  
-  this.info = this.toInfo()
-  
-  this.toString = function() {
-    return "asdf"
-  }
-  
-  this.toHtml = function() {
-    var str = []
-    str.push("  <div class='diff'>")
-    var diff = this
-    _(this.info).each(function(chunk) {
-      _(chunk.lines).each(function(line) {
-        var truncatedLine = Git.escapeHTML(line.line.slice(0, Git.FileDiff.MAX_LINE_CHARS))
-        if (line.type == "context") {
-          var oldIx = line.oldIndex.toString().rjust(2, " ")
-          var newIx = line.newIndex.toString().rjust(2, " ")
-          str.push("<pre class='context'>" + oldIx + " " + newIx + "  " + truncatedLine + "</pre>")
-        } else if (line.type == "added") {
-          var newIx = line.newIndex.toString().rjust(2, " ")
-          str.push("<pre class='added'>" + "   " + newIx + " +" + truncatedLine + "</pre>")
-        } else if (line.type == "removed") {
-          var oldIx = line.oldIndex.toString().rjust(2, " ")
-          str.push("<pre class='removed'>" + oldIx + "    -" + truncatedLine + "</pre>")
-        }
+
+    if (removed.length > 0) {
+      _(removed.chunk).each(function(line, i) {
+        var oldIx = removed.offset + i + 1
+        infoChunk.lines.push({oldIndex: oldIx, newIndex:null, line: line, type:"removed"})
       })
-    })
-    str.push("</div>")
-    return str.join("\n")
-  }
-  
-  this.stat = function() {
-    var result = {insertions: 0, deletions: 0}
-    _(this.info).each(function(chunk) {
-      _(chunk.lines).each(function(line) {
-        if (line.type == "context") {
-        } else if (line.type == "added") {
-          result.insertions += 1
-        } else if (line.type == "removed") {
-          result.deletions += 1
-        }
+    }
+
+    if (added.length > 0) {
+      _(added.chunk).each(function(line, i) {
+        var newIx = added.offset + i + 1
+        infoChunk.lines.push({oldIndex: null, newIndex:newIx, line: line, type:"added"})
       })
+    }
+
+    var postContextRange = [(added.offset - totalAdded + totalRemoved) + removed.length, (added.offset - totalAdded + totalRemoved) + diff.contextLength + removed.length]
+    var postContext = diff.lines1.slice(postContextRange[0], postContextRange[1])
+    _(postContext).each(function(line, i) {
+      var oldIx = postContextRange[0] + i + 1
+      var newIx = oldIx + added.length - removed.length + totalAdded - totalRemoved
+      infoChunk.lines.push({oldIndex: oldIx, newIndex:newIx, line: line, type:"context"})
     })
-    return result
-  }
+    totalAdded += added.length
+    totalRemoved += removed.length
+    if (infoChunk !== lastInfoChunk) {
+      infos.push(infoChunk)
+    }
+    lastInfoChunk = infoChunk
+  })
+  return infos
 }
 
-Git.FileDiff.MAX_LINE_CHARS = 140
+FileDiff.MAX_LINE_CHARS = 140
+
+module.exports = FileDiff
diff --git a/lib/git/github_repo.js b/lib/git/github_repo.js
new file mode 100644
index 0000000..0f5d271
--- /dev/null
+++ b/lib/git/github_repo.js
@@ -0,0 +1,10 @@
+var MemoryRepo = require('./memory_repo')
+
+// Helper for creating Repos for a Github proxy
+module.exports = function(username, reponame, password) {
+  var repo = new MemoryRepo()
+  var githubCredentials = "password=" + encodeURI(password) + "&username=" + username
+  var remoteUrl = "http://localhost:3000/" + username + "/" + reponame + ".git?server=" + encodeURI("https://github.com") + "&" + githubCredentials
+  repo.addRemote("origin", remoteUrl)
+  return repo
+}
diff --git a/lib/git/http_remote.js b/lib/git/http_remote.js
index f5813a4..a8711ed 100644
--- a/lib/git/http_remote.js
+++ b/lib/git/http_remote.js
@@ -1,6 +1,14 @@
+var BinaryFile = require('../binary_file')
+  , Remote = require('./remote')
+  , Pack = require('./pack')
+  , PackIndex = require('./pack_index')
+  , utils = require('./utils')
+  , _ = require('underscore')
+  , inflate = require('../../vendor/js-deflate/rawinflate')
+  , Objects = require('./objects')
 
-Git.HttpRemote = function(repo, name, repoUrl) {
-  Git.Remote.apply(this, [repo, name, repoUrl])
+var HttpRemote = function(repo, name, repoUrl) {
+  Remote.call(this, repo, name, repoUrl)
   
   this.fetchRefs = function(callback) {
     var remote = this
@@ -8,7 +16,7 @@ Git.HttpRemote = function(repo, name, repoUrl) {
       this.makeUri('/info/refs'),
       "",
       function(data) {
-        var refs = Git.HttpRemote.parseInfoRefs(data)
+        var refs = HttpRemote.parseInfoRefs(data)
         _(refs).each(function(ref) {
           remote.addRef(ref.name, ref.sha)
         })
@@ -66,7 +74,7 @@ Git.HttpRemote = function(repo, name, repoUrl) {
         xhr.overrideMimeType('text/plain; charset=x-user-defined')
       },
       success: function(data) {
-        callback(Git.HttpRemote.parseObjectData(sha, data))
+        callback(HttpRemote.parseObjectData(sha, data))
       },
       error: function(xhr) {
         callback(null)
@@ -102,7 +110,7 @@ Git.HttpRemote = function(repo, name, repoUrl) {
         url: uri, type: "GET", 
         success: function(data) {
           remote.packs = {}
-          _(Git.HttpRemote.parsePackList(data)).each(function(packSha) {
+          _(HttpRemote.parsePackList(data)).each(function(packSha) {
             remote.packs[packSha] = {index: null, pack: null}
           })
           callback(remote.packs)
@@ -124,7 +132,7 @@ Git.HttpRemote = function(repo, name, repoUrl) {
           xhr.overrideMimeType('text/plain; charset=x-user-defined')
         },
         success: function(data) {
-          var packIndex = new Git.PackIndex(data)
+          var packIndex = new PackIndex(data)
           remote.packs[sha].index = packIndex
           callback(packIndex)
         }
@@ -145,7 +153,7 @@ Git.HttpRemote = function(repo, name, repoUrl) {
           xhr.overrideMimeType('text/plain; charset=x-user-defined')
         },
         success: function(data) {
-          var packFile = new Git.Pack(data)
+          var packFile = new Pack(data)
           remote.packs[sha].pack = packFile
           callback(packFile)
         }
@@ -158,8 +166,10 @@ Git.HttpRemote = function(repo, name, repoUrl) {
   }
 }
 
+HttpRemote.prototype = new Remote('','','')
+
 // Parses the contents of the .git/info/refs file
-Git.HttpRemote.parseInfoRefs = function(data) {
+HttpRemote.parseInfoRefs = function(data) {
   var lines = data.split("\n")
   var refs = []
   _(lines).each(function(line) {
@@ -172,7 +182,7 @@ Git.HttpRemote.parseInfoRefs = function(data) {
   return refs
 }
 
-Git.HttpRemote.parsePackList = function(data) {
+HttpRemote.parsePackList = function(data) {
   var lines = data.split("\n")
   var packs = []
   _(lines).each(function(line) {
@@ -184,9 +194,9 @@ Git.HttpRemote.parsePackList = function(data) {
   return packs
 }
 
-Git.HttpRemote.parseObjectData = function(sha, compressedData) {
-  var deflated = Git.stripZlibHeader(Git.stringToBytes(compressedData))
-  var data = new BinaryFile(RawDeflate.inflate(Git.bytesToString(deflated)).toString())
+HttpRemote.parseObjectData = function(sha, compressedData) {
+  var deflated = utils.stripZlibHeader(utils.stringToBytes(compressedData))
+  var data = new BinaryFile(inflate(utils.bytesToString(deflated)).toString())
   var offset = 0
   
   var peek = function(length) {
@@ -201,7 +211,7 @@ Git.HttpRemote.parseObjectData = function(sha, compressedData) {
     offset += length
   }
   
-  var type = Git.bytesToString(peek(3))
+  var type = utils.bytesToString(peek(3))
   advance(3)
   if (type === "com") {
     type = "commit"
@@ -221,13 +231,7 @@ Git.HttpRemote.parseObjectData = function(sha, compressedData) {
     nextByte = peek(1)[0]
     advance(1)
   }
-  return Git.objects.make(sha, type, Git.bytesToString(rest()))
+  return Objects.make(sha, type, utils.bytesToString(rest()))
 }
 
-
-
-
-
-
-
-
+module.exports = exports = HttpRemote
diff --git a/lib/git/memory_repo.js b/lib/git/memory_repo.js
index c836937..3403e0e 100644
--- a/lib/git/memory_repo.js
+++ b/lib/git/memory_repo.js
@@ -1,109 +1,92 @@
+var HttpRemote = require('./http_remote')
+  , _ = require('underscore')
+  , Objects = require('./objects')
 
-Git.MemoryRepo = function() {
-  var refs = {}
-  var that = {}
-  var remotes = {}
-  var objects = {}
-
-  that.getRef = function(refname) {
-    return refs[refname]
-  }
-  
-  that.getRefs = function() {
-    return _(refs).values()
-  }
-  
-  that.haveRefs = function(refs) {
-    var have = []
-    _(refs).each(function(ref) {
-      if (objects[ref.sha] != null) {
-        have.push(ref)
-      }
-    })
-    return have
-  }
-  
-  that.getAllRefs = function() {
-    return _(that.getRemotes()).reduce(function(memo, remote) {
-      return memo.concat(remote.getRefs())
-    }, that.getRefs())
-  }
-  
-  // Add a ref to this repo. fullName is of the form:
-  //   refs/heads/master or refs/tags/123
-  that.addRef = function(fullName, sha) {
-    var type = fullName.split("/")[1]
-    var name = fullName.split("/")[2]
-    refs[name] = {name:name, sha:sha, remote:null, type:type}
-  }
-  
-  that.getRemote = function(name) {
-    return remotes[name]
-  }
-  
-  that.getRemotes = function() {
-    return _(remotes).values()
-  }
-  
-  that.addRemote = function(name, url) { 
-    remotes[name] = new Git[Git.REMOTE_TYPE](this, name, url)
-  }
-  
-  that.addRemoteObject = function(name, remote) {
-    remotes[name] = remote
-  }
-  
-  that.makeAndAddObject = function(sha, type, content) {
-    objects[sha] = Git.objects.make(sha, type, content)
-    return objects[sha]
-  }
-  
-  that.addObject = function(object) {
-    objects[object.sha] = object
-    return object
-  }
-  
-  that.getObjectShas = function(sha) {
-    return _(objects).keys()
-  }
-  
-  that.objectCount = function() {
-    return _(objects).keys().length
-  }
-  
-  that.getObject = function(sha, callback) {
-    var already = objects[sha]
-    if (already) { return callback(null, already) }
-  
-    var remote = that.getRemotes()[0]
-    remote.getObject(sha, function(object) {
-      if (object) {
-        that.addObject(object)
-      }
-      callback(null, object)
-    })
-  }
-  
-  return that
+var MemoryRepo = function() {
+  this.refs = {}
+  this.that = {}
+  this.remotes = {}
+  this.objects = {}
+};
+
+
+MemoryRepo.prototype.getRef = function(refname) {
+  return this.refs[refname]
+}
+
+MemoryRepo.prototype.getRefs = function() {
+  return _(this.refs).values()
 }
 
-// Helper for creating Repos for a Github proxy
-Git.GithubProxyRepo = function(username, reponame, password) {
-  var repo = new Git.MemoryRepo()
-  var githubCredentials = "password=" + encodeURI(password) + "&username=" + username
-  var remoteUrl = "http://localhost:3000/" + username + "/" + reponame + ".git?server=" + encodeURI("https://github.com") + "&" + githubCredentials
-  repo.addRemote("origin", remoteUrl)
-  return repo
+MemoryRepo.prototype.haveRefs = function(refs) {
+  var have = []
+  _(refs).each(function(ref) {
+    if (this.objects[ref.sha] != null) {
+      have.push(ref)
+    }
+  })
+  return have
 }
 
+MemoryRepo.prototype.getAllRefs = function() {
+  return _(that.getRemotes()).reduce(function(memo, remote) {
+    return memo.concat(remote.getRefs())
+  }, that.getRefs())
+}
+
+// Add a ref to this repo. fullName is of the form:
+//   refs/heads/master or refs/tags/123
+MemoryRepo.prototype.addRef = function(fullName, sha) {
+  var type = fullName.split("/")[1]
+  var name = fullName.split("/")[2]
+  this.refs[name] = {name:name, sha:sha, remote:null, type:type}
+}
 
+MemoryRepo.prototype.getRemote = function(name) {
+  return this.remotes[name]
+}
 
+MemoryRepo.prototype.getRemotes = function() {
+  return _(this.remotes).values()
+}
 
+MemoryRepo.prototype.addRemote = function(name, url) {
+  this.remotes[name] = new HttpRemote(this, name, url)
+}
 
+MemoryRepo.prototype.addRemoteObject = function(name, remote) {
+  this.remotes[name] = remote
+}
 
+MemoryRepo.prototype.makeAndAddObject = function(sha, type, content) {
+  this.objects[sha] = Objects.make(sha, type, content)
+  return this.objects[sha]
+}
 
+MemoryRepo.prototype.addObject = function(object) {
+  this.objects[object.sha] = object
+  return object
+}
 
+MemoryRepo.prototype.getObjectShas = function(sha) {
+  return _(this.objects).keys()
+}
 
+MemoryRepo.prototype.objectCount = function() {
+  return _(this.objects).keys().length
+}
 
+MemoryRepo.prototype.getObject = function(sha, callback) {
+  var already = this.objects[sha]
+  if (already) { return callback(null, already) }
 
+  var remote = that.getRemotes()[0]
+  remote.getObject(sha, function(object) {
+    if (object) {
+      that.addObject(object)
+    }
+    callback(null, object)
+  })
+}
 
+module.exports = exports = MemoryRepo 
diff --git a/lib/git/objects.js b/lib/git/objects.js
index d3e472e..383fcd1 100644
--- a/lib/git/objects.js
+++ b/lib/git/objects.js
@@ -1,5 +1,8 @@
+var BinaryFile = require('../binary_file')
+  , utils = require('./utils')
+  , _ = require('underscore')
 
-Git.objects = {
+var Objects = {
   CONSTRUCTOR_NAMES:{
     "blob": "Blob", 
     "tree": "Tree", 
@@ -8,7 +11,7 @@ Git.objects = {
   },
   
   make: function(sha, type, content) {
-    var constructor = Git.objects[this.CONSTRUCTOR_NAMES[type]]
+    var constructor = Objects[this.CONSTRUCTOR_NAMES[type]]
     if (constructor) {
       return new constructor(sha, content)
     } else {
@@ -21,7 +24,7 @@ Git.objects = {
     this.sha = sha
     this.data = data
     this.toString = function() {
-      return data
+      return 'blob: '+this.sha 
     }
   },
   
@@ -51,7 +54,7 @@ Git.objects = {
       }
       advance(1)
       if (bytes.length > 0) {
-        return Git.bytesToString(bytes)
+        return utils.bytesToString(bytes)
       }
       else {
         return false
@@ -59,10 +62,10 @@ Git.objects = {
     }
     
     var matchMode = function() {
-      var first = collectUntil(Git.stringToBytes(" ")[0])
+      var first = collectUntil(utils.stringToBytes(" ")[0])
       if (!first) return null
       if (first != "100644" && first != "40000") {
-        first = collectUntil(Git.stringToBytes(" ")[0])
+        first = collectUntil(utils.stringToBytes(" ")[0])
       }
       return first
     }
@@ -127,9 +130,8 @@ Git.objects = {
     }
     
     var parseAuthor = function(line) {
-      var match = /^(.*) <(.*)> (\d+) \+\d\d\d\d$/.exec(line)
+      var match = /^(.*) <(.*)> (\d+) [\+\-]\d\d\d\d$/.exec(line)
       var result = {}
-      
       result.name = match[1]
       result.email = match[2]
       result.timestamp = parseInt(match[3])
@@ -165,3 +167,4 @@ Git.objects = {
   }
 }
 
+module.exports = exports = Objects
diff --git a/lib/git/pack-file.js b/lib/git/pack-file.js
index df19ed5..660c727 100644
--- a/lib/git/pack-file.js
+++ b/lib/git/pack-file.js
@@ -1,38 +1,43 @@
 var fs   = require('fs')
-var path = require('path')
+  , path = require('path')
+  , PackIndex   = require('./pack_index')
+  , Pack    = require('./pack')
 
-Git.PackFile = function(repo, sha) {
+var PackFile = function(repo, sha) {
   var that = this
-  that.repo = repo
-  that.sha = sha
-  
-  that.getPackIndex = function(callback) {
-    var packPath = path.join(repo.gitDir, "objects/pack/pack-" + sha + ".idx")
-    fs.readFile(packPath, function(err, data) {
-      var string = data.toString("binary")
-      callback(new Git.PackIndex(string))
-    })
-  }
-  
-  that.getPack = function(callback) {
-    var packPath = path.join(repo.gitDir, "objects/pack/pack-" + sha + ".pack")
-    fs.readFile(packPath, function(err, data) {
-      var string = data.toString("binary")
-      callback(new Git.Pack(string))
-    })
-  }
-  
-  that.getObject = function(sha, callback) {
-    that.getPackIndex(function(packIndex) {
-      var offset = packIndex.getOffset(sha)
-      if (offset) {
-        that.getPack(function(pack) {
-          var object = pack.getObjectAtOffset(offset)
-          callback(object)
-        })
-      } else {
-        callback(null)
-      }
-    })
-  }
-}
\ No newline at end of file
+  this.repo = repo
+  this.sha = sha
+}
+
+PackFile.prototype.getPackIndex = function(callback) {
+  var packPath = path.join(this.repo.gitDir, "objects/pack/pack-" + this.sha + ".idx")
+  fs.readFile(packPath, function(err, data) {
+    var string = data.toString("binary")
+    callback(new PackIndex(string))
+  })
+}
+
+PackFile.prototype.getPack = function(callback) {
+  var packPath = path.join(this.repo.gitDir, "objects/pack/pack-" + this.sha + ".pack")
+  fs.readFile(packPath, function(err, data) {
+    var string = data.toString("binary")
+    callback(new Pack(string))
+  })
+}
+
+PackFile.prototype.getObject = function(sha, callback) {
+  var self = this
+  self.getPackIndex(function(packIndex) {
+    var offset = packIndex.getOffset(sha)
+    if (offset) {
+      self.getPack(function(pack) {
+        var object = pack.getObjectAtOffset(offset)
+        callback(object)
+      })
+    } else {
+      callback(null)
+    }
+  })
+}
+
+module.exports = exports = PackFile
diff --git a/lib/git/pack.js b/lib/git/pack.js
index 4e19bba..16a6393 100644
--- a/lib/git/pack.js
+++ b/lib/git/pack.js
@@ -1,4 +1,44 @@
+var BinaryFile = require('../binary_file')
+  , utils = require('./utils')
+  , Sha1 = require('../../vendor/sha1')
+  , inflate = require('../../vendor/js-deflate/rawinflate')
+  , applyDelta = require('./delta')
+  , Objects = require('./objects')
+  , _ = require('underscore')
 
+// Defined in RFC 1950
+var adler32 = function(string) {
+  var s1 = 1,
+      s2 = 0,
+      i;
+  var bytes = utils.stringToBytes(string)
+  for(i = 0; i < bytes.length; i++) {
+    s1 = s1 + bytes[i]
+    s2 = s2 + s1
+    s1 = s1 % 65521
+    s2 = s2 % 65521
+  }
+  return s2*65536 + s1
+}
+
+var objectHash = function(type, content) {
+  var data = type + " " + content.length + "\0" + content
+  // return new SHA1(data).hexdigest()
+  return Sha1.rstr2hex(Sha1.rstr_sha1(data))
+}
+
+var intToBytes = function(val, atLeast) {
+  var bytes = []
+  var current = val
+  while (current > 0) {
+    bytes.push(current % 256)
+    current = Math.floor(current / 256)
+  }
+  while (atLeast && bytes.length < atLeast) {
+    bytes.push(0)
+  }
+  return bytes.reverse()
+}
 
 // Encapsulates a pack file, with methods to extract objects:
 //
@@ -8,313 +48,278 @@
 // some time for all but the smallest pack files.
 //
 //  parseAll()
-Git.Pack = function(binary) {
-  var binaryString = Git.toBinaryString(binary)
-  var data = new BinaryFile(binaryString)
-  var offset = 0
-  var objects = null
-  
-  if (typeof require === "undefined") {
-    var myDebug = function(obj) { console.log(obj) }
+
+var Pack = function(binary) {
+  this.binaryString = utils.toBinaryString(binary)
+  this.data = new BinaryFile(this.binaryString)
+  this.offset = 0
+  this.objects = null
+}
+
+Pack.prototype.peek = function(length) {
+  return this.data.slice(this.offset, this.offset + length)
+}
+
+Pack.prototype.rest = function() {
+  return this.data.slice(this.offset)
+}
+
+Pack.prototype.advance = function(length) {
+  this.offset += length
+}
+
+Pack.prototype.matchPrefix = function() {
+  if (utils.bytesToString(this.peek(4)) === "PACK") {
+    this.advance(4)
   }
   else {
-    var myDebug = require('util').debug
-  }
-  
-  var peek = function(length) {
-    return data.slice(offset, offset + length)
-  }
-  
-  var rest = function() {
-    return data.slice(offset)
-  }
-  
-  var advance = function(length) {
-    offset += length
-  }
-  
-  var matchPrefix = function() {
-    if (Git.bytesToString(peek(4)) === "PACK") {
-      advance(4)
-    }
-    else {
-      throw(Error("couldn't match PACK"))
-    }
-  }
-  
-  var matchVersion = function(expectedVersion) {
-    var actualVersion = peek(4)[3]
-    advance(4)
-    if (actualVersion !== expectedVersion) {
-      throw("expected packfile version " + expectedVersion + ", but got " + actualVersion)
-    }
-  }
-  
-  var matchNumberOfObjects = function() {
-    var num = 0
-    _(peek(4)).each(function(b) {
-      num = num << 8
-      num += b
-    })
-    advance(4);
-    return num;
+    throw new Error("couldn't match PACK")
   }
-  
-  var objectSizeInfosToSize = function(sizeInfos) {
-    var current = 0,
-        currentShift = 0,
-        i,
-        sizeInfo;
-        
-    for (i = 0; i < sizeInfos.length; i++) {
-      sizeInfo = sizeInfos[i]
-      current += (parseInt(sizeInfo, 2) << currentShift)
-      currentShift += sizeInfo.length
-    }
-    return current
-  }
-  
-  var getType = function(typeStr) {
-    return {
-      "001":"commit",
-      "010":"tree",
-      "011":"blob",
-      "100":"tag",
-      "110":"ofs_delta",
-      "111":"ref_delta"
-      }[typeStr]
-  }
-    
-  var matchObjectHeader = function() {
-    var sizeInfos       = []
-    var hintTypeAndSize = peek(1)[0].toString(2).rjust(8, "0")
-    var typeStr         = hintTypeAndSize.slice(1, 4)
-    var needMore        = (hintTypeAndSize[0] == "1")
-    var hintAndSize     = null
-    var objectStartOffset = offset
-    
-    sizeInfos.push(hintTypeAndSize.slice(4, 8))
-    advance(1)
-
-    while (needMore) {
-      hintAndSize = peek(1)[0].toString(2).rjust(8, "0")
-      needMore    = (hintAndSize[0] == "1")
-      sizeInfos.push(hintAndSize.slice(1))
-      advance(1)
-    }
-    return {size:objectSizeInfosToSize(sizeInfos), type:getType(typeStr), offset: objectStartOffset}
+}
+
+Pack.prototype.matchVersion = function(expectedVersion) {
+  var actualVersion = this.peek(4)[3]
+  this.advance(4)
+  if (actualVersion !== expectedVersion) {
+    throw new Error("expected packfile version " + expectedVersion + ", but got " + actualVersion)
   }
-  
-  // Defined in RFC 1950
-  var adler32 = function(string) {
-    var s1 = 1,
-        s2 = 0,
-        i;
-    var bytes = Git.stringToBytes(string)
-    for(i = 0; i < bytes.length; i++) {
-      s1 = s1 + bytes[i]
-      s2 = s2 + s1
-      s1 = s1 % 65521
-      s2 = s2 % 65521
-    }
-    return s2*65536 + s1
+}
+
+Pack.prototype.matchNumberOfObjects = function() {
+  var num = 0
+  _(this.peek(4)).each(function(b) {
+    num = num << 8
+    num += b
+  })
+  this.advance(4);
+  return num;
+}
+
+Pack.prototype.objectSizeInfosToSize = function(sizeInfos) {
+  var current = 0,
+      currentShift = 0,
+      i,
+      sizeInfo;
+
+  for (i = 0; i < sizeInfos.length; i++) {
+    sizeInfo = sizeInfos[i]
+    current += (parseInt(sizeInfo, 2) << currentShift)
+    currentShift += sizeInfo.length
   }
-  
-  var intToBytes = function(val, atLeast) {
-    var bytes = []
-    var current = val
-    while (current > 0) { 
-      bytes.push(current % 256)
-      current = Math.floor(current / 256)
-    }
-    while (atLeast && bytes.length < atLeast) {
-      bytes.push(0)
-    }
-    return bytes.reverse()
+  return current
+}
+
+Pack.prototype.getType = function(typeStr) {
+  return {
+    "001":"commit",
+    "010":"tree",
+    "011":"blob",
+    "100":"tag",
+    "110":"ofs_delta",
+    "111":"ref_delta"
+    }[typeStr]
+}
+
+Pack.prototype.matchObjectHeader = function() {
+  var sizeInfos       = []
+  var hintTypeAndSize = this.peek(1)[0].toString(2).rjust(8, "0")
+  var typeStr         = hintTypeAndSize.slice(1, 4)
+  var needMore        = (hintTypeAndSize[0] == "1")
+  var hintAndSize     = null
+  var objectStartOffset = this.offset
+
+  sizeInfos.push(hintTypeAndSize.slice(4, 8))
+  this.advance(1)
+
+  while (needMore) {
+    hintAndSize = this.peek(1)[0].toString(2).rjust(8, "0")
+    needMore    = (hintAndSize[0] == "1")
+    sizeInfos.push(hintAndSize.slice(1))
+    this.advance(1)
   }
-  
-  var matchBytes = function(bytes) {
-    var i
-    var nextByte
-    for (i = 0; i < bytes.length; i++) {
-      nextByte = peek(1)[0]
-      if (nextByte !== bytes[i]) {
-        throw(Error("adler32 checksum didn't match"))
-      }
-      advance(1)
+  return {size:this.objectSizeInfosToSize(sizeInfos), type:this.getType(typeStr), offset: objectStartOffset}
+}
+
+Pack.prototype.matchBytes = function(bytes) {
+  var i
+  var nextByte
+  for (i = 0; i < bytes.length; i++) {
+    nextByte = this.peek(1)[0]
+    if (nextByte !== bytes[i]) {
+      throw new Error("adler32 checksum didn't match")
     }
+    this.advance(1)
   }
-  
-  var advanceToBytes = function(bytes) {
-    var nextByte
-    var matchedByteCount = 0
-    while (matchedByteCount < bytes.length) {
-      nextByte = peek(1)[0]
-      if (nextByte == bytes[matchedByteCount]) {
-        matchedByteCount++
-      } else {
-        matchedByteCount = 0
-      }
-      advance(1)
+}
+
+// XXX: Possibly unused?
+Pack.prototype.advanceToBytes = function(bytes) {
+  var nextByte
+  var matchedByteCount = 0
+  while (matchedByteCount < bytes.length) {
+    nextByte = peek(1)[0]
+    if (nextByte == bytes[matchedByteCount]) {
+      matchedByteCount++
+    } else {
+      matchedByteCount = 0
     }
+    this.advance(1)
   }
-  
-  var objectHash = function(type, content) {
-    var data = type + " " + content.length + "\0" + content
-    // return new SHA1(data).hexdigest()
-    return Sha1.rstr2hex(Sha1.rstr_sha1(data))
-  }
-  
-  var matchOffsetDeltaObject = function(header) {
-    var offsetBytes       = []
-    var hintAndOffsetBits = peek(1)[0].toString(2).rjust(8, "0")
-    var needMore          = (hintAndOffsetBits[0] == "1")
-    
-    offsetBytes.push(hintAndOffsetBits.slice(1, 8))
-    advance(1)
+}
 
-    while (needMore) {
-      hintAndOffsetBits = peek(1)[0].toString(2).rjust(8, "0")
-      needMore          = (hintAndOffsetBits[0] == "1")
-      offsetBytes.push(hintAndOffsetBits.slice(1, 8))
-      advance(1)
-    }
-    
-    var longOffsetString = _(offsetBytes).reduce(function(memo, byteString) {
-      return memo + byteString
-    }, "")
-    
-    var offsetDelta = parseInt(longOffsetString, 2)
-    var n = 1
-    _(offsetBytes.length - 1).times(function() {
-      offsetDelta += Math.pow(2, 7*n)
-      n += 1
-    })
-
-    var deflated = Git.stripZlibHeader(rest())
-    var uncompressedData = RawDeflate.inflate(Git.bytesToString(deflated))
-    var checksum = adler32(uncompressedData)
-    advance(2 + uncompressedData.compressedLength)
-    matchBytes(intToBytes(checksum, 4))
-    return {
-      type: header.type,
-      sha: null,
-      desiredOffset: header.offset - offsetDelta,
-      offset: header.offset,
-      data: Git.stringToBytes(uncompressedData.toString())
-    }
+Pack.prototype.matchOffsetDeltaObject = function(header) {
+  var offsetBytes       = []
+  var hintAndOffsetBits = this.peek(1)[0].toString(2).rjust(8, "0")
+  var needMore          = (hintAndOffsetBits[0] == "1")
+
+  offsetBytes.push(hintAndOffsetBits.slice(1, 8))
+  this.advance(1)
+
+  while (needMore) {
+    hintAndOffsetBits = this.peek(1)[0].toString(2).rjust(8, "0")
+    needMore          = (hintAndOffsetBits[0] == "1")
+    offsetBytes.push(hintAndOffsetBits.slice(1, 8))
+    this.advance(1)
   }
-  
-  var matchNonDeltaObject = function(header) {
-    var deflated = Git.stripZlibHeader(rest())
-    var uncompressedData = RawDeflate.inflate(Git.bytesToString(deflated))
-    var checksum = adler32(uncompressedData)
-    advance(2 + uncompressedData.compressedLength)
-    matchBytes(intToBytes(checksum, 4))
-    
-    return {
-      offset: header.offset,
-      type: header.type,
-      sha: objectHash(header.type, uncompressedData),
-      data: uncompressedData.toString()
-    }
+
+  var longOffsetString = _(offsetBytes).reduce(function(memo, byteString) {
+    return memo + byteString
+  }, "")
+
+  var offsetDelta = parseInt(longOffsetString, 2)
+  var n = 1
+  _(offsetBytes.length - 1).times(function() {
+    offsetDelta += Math.pow(2, 7*n)
+    n += 1
+  })
+
+  var deflated = utils.stripZlibHeader(this.rest())
+  var uncompressedData = inflate(utils.bytesToString(deflated))
+  var checksum = adler32(uncompressedData)
+  this.advance(2 + uncompressedData.compressedLength)
+  this.matchBytes(intToBytes(checksum, 4))
+  return {
+    type: header.type,
+    sha: null,
+    desiredOffset: header.offset - offsetDelta,
+    offset: header.offset,
+    data: utils.stringToBytes(uncompressedData.toString())
   }
-  
-  var matchObjectData = function(header) {
-    if (header.type == "ofs_delta") {
-      return matchOffsetDeltaObject(header)
-    }
-    else if (header.type == "ref_delta") {
-      var shaBytes = peek(20)
-      advance(20)
-      var sha = _(shaBytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
-      throw(Error("found ref_delta"))
-    }
-    else {
-      return matchNonDeltaObject(header)
-    }
+}
+
+Pack.prototype.matchNonDeltaObject = function(header) {
+  var deflated = utils.stripZlibHeader(this.rest())
+  var uncompressedData = inflate(utils.bytesToString(deflated))
+  var checksum = adler32(uncompressedData)
+  this.advance(2 + uncompressedData.compressedLength)
+  this.matchBytes(intToBytes(checksum, 4))
+
+  return {
+    offset: header.offset,
+    type: header.type,
+    sha: objectHash(header.type, uncompressedData),
+    data: uncompressedData.toString()
   }
-  
-  var matchObjectAtOffset = function(startOffset) {
-    offset = startOffset
-    var header = matchObjectHeader()
-    return matchObjectData(header)
+}
+
+Pack.prototype.matchObjectData = function(header) {
+  if (header.type == "ofs_delta") {
+    return this.matchOffsetDeltaObject(header)
   }
-  
-  var stripOffsetsFromObjects = function() {
-    _(objects).each(function(object) {
-      delete object.offset
-    })
+  else if (header.type == "ref_delta") {
+    var shaBytes = peek(20)
+    this.advance(20)
+    var sha = _(shaBytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
+    throw new Error("found ref_delta")
   }
-  
-  var objectAtOffset = function(offset) {
-    return _(objects).detect(function(obj) { return obj.offset == offset })
+  else {
+    return this.matchNonDeltaObject(header)
   }
-  
-  var expandOffsetDeltas = function() {
-    _(objects).each(function(object) {
-      expandDelta(object)
-    })
+}
+
+Pack.prototype.matchObjectAtOffset = function(startOffset) {
+  this.offset = startOffset
+  var header = this.matchObjectHeader()
+  return this.matchObjectData(header)
+}
+
+Pack.prototype.stripOffsetsFromObjects = function() {
+  _(this.objects).each(function(object) {
+    delete object.offset
+  })
+}
+
+Pack.prototype.objectAtOffset = function(offset) {
+  return _(this.objects).detect(function(obj) { return obj.offset == offset })
+}
+
+Pack.prototype.expandOffsetDeltas = function() {
+  var self = this
+  _(this.objects).each(function(object) {
+    self.expandDelta(object)
+  })
+}
+
+Pack.prototype.expandDelta = function(object) {
+  if (object.type == "ofs_delta") {
+    this.expandOffsetDelta(object)
   }
-  
-  var expandDelta = function(object) {
-    if (object.type == "ofs_delta") {
-      expandOffsetDelta(object)
-    }
+}
+
+Pack.prototype.getObjectAtOffset = function(offset) {
+  if (this.objects) {
+    return this.objectAtOffset(offset)
   }
-  
-  var getObjectAtOffset = function(offset) {
-    if (objects) {
-      return objectAtOffset(offset)
-    }
-    var rawObject = matchObjectAtOffset(offset)
-    expandDelta(rawObject)
-    var newObject = Git.objects.make(rawObject.sha, rawObject.type, rawObject.data)
-    return newObject
+  var rawObject = this.matchObjectAtOffset(offset)
+  this.expandDelta(rawObject)
+
+  var newObject = Objects.make(rawObject.sha, rawObject.type, rawObject.data)
+  return newObject
+}
+
+Pack.prototype.expandOffsetDelta = function(object) {
+  var baseObject = this.getObjectAtOffset(object.desiredOffset)
+  if (baseObject.type == "ofs_delta" || baseObject.type == "ref_delta") {
+    throw new Error("delta pointing to delta, can't handle this yet")
   }
-  
-  var expandOffsetDelta = function(object) {
-    var baseObject = getObjectAtOffset(object.desiredOffset)
-    if (baseObject.type == "ofs_delta" || baseObject.type == "ref_delta") {
-      throw(Error("delta pointing to delta, can't handle this yet"))
-    }
-    else {
-      var expandedData = Git.applyDelta(baseObject.data, object.data)
-      object.type = baseObject.type
-      object.fromDelta = {type: "ofs_delta", data: object.data, base: baseObject.sha}
-      delete object.desiredOffset
-      object.data = expandedData
-      object.sha = objectHash(object.type, object.data)
-    }
+  else {
+    var expandedData = applyDelta(baseObject.data, object.data)
+    object.type = baseObject.type
+    object.fromDelta = {type: "ofs_delta", data: object.data, base: baseObject.sha}
+    delete object.desiredOffset
+    object.data = expandedData
+    object.sha = objectHash(object.type, object.data)
   }
+}
 
-  this.parseAll = function() {
-    try {
-      var numObjects
-      var i
-      objects = []
-      
-      matchPrefix()
-      matchVersion(2)
-      numObjects = matchNumberOfObjects()
-      
-      for (i = 0; i < numObjects; i++) {
-        var object = matchObjectAtOffset(offset)
-        objects.push(object)
-      }
-      expandOffsetDeltas()
-      stripOffsetsFromObjects()
-    }
-    catch(e) {
-      console.log("Error caught in pack file parsing data") // + Git.stringToBytes(data.getRawData()))
-      throw(e)
+Pack.prototype.parseAll = function() {
+  try {
+    var numObjects
+    var i
+    this.objects = []
+
+    this.matchPrefix()
+    this.matchVersion(2)
+    numObjects = this.matchNumberOfObjects()
+
+    for (i = 0; i < numObjects; i++) {
+      var object = this.matchObjectAtOffset(this.offset)
+      this.objects.push(object)
     }
-    return this
+    this.expandOffsetDeltas()
+    this.stripOffsetsFromObjects()
   }
-  
-  this.getObjects = function() {
-    return objects
+  catch(e) {
+    console.log("Error caught in pack file parsing data")
+    throw(e)
   }
-  
-  this.getObjectAtOffset = getObjectAtOffset
+  return this
+}
+
+Pack.prototype.getObjects = function() {
+  return this.objects
 }
+
+Pack.prototype.getObjectAtOffset = Pack.prototype.getObjectAtOffset
+
+module.exports = exports = Pack
diff --git a/lib/git/pack_index.js b/lib/git/pack_index.js
index 73304e7..e74a8a4 100644
--- a/lib/git/pack_index.js
+++ b/lib/git/pack_index.js
@@ -1,119 +1,126 @@
+var BinaryFile = require('../binary_file')
+  , _ = require('underscore')
 
 // This object partially parses the data contained in a pack-*.idx file, and provides
 // access to the offsets of the objects the packfile and the crc checksums of the objects.
-Git.PackIndex = function(data) {
+var PackIndex = function(data) {
   this.data = new BinaryFile(data)
   
-  if (!Git.PackIndex.assertVersion(this.data, 2)) {
+  if (!this.assertVersion(2)) {
     throw(Error("pack index is not version 2"))
   }
-  
-  this.bytesToInteger = function(bytes) {
-    var val = 0
-    _(bytes).each(function(b) {
-      val += b
-      val *= 256
-    })
-    return val/256
-  }
-  
-  this.bytesToSha = function(bytes) {
-    return _(bytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
-  }
-  
-  this.numObjects = function() {
-    return this.bytesToInteger(this.data.slice(8 + 255*4, 8 + 255*4 + 4))
-  }
-  
-  // Return the offset within the packfile of the object with the given sha.
-  this.getOffset = function(sha) {
-    var numObjects = this.numObjects()
-    var ix = this.indexOfSha(sha)
-    return this.offsets[ix]
-  }
-  
-  // Return the checksum of the object with the given sha.
-  this.getCrc = function(sha) {
-    var numObjects = this.numObjects()
-    var crcArrayOffset = 8 + 256*4 + numObjects*20
-    var ix = this.indexOfSha(sha)
-    var offset = crcArrayOffset + ix*4
-    return this.bytesToInteger(this.data.slice(offset, offset + 4))
-  }
-  
-  // Does this pack index contain 64b offsets?
-  this.has64bOffsets = function() {
-    var numObjects = this.numObjects()
-    var expectedLength = 8 + 256*4 + numObjects*20 + numObjects*4 + numObjects*4 + 40
-    return this.data.length > expectedLength + 7 // 64b offsets are 8 bytes
+  var info = this.offsetInfo()
+  this.offsets = info.offsets
+  this.maxOffset = info.max
+}
+
+PackIndex.prototype.bytesToInteger = function(bytes) {
+  var val = 0
+  _(bytes).each(function(b) {
+    val += b
+    val *= 256
+  })
+  return val/256
+}
+
+PackIndex.prototype.bytesToSha = function(bytes) {
+  return _(bytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
+}
+
+PackIndex.prototype.numObjects = function() {
+  return this.bytesToInteger(this.data.slice(8 + 255*4, 8 + 255*4 + 4))
+}
+
+// Return the offset within the packfile of the object with the given sha.
+PackIndex.prototype.getOffset = function(sha) {
+  var numObjects = this.numObjects()
+  var ix = this.indexOfSha(sha)
+  return this.offsets[ix]
+}
+
+// Return the checksum of the object with the given sha.
+PackIndex.prototype.getCrc = function(sha) {
+  var numObjects = this.numObjects()
+  var crcArrayOffset = 8 + 256*4 + numObjects*20
+  var ix = this.indexOfSha(sha)
+  var offset = crcArrayOffset + ix*4
+  return this.bytesToInteger(this.data.slice(offset, offset + 4))
+}
+
+// Does this pack index contain 64b offsets?
+PackIndex.prototype.has64bOffsets = function() {
+  var numObjects = this.numObjects()
+  var expectedLength = 8 + 256*4 + numObjects*20 + numObjects*4 + numObjects*4 + 40
+  return this.data.length > expectedLength + 7 // 64b offsets are 8 bytes
+}
+
+// Returns the index offset into the sha array which is the first occurrence
+// of shas with first byte matching the first byte of the given sha.
+PackIndex.prototype.fanout = function(sha) {
+  var firstByte = parseInt(sha.slice(0, 2), 16) - 1
+  if (firstByte === -1) {
+    return 0
+  } else {
+    var fanoutBytes = this.data.slice(8 + firstByte*4, 8 + firstByte*4 + 4)
+    return this.bytesToInteger(fanoutBytes)
   }
-  
-  // Returns the index offset into the sha array which is the first occurrence
-  // of shas with first byte matching the first byte of the given sha.
-  this.fanout = function(sha) {
-    var firstByte = parseInt(sha.slice(0, 2), 16) - 1
-    if (firstByte === -1) {
-      return 0
+}
+
+// Returns the index of this sha into the three arrays: sha[], crc[] and offset[]
+PackIndex.prototype.indexOfSha = function(sha) {
+  var ix = this.fanout(sha)
+  var currentSha = this.shaAtIndex(ix)
+  var firstByte = sha.slice(0, 2)
+  while (currentSha !== sha) {
+    ix++
+    currentSha = this.shaAtIndex(ix)
+    if (ix >= this.numObjects()) {
+      return null
     } else {
-      var fanoutBytes = this.data.slice(8 + firstByte*4, 8 + firstByte*4 + 4)
-      return this.bytesToInteger(fanoutBytes)
-    }
-  }
-  
-  // Returns the index of this sha into the three arrays: sha[], crc[] and offset[]
-  this.indexOfSha = function(sha) {
-    var ix = this.fanout(sha)
-    var currentSha = this.shaAtIndex(ix)
-    var firstByte = sha.slice(0, 2)
-    while (currentSha !== sha) {
-      ix++
-      currentSha = this.shaAtIndex(ix)
-      if (ix >= this.numObjects()) {
+      if (currentSha.slice(0, 2) !== firstByte) {
         return null
-      } else {
-        if (currentSha.slice(0, 2) !== firstByte) {
-          return null
-        }
       }
     }
-    return ix 
   }
-  
-  // Returns the sha at the given index into the sha array
-  this.shaAtIndex = function(ix) {
-    var shaArrayOffset = 8 + 256*4
-    var offset = shaArrayOffset + ix*20
-    return this.bytesToSha(this.data.slice(offset, offset + 20))
-  }
-  
-  // Extracts the offset array from the data, and gets the maximum offset
-  // Return {offsets: [int], max: int}
-  this.offsetInfo = function() {
-    var offsets = []
-    var numObjects = this.numObjects()
-    var offsetArrayOffset = 8 + 256*4 + numObjects*20 + numObjects*4
-    var i
-    var max = 0
-    for (i = 0; i < numObjects; i++) {
-      var offsetBytes = this.data.slice(offsetArrayOffset + i*4, offsetArrayOffset + i*4 + 4)
-      var offset = this.bytesToInteger(offsetBytes)
-      if (offset > max) { max = offset}
-      offsets.push(offset)
-    }
-    return {offsets: offsets, max: max}
-  }
-  
-  // Returns an estimate (a lower bound) of the size of the packfile. 
-  this.estimatedPackFileSize = function() {
-    return this.maxOffset
+  return ix 
+}
+
+// Returns the sha at the given index into the sha array
+PackIndex.prototype.shaAtIndex = function(ix) {
+  var shaArrayOffset = 8 + 256*4
+  var offset = shaArrayOffset + ix*20
+  return this.bytesToSha(this.data.slice(offset, offset + 20))
+}
+
+// Extracts the offset array from the data, and gets the maximum offset
+// Return {offsets: [int], max: int}
+PackIndex.prototype.offsetInfo = function() {
+  var offsets = []
+  var numObjects = this.numObjects()
+  var offsetArrayOffset = 8 + 256*4 + numObjects*20 + numObjects*4
+  var i
+  var max = 0
+  for (i = 0; i < numObjects; i++) {
+    var offsetBytes = this.data.slice(offsetArrayOffset + i*4, offsetArrayOffset + i*4 + 4)
+    var offset = this.bytesToInteger(offsetBytes)
+    if (offset > max) { max = offset}
+    offsets.push(offset)
   }
-  
-  var info = this.offsetInfo()
-  this.offsets = info.offsets
-  this.maxOffset = info.max
+  return {offsets: offsets, max: max}
 }
 
-Git.PackIndex.assertVersion = function(binary, expectedVersion) {
-  var versionBytes = binary.slice(4, 8)
+// Returns an estimate (a lower bound) of the size of the packfile. 
+PackIndex.prototype.estimatedPackFileSize = function() {
+  return this.maxOffset
+}
+  
+PackIndex.prototype.assertVersion = function(expectedVersion) {
+  var versionBytes = this.data.slice(4, 8)
   return _(versionBytes).isEqual([0, 0, 0, expectedVersion])
 }
+
+PackIndex.assertVersion = function(data, expectedVersion) {
+  return PackIndex.prototype.assertVersion.call({data:data}, expectedVersion)
+}
+
+module.exports = exports = PackIndex
diff --git a/lib/git/remote.js b/lib/git/remote.js
index 70ae823..c15f7b4 100644
--- a/lib/git/remote.js
+++ b/lib/git/remote.js
@@ -1,52 +1,6 @@
+var _ = require('underscore')
 
-Git.Remote = function(repo, name, repoUrl) {
-  this.repo = repo
-  this.name = name
-  this.refs = {}
-  this.url = repoUrl.replace(/\?.*/, "").replace(/\/$/, "")
-  this.urlOptions = Git.Remote.queryParams(repoUrl)
-
-  this.makeUri = function(path, extraOptions) {
-    var uri = this.url + path
-    var options = _(this.urlOptions).extend(extraOptions || {})
-    if (options && _(options).size() > 0) {
-      var optionKeys = _(options).keys()
-      var optionPairs = _(optionKeys).map(function(optionName) {
-        return optionName + "=" + encodeURI(options[optionName])
-      })
-
-      return uri + "?" + optionPairs.join("&")
-    }
-    else {
-      return uri
-    }
-  }
-
-  // Add a ref to this remote. fullName is of the form:
-  //   refs/heads/master or refs/tags/123
-  this.addRef = function(fullName, sha) {
-    var type, name
-    if (fullName.slice(0, 5) == "refs/") {
-      type = fullName.split("/")[1]
-      name = this.name + "/" + fullName.split("/")[2]
-    }
-    else {
-      type = "HEAD"
-      name = this.name + "/" + "HEAD"
-    }
-    this.refs[name] = {name:name, sha:sha, remote:this, type:type}
-  }
-  
-  this.getRefs = function() {
-    return _(this.refs).values()
-  }
-  
-  this.getRef = function(name) {
-    return this.refs[this.name + "/" + name]
-  }
-}
-
-Git.Remote.queryParams = function(uri) {
+var queryParams = function(uri) {
   var paramString = uri.split("?")[1]
   if (!paramString) {
     return {}
@@ -61,47 +15,51 @@ Git.Remote.queryParams = function(uri) {
   return params
 }
 
+var Remote = function(repo, name, repoUrl) {
+  this.repo = repo
+  this.name = name
+  this.refs = {}
+  this.url = repoUrl.replace(/\?.*/, "").replace(/\/$/, "")
+  this.urlOptions = queryParams(repoUrl)
+};
+
+Remote.prototype.makeUri = function(path, extraOptions) {
+  var uri = this.url + path
+  var options = _(this.urlOptions).extend(extraOptions || {})
+  if (options && _(options).size() > 0) {
+    var optionKeys = _(options).keys()
+    var optionPairs = _(optionKeys).map(function(optionName) {
+      return optionName + "=" + encodeURI(options[optionName])
+    })
+
+    return uri + "?" + optionPairs.join("&")
+  }
+  else {
+    return uri
+  }
+}
 
+// Add a ref to this remote. fullName is of the form:
+//   refs/heads/master or refs/tags/123
+Remote.prototype.addRef = function(fullName, sha) {
+  var type, name
+  if (fullName.slice(0, 5) == "refs/") {
+    type = fullName.split("/")[1]
+    name = this.name + "/" + fullName.split("/")[2]
+  }
+  else {
+    type = "HEAD"
+    name = this.name + "/" + "HEAD"
+  }
+  this.refs[name] = {name:name, sha:sha, remote:this, type:type}
+}
 
+Remote.prototype.getRefs = function() {
+  return _(this.refs).values()
+}
 
+Remote.prototype.getRef = function(name) {
+  return this.refs[this.name + "/" + name]
+}
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+module.exports = exports = Remote
diff --git a/lib/git/repo.js b/lib/git/repo.js
index d7b57a8..e26f9c4 100644
--- a/lib/git/repo.js
+++ b/lib/git/repo.js
@@ -1,170 +1,193 @@
-var path = require('path')
-var fs   = require('fs')
-var util = require('util')
+var BinaryFile = require('../binary_file')
+  , path = require('path')
+  , fs   = require('fs')
+  , utils = require('./utils')
+  , PackFile = require('./pack-file')
+  , inflate = require('../../vendor/js-deflate/rawinflate')
+  , Objects = require('./objects')
+
+var firstIndexOfByte = function(bytes, b) {
+  var i = 0
+  while (bytes.getByteAt(i) != b) i += 1
+  return i
+}
 
 // This class encapsulates an on-disk Repo
-Git.Repo = function(gitDir) {
-  var that    = {}
+var Repo = function(gitDir) {
+  var that    = this 
   that.dir    = path.join(gitDir, "..")
   that.gitDir = gitDir
-  
+
   if (!path.existsSync(that.dir)) {
     throw "Error: " + that.dir + " does not exist"
   }
-  
+
   if (!path.existsSync(that.gitDir)) {
     throw "Error: " + that.gitDir + " does not exist"
   }
-  
-  var firstIndexOfByte = function(bytes, b) {
-    var i = 0
-    while (bytes.getByteAt(i) != b) i += 1
-    return i  
-  }
-  
-  // If an object exists loose, returns it. Otherwise, returns null
-  that.getLooseObject = function(sha, callback) {
-    if (sha == "" || !sha) { return callback(err, null) }
-    
-    var objectPath = path.join(that.gitDir, "/objects/" + sha.slice(0, 2) + "/" + sha.slice(2))
-    
-    fs.readFile(objectPath, function(err, data) {
-      if (err) return callback(null, null)
-      
-      var compressedData = data.toString('binary')
-      var deflated = Git.stripZlibHeader(Git.stringToBytes(compressedData))
-      var uncompressedData = new BinaryFile(RawDeflate.inflate(Git.bytesToString(deflated)).toString())
-      var result = Git.bytesToString(uncompressedData.slice(0))
-      var objectType = result.slice(0, 4)
-      var objectData = result.slice(firstIndexOfByte(uncompressedData, 0) + 1)
-      var obj = Git.objects.make(sha, objectType, objectData)
-        
-      callback(null, obj)
+}
+
+// If an object exists loose, returns it. Otherwise, returns null
+Repo.prototype.getLooseObject = function(sha, callback) {
+  var that = this
+  if (sha == "" || !sha) { return callback(err, null) }
+
+  var objectPath = path.join(that.gitDir, "/objects/" + sha.slice(0, 2) + "/" + sha.slice(2))
+
+  fs.readFile(objectPath, function(err, data) {
+    if (err) return callback(null, null)
+
+    var compressedData = data.toString('binary')
+    var deflated = utils.stripZlibHeader(utils.stringToBytes(compressedData))
+    var uncompressedData = new BinaryFile(inflate(utils.bytesToString(deflated)).toString())
+    var result = utils.bytesToString(uncompressedData.slice(0))
+    var objectType = result.slice(0, 4)
+    var objectData = result.slice(firstIndexOfByte(uncompressedData, 0) + 1)
+    var obj = Objects.make(sha, objectType, objectData)
+
+    callback(null, obj)
+  })
+}
+
+// Calls callback with a list of PackFiles
+Repo.prototype.getPackFiles = function(callback) {
+  var that = this
+  fs.readdir(path.join(that.gitDir, "/objects/pack"), function(err, files) {
+    var packFiles = []
+    files.forEach(function(file) {
+      var match = /pack-(.*)\.idx/.exec(file)
+      if (match) {
+        packFiles.push(new PackFile(that, match[1]))
+      }
     })
-  }
-  
-  // Calls callback with a list of PackFiles
-  that.getPackFiles = function(callback) {
-    fs.readdir(path.join(that.gitDir, "/objects/pack"), function(err, files) {
-      var packFiles = []
-      files.forEach(function(file) {
-        var match = /pack-(.*)\.idx/.exec(file)
-        if (match) {
-          packFiles.push(new Git.PackFile(that, match[1]))
+    callback(packFiles)
+  })
+}
+
+// Get the object with the specified sha, or null if it doesn't exist in
+// this repo.
+// callback takes (err, object)
+Repo.prototype.getObject = function(sha, callback) {
+  var that = this
+  if (sha == "" || !sha)     return callback(null)
+  if (sha.slice(-1) == "\n") sha = sha.slice(0, sha.length - 1)
+
+  that.getLooseObject(sha, function(err, object) {
+    if (err) return callback(err)
+
+    if (object) {
+      return callback(null, object)
+    } else {
+      that.getPackFiles(function(packFiles) {
+        for(var i = 0; i < packFiles.length; i++) {
+          ;(function(ix) {
+            packFiles[ix].getObject(sha, function(object) {
+              if (object) {
+                return callback(null, object)
+              } else {
+                if (ix == packFiles.length - 1 ) {
+                  return callback(null, null)
+                }
+              }
+            })
+          })(i)
         }
       })
-      callback(packFiles)
-    })
-  }
+    }
+  })
+  return null
+}
 
-  // Get the object with the specified sha, or null if it doesn't exist in 
-  // this repo.
-  // callback takes (err, object)
-  that.getObject = function(sha, callback) {
-    if (sha == "" || !sha)     return callback(null)
-    if (sha.slice(-1) == "\n") sha = sha.slice(0, sha.length - 1)
-    
-    that.getLooseObject(sha, function(err, object) {
-      if (err) return callback(err)
-      
-      if (object) {
-        return callback(null, object)
-      } else {
-        that.getPackFiles(function(packFiles) {
-          for(var i = 0; i < packFiles.length; i++) {
-            ;(function(ix) {
-              packFiles[ix].getObject(sha, function(object) {
-                if (object) {
-                  return callback(null, object)
-                } else {
-                  if (ix == packFiles.length - 1 ) {
-                    return callback(null, null)
-                  }
+// Get an array of heads [[name, sha], ...].
+// Callback receives(err, data)
+Repo.prototype.getBranches = function(cb) {
+  var that = this
+  var headsDir = path.join(that.gitDir, "/refs/heads")
+  var result = {branchNames: []}
+
+  return fs.readdir(headsDir, parseLooseHeadFiles.bind(this, parsePackedRefFile, ''))
+
+  function parseLooseHeadFiles(done, parent, err, files) {
+    if (err) return cb(err)
+    if (files.length == 0) return parsePackedRefFile()
+
+    var readyCount = files.length;
+
+    for(var i = 0; i < files.length; i++) {
+      (function(ix) {
+        var headPath = path.join(headsDir, parent, files[ix])
+        fs.stat(headPath, function(err, stat) {
+          if(!err) {
+            if(stat.isFile()) {
+              fs.readFile(headPath, function(err, contents) {
+                if (!err) {
+                  result.branchNames.push(path.join(parent, files[ix]))
+                  result[path.join(parent, files[ix])] = contents.toString("ascii")
+                }
+                if (--readyCount === 0) {
+                  return done()
                 }
               })
-            })(i)
-          }
-        })
-      }
-    })
-    return null
-  }
-  
-  // Get an array of heads [[name, sha], ...]. 
-  // Callback receives(err, data)
-  that.getBranches = function(cb) {
-    var headsDir = path.join(that.gitDir, "/refs/heads")
-    var result = {branchNames: []}
-    return fs.readdir(headsDir, parseLooseHeadFiles)
-    
-    function parseLooseHeadFiles(err, files) {
-      if (err) return cb(err)
-      if (files.length == 0) return parsePackedRefFile()
-      
-      for(var i = 0; i < files.length; i++) {
-        (function(ix) {
-          var headPath = path.join(headsDir, files[ix])
-          return fs.readFile(headPath, function(err, contents) {
-            if (!err) {
-              result.branchNames.push(files[ix])
-              result[files[ix]] = contents.toString("ascii")
-            }
-            if (ix == files.length - 1) {
-              return parsePackedRefFile()
+            } else {
+              fs.readdir(headPath, parseLooseHeadFiles.bind(this, function() {
+                if (--readyCount === 0) {
+                  return done()
+                }
+              }, path.join(parent, files[ix])));
             }
-          })
-        })(i)
-      }
+          } 
+        });
+
+
+      })(i)
     }
-    
-    function parsePackedRefFile() {
-      var packedRefPath = path.join(that.gitDir, "/packed-refs")
-      fs.readFile(packedRefPath, function(err, contents) {
-        if (err) {
-          if (err.code == "ENOENT") {
-            return cb(null, result)
-          } else {
-            return cb(err)
-          }
+  }
+
+  function parsePackedRefFile() {
+    var packedRefPath = path.join(that.gitDir, "/packed-refs")
+    fs.readFile(packedRefPath, function(err, contents) {
+      if (err) {
+        if (err.code == "ENOENT") {
+          return cb(null, result)
+        } else {
+          return cb(err)
         }
-        var lines = contents.toString("ascii").split("\n")
-        for(var i = 0; i < lines.length; i++) {
-          var line = lines[i]
-          if (line.match(/^\s*#/) || line.match(/^\s*$/)) {
-          } else {
-            var bits = lines[i].split(" ")
-            var sha = bits[0]
-            var refPath = bits[1]
-            var nameMatch = refPath.match(/^refs\/heads\/(.*)$/)
-            if (nameMatch) {
-              result.branchNames.push(nameMatch[1])
-              result[nameMatch[1]] = sha
-            }
+      }
+      var lines = contents.toString("ascii").split("\n")
+      for(var i = 0; i < lines.length; i++) {
+        var line = lines[i]
+        if (line.match(/^\s*#/) || line.match(/^\s*$/)) {
+        } else {
+          var bits = lines[i].split(" ")
+          var sha = bits[0]
+          var refPath = bits[1]
+          var nameMatch = refPath.match(/^refs\/heads\/(.*)$/)
+          if (nameMatch) {
+            result.branchNames.push(nameMatch[1])
+            result[nameMatch[1]] = sha
           }
         }
-        return cb(null, result)
-      })
-    }
-  }
-  
-  // Get the current head. Callback receives (err, data)
-  that.getHead = function(cb) {
-    var headFile = path.join(that.gitDir, "/HEAD")
-    fs.readFile(headFile, function(err, contents) {
-      if (err) return cb(err)
-      
-      var head = contents.toString("ascii")
-      var match = /ref: refs\/heads\/(.*)\n$/.exec(head)
-      if (match) {
-        cb(null, match[1])
-      } else {
-        cb(null, null)
       }
+      return cb(null, result)
     })
   }
-  
-  return that
 }
 
+// Get the current head. Callback receives (err, data)
+Repo.prototype.getHead = function(cb) {
+  var that = this
+  var headFile = path.join(that.gitDir, "/HEAD")
+  fs.readFile(headFile, function(err, contents) {
+    if (err) return cb(err)
 
+    var head = contents.toString("ascii")
+    var match = /ref: refs\/heads\/(.*)\n$/.exec(head)
+    if (match) {
+      cb(null, match[1])
+    } else {
+      cb(null, null)
+    }
+  })
+}
 
+module.exports = exports = Repo
diff --git a/lib/git/smart_http_remote.js b/lib/git/smart_http_remote.js
index b92fd01..e4d6a6a 100644
--- a/lib/git/smart_http_remote.js
+++ b/lib/git/smart_http_remote.js
@@ -1,6 +1,9 @@
+var Remote = require('./remote')
+  , UploadPackParser = require('./upload_pack_parser')
+  , utils = require('./utils')
 
-Git.SmartHttpRemote = function(repo, name, repoUrl) {
-  Git.Remote.apply(this, [repo, name, repoUrl])
+var SmartHttpRemote = function(repo, name, repoUrl) {
+  Remote.call(this, repo, name, repoUrl)
   
   this.fetchRefs = function(callback) {
     var remote = this
@@ -8,7 +11,7 @@ Git.SmartHttpRemote = function(repo, name, repoUrl) {
       this.makeUri('/info/refs', {service: "git-upload-pack"}),
       "",
       function(data) {
-        var discInfo = Git.SmartHttpRemote.parseDiscovery(data)
+        var discInfo = SmartHttpRemote.parseDiscovery(data)
         var i, ref
         for (i = 0; i < discInfo.refs.length; i++) {
           ref = discInfo.refs[i]
@@ -23,7 +26,7 @@ Git.SmartHttpRemote = function(repo, name, repoUrl) {
   
   this.fetchRef = function(wantRef, callback) {
     var url = this.makeUri('/git-upload-pack')
-    var body = Git.SmartHttpRemote.refWantRequest(wantRef, repo.haveRefs(repo.getAllRefs()))
+    var body = SmartHttpRemote.refWantRequest(wantRef, repo.haveRefs(repo.getAllRefs()))
     var thisRemote = this
     $.ajax({
       url: url,
@@ -35,11 +38,11 @@ Git.SmartHttpRemote = function(repo, name, repoUrl) {
       },
       success: function(data, textStatus, xhr) {
         var binaryData = xhr.responseText
-        var parser = new Git.UploadPackParser(binaryData)
+        var parser = new UploadPackParser(binaryData)
         parser.parse()
         var objectDatas = parser.getObjects()
         if (!objectDatas) {
-          throw("Upload pack contained no objects! Data is: " + Git.stringToBytes(binaryData).toString())
+          throw("Upload pack contained no objects! Data is: " + utils.stringToBytes(binaryData).toString())
         }
         var i, object
         var newObjects = []
@@ -53,18 +56,21 @@ Git.SmartHttpRemote = function(repo, name, repoUrl) {
         }
       },
       error: function(xhr, data, e) {
-        Git.displayError("ERROR Status: " + xhr.status + ", response: " + xhr.responseText)
+        utils.displayError("ERROR Status: " + xhr.status + ", response: " + xhr.responseText)
       }
     });
   }
   
 }
 
+SmartHttpRemote = new Remote('','','')
+
+
 // Parses the response to /info/refs?service=git-upload-pack, which contains ids for
 // refs/heads and a capability listing for this git HTTP server.
 //
 // Returns {capabilities:"...", refs: [{name:"...", sha:"..."}, ...]}
-Git.SmartHttpRemote.parseDiscovery = function(data) {
+SmartHttpRemote.parseDiscovery = function(data) {
   var lines = data.split("\n")
   var result = {"refs":[]}
   for ( i = 1; i < lines.length - 1; i++) {
@@ -87,7 +93,7 @@ Git.SmartHttpRemote.parseDiscovery = function(data) {
 // we want and a bunch of refs we have.
 //
 // Returns a String
-Git.SmartHttpRemote.refWantRequest = function(wantRef, haveRefs) {
+SmartHttpRemote.refWantRequest = function(wantRef, haveRefs) {
   var str = "0067want " + wantRef.sha + " multi_ack_detailed side-band-64k thin-pack ofs-delta\n0000"
   _(haveRefs).each(function(haveRef) {
     str += "0032have " + haveRef.sha + "\n"
@@ -96,11 +102,4 @@ Git.SmartHttpRemote.refWantRequest = function(wantRef, haveRefs) {
   return str
 }
 
-
-
-
-
-
-
-
-
+module.exports = exports = SmartHttpRemote
diff --git a/lib/git/tree-diff.js b/lib/git/tree-diff.js
index e259e33..c91ebaa 100644
--- a/lib/git/tree-diff.js
+++ b/lib/git/tree-diff.js
@@ -1,205 +1,209 @@
+var FileDiff = require('./file-diff')
+  , _ = require('underscore')
 
-Git.TreeDiff = function(repo, prevTreeSha, thisTreeSha, path) {
-  var that = this
-  that.repo        = repo
-  that.thisTreeSha = thisTreeSha
-  that.prevTreeSha = prevTreeSha
-  that.path        = path || ""
-  that.waitingFor  = 0
-  
-  var changesToHtml = function(changes) {        
-    var str = []
-    str.push("<table class='commit-summary'>")
-    _(changes).each(function(change) {
-      str.push("<tr>")
-      if (change.type == "new") {
-        str.push("<td class='modification new'>new</td><td>" + change.name + "</td>")
-      } else if (change.type == "changed") {
-        str.push("<td class='modification changed'>changed</td><td>" + change.name + "</td>")
-      } else if (change.type == "removed") {
-        str.push("<td class='modification removed'>removed</td><td>" + change.name + "</td>")
-      }
-      str.push("</tr>")
+var changesToHtml = function(changes) {
+  var str = []
+  str.push("<table class='commit-summary'>")
+  _(changes).each(function(change) {
+    str.push("<tr>")
+    if (change.type == "new") {
+      str.push("<td class='modification new'>new</td><td>" + change.name + "</td>")
+    } else if (change.type == "changed") {
+      str.push("<td class='modification changed'>changed</td><td>" + change.name + "</td>")
+    } else if (change.type == "removed") {
+      str.push("<td class='modification removed'>removed</td><td>" + change.name + "</td>")
+    }
+    str.push("</tr>")
+  })
+  str.push("</table>")
+  str.push("<hr>")
+
+  _(changes).each(function(change) {
+    str.push("<div class='changed-file'>")
+    str.push("  <div class='filename'><b>" + change.name + "</b></div>")
+    var diff = new FileDiff(change.blob[0], change.blob[1])
+    str.push(diff.toHtml())
+    str.push("</div>")
+  })
+  return str.join("\n")
+}
+
+var changesToStat = function(changes) {
+  var str = []
+  var result = {insertions: 0, deletions: 0}
+  _(changes).each(function(change) {
+    var diff = new FileDiff(change.blob[0], change.blob[1])
+    var stat = diff.stat()
+    result.insertions += stat.insertions
+    result.deletions  += stat.deletions
+    var changeStr = []
+    changeStr.push(" " + change.name + " |    " + (stat.insertions + stat.deletions) + " ")
+    for(var i = 0; i < stat.insertions; i++) changeStr.push("+")
+    for(var i = 0; i < stat.deletions; i++)  changeStr.push("-")
+    str.push(changeStr.join(""))
+  })
+  str.push(" " + changes.length + " files changed, " +
+    result.insertions + " insertions(+), " +
+    result.deletions  + " deletions(-)")
+
+  return str.join("\n")
+}
+
+var TreeDiff = function(repo, prevTreeSha, thisTreeSha, path) {
+  this.repo        = repo
+  this.thisTreeSha = thisTreeSha
+  this.prevTreeSha = prevTreeSha
+  this.path        = path || ""
+  this.waitingFor  = 0
+
+  this.finished = false
+  this.doneAll = false
+  this.changes = null
+}
+
+TreeDiff.prototype.incWaiting = function() {
+  this.waitingFor += 1
+}
+
+TreeDiff.prototype.decWaiting = function() {
+  this.waitingFor -= 1
+  this.finishIfDone()
+}
+
+TreeDiff.prototype.finishIfDone = function() {
+  if (this.waitingFor == 0 && !this.finished && this.doneAll) {
+    this.finished = true
+    this.callback(this.changes)
+  }
+}
+
+TreeDiff.prototype.compareBlobEntry = function(prevBlobEntry, thisBlobEntry) {
+  var generator = this
+  if(!prevBlobEntry) {
+    var name = this.path + thisBlobEntry.name
+    generator.incWaiting()
+    this.repo.getObject(thisBlobEntry.sha, function(err, thisBlob) {
+      generator.changes.push({type:"new", blob: ["", thisBlob.data], name: name})
+      generator.decWaiting()
     })
-    str.push("</table>")
-    str.push("<hr>")
-    
-    _(changes).each(function(change) {
-      str.push("<div class='changed-file'>")
-      str.push("  <div class='filename'><b>" + change.name + "</b></div>")
-      var diff = new Git.FileDiff(change.blob[0], change.blob[1])
-      str.push(diff.toHtml())
-      str.push("</div>")
+  } else if (!thisBlobEntry) {
+    var name = this.path + prevBlobEntry.name
+    generator.incWaiting()
+    this.repo.getObject(prevBlobEntry.sha, function(err, prevBlob) {
+      generator.changes.push({type:"removed", blob: [prevBlob.data, ""], name: name})
+      generator.decWaiting()
     })
-    return str.join("\n")
-  }
-  
-  var changesToStat = function(changes) {        
-    var str = []
-    var result = {insertions: 0, deletions: 0}
-    _(changes).each(function(change) {
-      var diff = new Git.FileDiff(change.blob[0], change.blob[1])
-      var stat = diff.stat()
-      result.insertions += stat.insertions
-      result.deletions  += stat.deletions
-      var changeStr = []
-      changeStr.push(" " + change.name + " |    " + (stat.insertions + stat.deletions) + " ")
-      for(var i = 0; i < stat.insertions; i++) changeStr.push("+")
-      for(var i = 0; i < stat.deletions; i++)  changeStr.push("-")
-      str.push(changeStr.join(""))
+  } else if (prevBlobEntry.sha != thisBlobEntry.sha) {
+    var name = this.path + thisBlobEntry.name
+    var generator = this
+    generator.incWaiting()
+    this.repo.getObject(prevBlobEntry.sha, function(err, prevBlob) {
+      this.repo.getObject(thisBlobEntry.sha, function(err, thisBlob) {
+        generator.changes.push({type:"changed", blob: [prevBlob.data, thisBlob.data], name: name})
+        generator.decWaiting()
+      })
     })
-    str.push(" " + changes.length + " files changed, " + 
-      result.insertions + " insertions(+), " + 
-      result.deletions  + " deletions(-)")
-    
-    return str.join("\n")
-  }
-  
-  that.incWaiting = function() {
-    that.waitingFor += 1
   }
-  
-  that.decWaiting = function() {
-    that.waitingFor -= 1
-    that.finishIfDone()
-  }
-  
-  that.finishIfDone = function() {
-    if (that.waitingFor == 0 && !that.finished && that.doneAll) {
-      that.finished = true
-      that.callback(that.changes)
-    }
+}
+
+TreeDiff.prototype.compareTreeEntry = function(prevTreeEntry, thisTreeEntry) {
+  var generator = this
+  if (!prevTreeEntry) {
+    generator.incWaiting()
+    var subTreeDiff = new TreeDiff(this.repo, null, thisTreeEntry.sha)
+    subTreeDiff.generateChanges(function(subChanges) {
+      generator.changes = generator.changes.concat(subChanges)
+      generator.decWaiting()
+    }, generator.path + thisTreeEntry.name + "/")
+  } else if (!thisTreeEntry) {
+    generator.incWaiting()
+    var subTreeDiff = new TreeDiff(this.repo, prevTreeEntry.sha, null)
+    subTreeDiff.generateChanges(function(subChanges) {
+      generator.changes = generator.changes.concat(subChanges)
+      generator.decWaiting()
+    }, generator.path + prevTreeEntry.name + "/")
+  } else if (prevTreeEntry.sha != thisTreeEntry.sha) {
+    generator.incWaiting()
+    var subTreeDiff = new TreeDiff(this.repo, prevTreeEntry.sha, thisTreeEntry.sha)
+    subTreeDiff.generateChanges(function(subChanges) {
+      generator.changes = generator.changes.concat(subChanges)
+      generator.decWaiting()
+    }, generator.path + thisTreeEntry.name + "/")
   }
-  
-  that.finished = false
-  that.doneAll = false
-  that.changes = null
-  
-  that.compareBlobEntry = function(prevBlobEntry, thisBlobEntry) {
-    var generator = that
-    if(!prevBlobEntry) {
-      var name = that.path + thisBlobEntry.name
-      generator.incWaiting()
-      repo.getObject(thisBlobEntry.sha, function(err, thisBlob) {
-        generator.changes.push({type:"new", blob: ["", thisBlob.data], name: name})
-        generator.decWaiting()
-      })
-    } else if (!thisBlobEntry) {
-      var name = that.path + prevBlobEntry.name
-      generator.incWaiting()
-      repo.getObject(prevBlobEntry.sha, function(err, prevBlob) {
-        generator.changes.push({type:"removed", blob: [prevBlob.data, ""], name: name})
-        generator.decWaiting()
-      })
-    } else if (prevBlobEntry.sha != thisBlobEntry.sha) {
-      var name = that.path + thisBlobEntry.name
-      var generator = that
-      generator.incWaiting()
-      repo.getObject(prevBlobEntry.sha, function(err, prevBlob) {
-        repo.getObject(thisBlobEntry.sha, function(err, thisBlob) {
-          generator.changes.push({type:"changed", blob: [prevBlob.data, thisBlob.data], name: name})
-          generator.decWaiting()
-        })
-      })
-    }
+}
+
+TreeDiff.prototype.compareTrees = function() {
+  var generator = this
+  var prevTreeHash = null
+  var thisTreeHash = null
+  if (this.prevTree && this.prevTree.asHash) {
+    prevTreeHash = this.prevTree.asHash()
+  } else {
+    prevTreeHash = {}
   }
-  
-  that.compareTreeEntry = function(prevTreeEntry, thisTreeEntry) {
-    var generator = that
-    if (!prevTreeEntry) {
-      generator.incWaiting()
-      var subTreeDiff = new Git.TreeDiff(repo, null, thisTreeEntry.sha)
-      subTreeDiff.generateChanges(function(subChanges) {
-        generator.changes = generator.changes.concat(subChanges)
-        generator.decWaiting()
-      }, generator.path + thisTreeEntry.name + "/")
-    } else if (!thisTreeEntry) {
-      generator.incWaiting()
-      var subTreeDiff = new Git.TreeDiff(repo, prevTreeEntry.sha, null)
-      subTreeDiff.generateChanges(function(subChanges) {
-        generator.changes = generator.changes.concat(subChanges)
-        generator.decWaiting()
-      }, generator.path + prevTreeEntry.name + "/")
-    } else if (prevTreeEntry.sha != thisTreeEntry.sha) {
-      generator.incWaiting()
-      var subTreeDiff = new Git.TreeDiff(repo, prevTreeEntry.sha, thisTreeEntry.sha)
-      subTreeDiff.generateChanges(function(subChanges) {
-        generator.changes = generator.changes.concat(subChanges)
-        generator.decWaiting()
-      }, generator.path + thisTreeEntry.name + "/")
-    }
+  if (this.thisTree) {
+    thisTreeHash = this.thisTree.asHash()
+  } else {
+    thisTreeHash = {}
   }
-  
-  that.compareTrees = function() {
-    var generator = that
-    var prevTreeHash = null
-    var thisTreeHash = null
-    if (that.prevTree) {
-      prevTreeHash = that.prevTree.asHash()
-    } else {
-      prevTreeHash = {}
-    }
-    if (that.thisTree) {
-      thisTreeHash = that.thisTree.asHash()
+  var names = _(_(thisTreeHash).keys().concat(_(prevTreeHash).keys())).uniq()
+  _(names).each(function(name) {
+    var prevEntry = prevTreeHash[name]
+    var thisEntry = thisTreeHash[name]
+    var prevType = (prevEntry ? prevEntry.type : null)
+    var thisType = (thisEntry ? thisEntry.type : null)
+    if (prevType == thisType || prevType == null || thisType == null) {
+      var type = prevType || thisType
+      if (type == "blob") {
+        generator.compareBlobEntry(prevEntry, thisEntry)
+      } else if (type == "tree") {
+        generator.compareTreeEntry(prevEntry, thisEntry)
+      }
     } else {
-      thisTreeHash = {}
-    }
-    var names = _(_(thisTreeHash).keys().concat(_(prevTreeHash).keys())).uniq()
-    _(names).each(function(name) {
-      var prevEntry = prevTreeHash[name]
-      var thisEntry = thisTreeHash[name]
-      var prevType = (prevEntry ? prevEntry.type : null)
-      var thisType = (thisEntry ? thisEntry.type : null)
-      if (prevType == thisType || prevType == null || thisType == null) {
-        var type = prevType || thisType
-        if (type == "blob") {
-          generator.compareBlobEntry(prevEntry, thisEntry)
-        } else if (type == "tree") {
-          generator.compareTreeEntry(prevEntry, thisEntry)
-        }
-      } else {
-        // entry changed from a dir to a file or vice versa
-        if (prevType == "blob" && thisType == "tree") {
-          generator.compareBlobEntry(prevEntry, null)
-          generator.compareTreeEntry(null, thisEntry)
-        }
+      // entry changed from a dir to a file or vice versa
+      if (prevType == "blob" && thisType == "tree") {
+        generator.compareBlobEntry(prevEntry, null)
+        generator.compareTreeEntry(null, thisEntry)
       }
-    })
-    that.doneAll = true
-    generator.finishIfDone()
-  }
-  
-  that.toHtml = function(callback) {
-    that.generateChanges(function(changes) {
-      callback(changesToHtml(changes))
-    })
-  }
-  
-  that.toStat = function(callback) {
-    that.generateChanges(function(changes) {
-      callback(null, changesToStat(changes))
-    })
-  }
-  
-  that.generateChanges = function(callback) {
-    if (that.changes === null) {
-      that.callback = callback
-      that.changes = []
-      repo.getObject(that.prevTreeSha, function(err, prevTree) {
+    }
+  })
+  this.doneAll = true
+  generator.finishIfDone()
+}
+
+TreeDiff.prototype.toHtml = function(callback) {
+  this.generateChanges(function(changes) {
+    callback(changesToHtml(changes))
+  })
+}
+
+TreeDiff.prototype.toStat = function(callback) {
+  this.generateChanges(function(changes) {
+    callback(null, changesToStat(changes))
+  })
+}
+
+TreeDiff.prototype.generateChanges = function(callback) {
+  if (this.changes === null) {
+    this.callback = callback
+    this.changes = []
+    var self = this
+    self.repo.getObject(this.prevTreeSha, function(err, prevTree) {
+      if (err) return callback(err)
+
+      self.prevTree = prevTree
+
+      self.repo.getObject(self.selfTreeSha, function(err, selfTree) {
         if (err) return callback(err)
-        
-        that.prevTree = prevTree
-        
-        repo.getObject(that.thisTreeSha, function(err, thisTree) {
-          if (err) return callback(err)
-        
-          that.thisTree = thisTree
-          return that.compareTrees()
-        })
+
+        self.selfTree = selfTree
+        return self.compareTrees()
       })
-    }
-    else {
-      return callback(that.changes)
-    }
+    })
+  }
+  else {
+    return callback(this.changes)
   }
 }
+
+module.exports = TreeDiff
diff --git a/lib/git/upload_pack_parser.js b/lib/git/upload_pack_parser.js
index 557bdb6..f680337 100644
--- a/lib/git/upload_pack_parser.js
+++ b/lib/git/upload_pack_parser.js
@@ -1,11 +1,14 @@
+var BinaryFile = require('../binary_file')
+  , utils = require('./utils')
+  , Pack = require('./pack')
 
 // A parser for the response to /git-upload-pack, which contains some
 // progress information and a pack file. Delegates parsing the packfile to 
 // the packFileParser.
 // 
 // Has methods parse, getRemoteLines and getObjects.
-Git.UploadPackParser = function(binary) {
-  var binaryString = Git.toBinaryString(binary)
+var UploadPackParser = function(binary) {
+  var binaryString = utils.toBinaryString(binary)
   var data   = new BinaryFile(binaryString);
   var offset = 0;
   var remoteLines = null;
@@ -23,7 +26,7 @@ Git.UploadPackParser = function(binary) {
   var nextPktLine = function() {
     var pktLine = null;
     var length;
-    length = parseInt(Git.bytesToString(peek(4)), 16);
+    length = parseInt(utils.bytesToString(peek(4)), 16);
     advance(4);
     if (length == 0) {
     //   return nextPktLine()
@@ -51,11 +54,11 @@ Git.UploadPackParser = function(binary) {
     var packData = ""
     var gotAckOrNak = false
     
-    while (Git.bytesToString(pktLine).slice(0, 7) === "shallow") {
+    while (utils.bytesToString(pktLine).slice(0, 7) === "shallow") {
       pktLine = nextPktLine()
     }
-    while (Git.bytesToString(pktLine) === "NAK\n" || 
-            Git.bytesToString(pktLine).slice(0, 3) === "ACK") {
+    while (utils.bytesToString(pktLine) === "NAK\n" || 
+            utils.bytesToString(pktLine).slice(0, 3) === "ACK") {
       pktLine = nextPktLine()
       gotAckOrNak = true
     }
@@ -67,12 +70,12 @@ Git.UploadPackParser = function(binary) {
     while (pktLine !== null) {
       // sideband format. "2" indicates progress messages, "1" pack data
       if (pktLine[0] == 2) {
-        var lineString = Git.bytesToString(pktLine)
+        var lineString = utils.bytesToString(pktLine)
         lineString = lineString.slice(1, lineString.length)
         remoteLine += lineString
       }
       else if (pktLine[0] == 1) {
-        packData += Git.bytesToString(pktLine.slice(1))
+        packData += utils.bytesToString(pktLine.slice(1))
       }
       else if (pktLine[0] == 3) {
         throw(Error("fatal error in packet line"))
@@ -80,7 +83,7 @@ Git.UploadPackParser = function(binary) {
       pktLine = nextPktLine()
     }
     
-    packFileParser = new Git.Pack(packData)
+    packFileParser = new Pack(packData)
     packFileParser.parseAll()
     objects = packFileParser.getObjects()
           
@@ -97,3 +100,4 @@ Git.UploadPackParser = function(binary) {
   };
 }
 
+module.exports = exports = UploadPackParser
diff --git a/lib/git/utils.js b/lib/git/utils.js
new file mode 100644
index 0000000..3615d50
--- /dev/null
+++ b/lib/git/utils.js
@@ -0,0 +1,52 @@
+var utils = {}
+
+utils.OBJECT_TYPES  = ["tag", "commit", "tree", "blob"]
+utils.REMOTE_TYPE   = 'HttpRemote'
+
+utils.handleError = typeof console !== 'undefined' ?
+    function() { console.log.apply(console, arguments) } :
+    function() { (this._logs || []).push([].slice.call(arguments)) }
+
+// Turn an array of bytes into a String
+utils.bytesToString = function(bytes) {
+    var result = [];
+    var i;
+    for (i = 0; i < bytes.length; i++) {
+      result.push(String.fromCharCode(bytes[i]));
+    }
+    return result.join('');
+};
+
+utils.stringToBytes = function(string) {
+    var bytes = []; 
+    var i; 
+    for(i = 0; i < string.length; i++) {
+      bytes.push(string.charCodeAt(i) & 0xff);
+    }
+    return bytes;
+};
+
+utils.toBinaryString = function(binary) {
+  return (binary instanceof Array) ?
+          this.bytesToString(binary) :
+          binary
+};
+
+utils.nextPktLine = function(data) {
+  var len = parseInt(data.slice(0, 4), 16);
+  return data.slice(4, len);
+};
+ 
+utils.stripZlibHeader = function(zlib) {
+  return zlib.slice(2);
+}
+ 
+utils.escapeHTML = function(str) {
+    return str.replace(/\&/g, '&amp;')
+              .replace(/</g, '&lt;')
+              .replace(/>/g, '&gt;')
+              .replace(/"/g, '&quot;')
+               replace(/'/g, '&#39;');
+};
+
+module.exports = exports = utils
diff --git a/test/delta_test.js b/test/delta_test.js
index 28fef59..c7a58b8 100644
--- a/test/delta_test.js
+++ b/test/delta_test.js
@@ -1,4 +1,4 @@
-require('../lib/git-server')
+var applyDelta = require('../lib/git/delta')
 
 DeltaTestData = {
   withCopyHunk: {
@@ -16,7 +16,7 @@ DeltaTestData = {
 exports['Apply Delta'] = {
   "Delta with copy hunk": function(test) {
     test.equals(
-      Git.applyDelta(DeltaTestData.withCopyHunk.baseData, DeltaTestData.withCopyHunk.delta),
+      applyDelta(DeltaTestData.withCopyHunk.baseData, DeltaTestData.withCopyHunk.delta),
       DeltaTestData.withCopyHunk.expectedResult
     )
     test.done()
@@ -24,8 +24,8 @@ exports['Apply Delta'] = {
   
   "Delta with many hunks": function(test) {
     test.equals(
-        Git.applyDelta(DeltaTestData.withManyHunks.baseData, DeltaTestData.withManyHunks.delta),
+        applyDelta(DeltaTestData.withManyHunks.baseData, DeltaTestData.withManyHunks.delta),
         DeltaTestData.withManyHunks.expectedResult)
     test.done()
   }
-}
\ No newline at end of file
+}
diff --git a/test/diff_test.js b/test/diff_test.js
index 59a40f1..6264e0f 100644
--- a/test/diff_test.js
+++ b/test/diff_test.js
@@ -1,11 +1,10 @@
-
-require('../lib/git-server')
+var FileDiff = require('../lib/git/file-diff')
 
 exports.NullEndpoints = {
   "null start": function(test) {
     var file1 = ""
     var file2 = ["a", "b", "c"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -19,7 +18,7 @@ exports.NullEndpoints = {
   "null end": function(test) {
     var file1 = ["a", "b", "c"].join("\n")
     var file2 = ""
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -36,7 +35,7 @@ exports.SingleHunk = {
   "additions at end": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "c", "d", "e", "f", "g", "h"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 7, 
@@ -53,7 +52,7 @@ exports.SingleHunk = {
   "additions at beginning": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["0", "1", "a", "b", "c", "d", "e", "f"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -70,7 +69,7 @@ exports.SingleHunk = {
   "additions in middle": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "c", "0", "1", "d", "e", "f"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 4, 
@@ -90,7 +89,7 @@ exports.SingleHunk = {
   "removals at end": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "c", "d"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 5, 
@@ -107,7 +106,7 @@ exports.SingleHunk = {
   "removals at beginning": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["c", "d", "e", "f"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 1, 
@@ -124,7 +123,7 @@ exports.SingleHunk = {
   "removals in middle": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "e", "f"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -142,7 +141,7 @@ exports.SingleHunk = {
   "added and removed in middle of same length": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "0", "1", "e", "f"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -162,7 +161,7 @@ exports.SingleHunk = {
   "more added than removed": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "0", "1", "2", "3", "e", "f"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -184,7 +183,7 @@ exports.SingleHunk = {
   "more removed than added": function(test) {
     var file1 = ["a", "b", "c", "d", "e", "f"].join("\n")
     var file2 = ["a", "b", "0", "1", "f"].join("\n")
-    var diff = new Git.FileDiff(file1, file2)
+    var diff = new FileDiff(file1, file2)
     test.deepEqual(
       diff.info, 
       [{offset: 3, 
@@ -206,7 +205,7 @@ exports.MultipleSeparateHunks = {
   "added then added": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy4567zq89".split("").join("\n")
-    var diff = new Git.FileDiff(file1, file2, {context: 1})
+    var diff = new FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 4, 
@@ -231,7 +230,7 @@ exports.MultipleSeparateHunks = {
   "removed then removed": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "1345689".split("").join("\n")
-    var diff = new Git.FileDiff(file1, file2, {context: 1})
+    var diff = new FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 2, 
@@ -254,7 +253,7 @@ exports.MultipleSeparateHunks = {
   "added then removed": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy45689".split("").join("\n")
-    var diff = new Git.FileDiff(file1, file2, {context: 1})
+    var diff = new FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 4, 
@@ -278,7 +277,7 @@ exports.MultipleSeparateHunks = {
   "removed then added": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "134567xq89".split("").join("\n")
-    var diff = new Git.FileDiff(file1, file2, {context: 1})
+    var diff = new FileDiff(file1, file2, {context: 1})
     test.deepEqual(
       diff.info[0], 
       {offset: 2, 
@@ -304,7 +303,7 @@ exports.MultipleConnectedHunks = {
   "overlap by 1": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy4zq56789".split("").join("\n")
-    var diff = new Git.FileDiff(file1, file2, {context: 1})
+    var diff = new FileDiff(file1, file2, {context: 1})
     test.equal(diff.info.length, 1)
     test.deepEqual(
       diff.info[0], 
@@ -324,7 +323,7 @@ exports.MultipleConnectedHunks = {
   "overlap by 2": function(test) {
     var file1 = "123456789".split("").join("\n")
     var file2 = "123xy4zq56789".split("").join("\n")
-    var diff = new Git.FileDiff(file1, file2, {context: 2})
+    var diff = new FileDiff(file1, file2, {context: 2})
     test.equal(diff.info.length, 1)
     test.deepEqual(
       diff.info[0], 
diff --git a/test/http_remote_test.js b/test/http_remote_test.js
index 1b94cb9..41d3ee1 100644
--- a/test/http_remote_test.js
+++ b/test/http_remote_test.js
@@ -1,4 +1,5 @@
-require('../lib/git-server')
+var HttpRemote = require('../lib/git/http_remote')
+  , utils = require('../lib/git/utils')
 
 var REMOTE_TEST_DATA = {
   infoRefs: {
@@ -28,14 +29,14 @@ var REMOTE_TEST_DATA = {
 exports.HttpRemote = {
   testParseDumbInfoRefs: function(test) {
     test.deepEqual(
-      Git.HttpRemote.parseInfoRefs(REMOTE_TEST_DATA.infoRefs.data),
+      HttpRemote.parseInfoRefs(REMOTE_TEST_DATA.infoRefs.data),
       REMOTE_TEST_DATA.infoRefs.result
     )
     test.done()
   },
 
   testParseObjectData: function(test) {
-    var commit = Git.HttpRemote.parseObjectData("123", Git.bytesToString(REMOTE_TEST_DATA.commitObjectData.data))
+    var commit = HttpRemote.parseObjectData("123", utils.bytesToString(REMOTE_TEST_DATA.commitObjectData.data))
     test.equals(commit.type, "commit")
     test.equals(commit.sha, "123")
     test.equals(commit.tree, "c6b93605bd1e2171b3094f70cf61133b8f749bda")
@@ -48,10 +49,10 @@ exports.HttpRemote = {
   
   testParsePackList: function(test) {
     test.deepEqual(
-      Git.HttpRemote.parsePackList(REMOTE_TEST_DATA.packList.data),
+      HttpRemote.parsePackList(REMOTE_TEST_DATA.packList.data),
       REMOTE_TEST_DATA.packList.result
     )
     test.done()
   }
 }
-  
\ No newline at end of file
+  
diff --git a/test/index.js b/test/index.js
index 3f772b6..dc4e353 100644
--- a/test/index.js
+++ b/test/index.js
@@ -4,11 +4,13 @@ var merge = function(what) {
     exp[key] = what[key]
   })
 }
+
 merge(require('./delta_test'))
 merge(require('./diff_test'))
+merge(require('./memory_repo_test'))
+
 merge(require('./http_remote_test'))
 merge(require('./jsgit_test'))
-merge(require('./memory_repo_test'))
 merge(require('./object_test'))
 merge(require('./pack_file_test'))
 merge(require('./pack_index_test'))
@@ -38,12 +40,12 @@ var finish = function() {
       , err   = error[1];
 
     if(last !== name) {
-      console.error(' in '+name+':');
+      console.error('\n\n in '+name+':\n--------------------------------');
       last = name;
     }
 
     var stack = trace(err);
-    process.stderr.write('\t'+err+'\n');
+    process.stderr.write(err+'\n');
     stack.frames.forEach(function(frame) {
       if(frame) {
         process.stderr.write(frame.filename.replace(process.cwd(), '.')+' on line '+frame.line+' \n')
diff --git a/test/jsgit_test.js b/test/jsgit_test.js
index e7fad10..05e63de 100644
--- a/test/jsgit_test.js
+++ b/test/jsgit_test.js
@@ -1,7 +1,8 @@
 
 require('../lib/git-server')
-
-var myDebug = require('util').debug
+var UploadPackParser = require('../lib/git/upload_pack_parser')
+  , utils = require('../lib/git/utils')
+  , Pack = require('../lib/git/pack')
 
 GitTestData = {
   pack: [80, 65, 67, 75, 0, 0, 0, 2, 0, 0, 0, 5, 145, 12, 120, 156, 157, 204, 77, 10, 194, 48, 16, 64, 225, 125, 78, 49, 123, 65, 218, 252, 52, 9, 136, 40, 184, 244, 18, 99, 102, 130, 129, 164, 45, 233, 228, 254, 246, 12, 190, 229, 183, 120, 210, 153, 33, 89, 27, 173, 198, 232, 34, 6, 173, 209, 160, 15, 142, 201, 39, 139, 139, 11, 244, 137, 75, 156, 136, 102, 239, 20, 14, 249, 110, 29, 94, 184, 22, 174, 240, 30, 169, 99, 22, 184, 17, 174, 143, 92, 7, 175, 210, 145, 74, 194, 122, 77, 91, 187, 195, 172, 163, 177, 206, 122, 103, 224, 50, 157, 169, 83, 91, 17, 225, 255, 15, 234, 73, 4, 7, 182, 189, 50, 228, 82, 249, 80, 63, 157, 99, 59, 198, 160, 4, 120, 156, 51, 52, 48, 48, 51, 49, 81, 8, 114, 117, 116, 241, 117, 101, 248, 171, 37, 219, 177, 129, 183, 133, 241, 192, 132, 250, 195, 143, 46, 63, 138, 103, 220, 29, 244, 220, 196, 0, 8, 20, 114, 50, 147, 24, 214, 5, 138, 78, 123, 220, 119, 173, 244, 54, 27, 243, 66, 19, 63, 191, 87, 250, 146, 110, 38, 0, 237, 58, 24, 59, 181, 4, 120, 156, 11, 73, 45, 46, 81, 8, 74, 45, 200, 55, 228, 178, 133, 3, 46, 46, 175, 82, 160, 112, 162, 66, 9, 72, 182, 8, 40, 171, 144, 150, 95, 164, 80, 156, 159, 155, 90, 146, 145, 153, 151, 174, 224, 169, 158, 171, 80, 158, 95, 148, 13, 98, 231, 231, 113, 1, 0, 239, 156, 22, 95, 162, 2, 120, 156, 51, 52, 48, 48, 51, 49, 81, 72, 203, 207, 215, 203, 42, 102, 120, 186, 106, 253, 246, 114, 209, 200, 155, 183, 117, 111, 200, 7, 197, 60, 55, 232, 46, 47, 20, 0, 0, 214, 161, 13, 153, 190, 1, 120, 156, 211, 215, 87, 112, 204, 83, 72, 173, 72, 204, 45, 200, 73, 85, 240, 74, 44, 75, 12, 78, 46, 202, 44, 40, 81, 72, 203, 204, 73, 229, 2, 0, 150, 63, 10, 27, 112, 162, 38, 201, 64, 200, 237, 148, 228, 62, 53, 100, 240, 52, 119, 16, 115, 91, 161, 48, 48, 48, 54, 1, 154, 48, 48, 48, 48],
@@ -13,8 +14,7 @@ GitTestData = {
 
 exports['PackFileParser'] = {
   "master pack": function(test) {
-    myDebug("master pack")
-    test.deepEqual(new Git.Pack(GitTestData.pack).parseAll().getObjects(),
+    test.deepEqual(new Pack(GitTestData.pack).parseAll().getObjects(),
     [ { sha: 'b3453be87b70a0c5dea28aacd49cf34ddb91a8c5'
       , type: "commit"
       , data: 'tree c44942a959a822a3a785ed7c4a658db9690dd175\nauthor Daniel Lucraft <dan@fluentradical.com> 1293454753 +0000\ncommitter Daniel Lucraft <dan@fluentradical.com> 1293454753 +0000\n\nAdd sample files\n'
@@ -36,12 +36,10 @@ exports['PackFileParser'] = {
       , data: '// An example JavaScript file\n'
     }
     ])
-    myDebug("master pack: done")
     test.done()
   },
   "branch1 pack": function(test) {
-    myDebug("branch1 pack")
-    test.deepEqual(new Git.Pack(GitTestData.packBranch1).parseAll().getObjects(), 
+    test.deepEqual(new Pack(GitTestData.packBranch1).parseAll().getObjects(), 
       [ { type: 'commit'
         , sha: '9f82761f8982d751097a922933467b798ae0158d'
         , data: 'tree 6341864dce4bc028f1ead9277261b98cecf6a4e5\nparent b3453be87b70a0c5dea28aacd49cf34ddb91a8c5\nauthor Daniel Lucraft <dan@fluentradical.com> 1293969635 +0000\ncommitter Daniel Lucraft <dan@fluentradical.com> 1293969635 +0000\n\nAdded LICENSE and a branch note to the README\n'
@@ -85,35 +83,28 @@ exports['PackFileParser'] = {
       }
       ]
     )
-    myDebug("branch1 pack: done")
     test.done()
   }
 }
 
 exports['UploadPackParser'] = {
   "NAK": function(test) {
-    myDebug("NAK")
-    var uploadPackParser = new Git.UploadPackParser(GitTestData.uploadPackNAK)
+    var uploadPackParser = new UploadPackParser(GitTestData.uploadPackNAK)
     uploadPackParser.parse()
     test.deepEqual(uploadPackParser.getRemoteLines(), 
                   ['Counting objects: 5, done.', 'Compressing objects: 100% (3/3), done.', 'Total 5 (delta 0), reused 0 (delta 0)'])
-    myDebug("NAK: done")
     test.done()
   },
   "ACK": function(test) {
-    myDebug("ACK")
-    var uploadPackParser = new Git.UploadPackParser(GitTestData.uploadPackACK)
+    var uploadPackParser = new UploadPackParser(GitTestData.uploadPackACK)
     uploadPackParser.parse()
     test.deepEqual(uploadPackParser.getRemoteLines(), 
                   ['Counting objects: 8, done.', 'Compressing objects: 100% (6/6), done.', 'Total 6 (delta 0), reused 0 (delta 0)'])
-    myDebug("ACK: done")
     test.done()
   }
 }
 
 exports['nextPktLine()'] = function(test) {
-  myDebug("nextPktLine")
-  test.equal(Git.nextPktLine("0008NAK\nasdflijasdfj"), "NAK\n")
-  myDebug("nextPktLine: done")
+  test.equal(utils.nextPktLine("0008NAK\nasdflijasdfj"), "NAK\n")
   test.done()
 }
diff --git a/test/memory_repo_test.js b/test/memory_repo_test.js
index 8284b38..ad9549d 100644
--- a/test/memory_repo_test.js
+++ b/test/memory_repo_test.js
@@ -1,20 +1,21 @@
-require('../lib/git-server')
+var MemoryRepo = require('../lib/git/memory_repo')
+  , GithubProxyRepo = require('../lib/git/github_repo')
 
 exports.MemoryRepo = { 
   testCreate: function(test) {
-    var repo = new Git.MemoryRepo()
+    var repo = new MemoryRepo()
     test.done()
   },
   
   testEmpty: function(test) {
-    var repo = new Git.MemoryRepo()
+    var repo = new MemoryRepo()
     test.equal(repo.getRefs().length, 0)
     test.equal(repo.getRemotes().length, 0)
     test.done()
   },
   
   testAddRef: function(test) {
-    var repo = new Git.MemoryRepo()
+    var repo = new MemoryRepo()
     test.deepEqual(repo.getRefs(), [])
     
     repo.addRef("refs/heads/master", "yurrffff")
@@ -24,7 +25,7 @@ exports.MemoryRepo = {
   },
   
   testAddRemote: function(test) {
-    var repo = new Git.MemoryRepo()
+    var repo = new MemoryRepo()
     test.deepEqual(repo.getRemotes(), [])
     
     repo.addRemote("origin", "http://www.yahoo.com/")
@@ -35,7 +36,7 @@ exports.MemoryRepo = {
   },
   
   testMakeAndAddObject: function(test) {
-    var repo = new Git.MemoryRepo()
+    var repo = new MemoryRepo()
     test.deepEqual(repo.objectCount(), 0)
     
     repo.makeAndAddObject("asdfasdf", "blob", "Hello World!")
@@ -52,7 +53,7 @@ exports.MemoryRepo = {
 }
 
 var createTestRepo = function() {
-  return new Git.GithubProxyRepo("danlucraft", "clojure-dojo", "foopw") 
+  return new GithubProxyRepo("danlucraft", "clojure-dojo", "foopw") 
 }
 
 exports.GithubProxyRepo = {
diff --git a/test/object_test.js b/test/object_test.js
index d43af97..ce45517 100644
--- a/test/object_test.js
+++ b/test/object_test.js
@@ -1,9 +1,9 @@
-
-require('../lib/git-server')
+var Objects = require('../lib/git/objects')
+  , utils = require('../lib/git/utils')
 
 exports.Blob = {
   "has basic data": function(test) {
-    var blob = new Git.objects.Blob("sha123", "// An example JavaScript file")
+    var blob = new Objects.Blob("sha123", "// An example JavaScript file")
     test.equals(blob.sha, "sha123")
     test.equals(blob.type, "blob")
     test.equals(blob.data, "// An example JavaScript file")
@@ -15,16 +15,16 @@ var testCommitData = [116, 114, 101, 101, 32, 99, 52, 52, 57, 52, 50, 97, 57, 53
 
 exports.Commit = {
   "has basic data": function(test) {
-    var commit = new Git.objects.Commit("sha123", Git.bytesToString(testCommitData))
+    var commit = new Objects.Commit("sha123", utils.bytesToString(testCommitData))
     
     test.equals(commit.sha, "sha123")
     test.equals(commit.type, "commit")
-    test.equals(commit.data, Git.bytesToString(testCommitData))
+    test.equals(commit.data, utils.bytesToString(testCommitData))
     test.done()
   },
   
   "has commit information": function(test) {
-    var commit = new Git.objects.Commit("sha123", Git.bytesToString(testCommitData))
+    var commit = new Objects.Commit("sha123", utils.bytesToString(testCommitData))
     
     test.equals(commit.tree, "c44942a959a822a3a785ed7c4a658db9690dd175")
     test.equals(commit.author.name, "Daniel Lucraft")
@@ -43,15 +43,15 @@ var testTreeData = [49, 48, 48, 54, 52, 52, 32, 82, 69, 65, 68, 77, 69, 0, 253,
 
 exports.Tree = {
   "has basic data": function(test) {
-    var tree = new Git.objects.Tree("sha123", Git.bytesToString(testTreeData))
+    var tree = new Objects.Tree("sha123", utils.bytesToString(testTreeData))
     test.equals(tree.sha, "sha123")
     test.equals(tree.type, "tree")
-    test.equals(tree.data, Git.bytesToString(testTreeData))
+    test.equals(tree.data, utils.bytesToString(testTreeData))
     test.done()
   },
   
   "has contents": function(test) {
-    var tree = new Git.objects.Tree("sha123", Git.bytesToString(testTreeData))
+    var tree = new Objects.Tree("sha123", utils.bytesToString(testTreeData))
     test.deepEqual(tree.contents, 
       [
         {
@@ -69,4 +69,4 @@ exports.Tree = {
       ])
     test.done()
   }
-}
\ No newline at end of file
+}
diff --git a/test/pack_file_test.js b/test/pack_file_test.js
index 8a80c47..ae3bf27 100644
--- a/test/pack_file_test.js
+++ b/test/pack_file_test.js
@@ -1,22 +1,24 @@
 require('../lib/git-server')
 
 var fs = require('fs')
+var Pack = require('../lib/git/pack')
+  , utils = require('../lib/git/utils')
 
 var fixturePackFile = function() {
   var arr = eval(fs.readFileSync("test/fixtures/pack.json").toString('binary'))
-  return Git.bytesToString(arr)
+  return utils.bytesToString(arr)
 }
 
 exports.PackFileParser = {
   "parses out objects": function(test) {
-    var packFile = new Git.Pack(fixturePackFile())
+    var packFile = new Pack(fixturePackFile())
     packFile.parseAll()
     test.equal(packFile.getObjects().length, 124)
     test.done()
   },
   
   "supports random access by offset": function(test) {
-    var packFile = new Git.Pack(fixturePackFile())
+    var packFile = new Pack(fixturePackFile())
     test.deepEqual(
       packFile.getObjectAtOffset(10229).id(), 
       { type: 'tree'
@@ -40,7 +42,7 @@ exports.PackFileParser = {
   },
   
   "supports random access of delta objects by offset": function(test) {
-    var packFile = new Git.Pack(fixturePackFile())
+    var packFile = new Pack(fixturePackFile())
     var object = packFile.getObjectAtOffset(11633)
     test.equals(object.type, "blob")
     test.equals(object.sha, "88a9ba3a43861008a937d585583fa21ad0e8066f")
diff --git a/test/pack_index_test.js b/test/pack_index_test.js
index e527bc7..7659071 100644
--- a/test/pack_index_test.js
+++ b/test/pack_index_test.js
@@ -1,52 +1,53 @@
-require('../lib/git-server')
+var utils = require('../lib/git/utils')
+  , PackIndex = require('../lib/git/pack_index')
 
 var fs = require('fs')
 
 var fixturePackIndex = function() {
   var arr = eval(fs.readFileSync("test/fixtures/pack_index.json").toString('binary'))
-  return Git.bytesToString(arr)
+  return utils.bytesToString(arr)
 }
 
 exports.PackIndex = {
   "getOffset": function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.getOffset("d3e1f6c063d0e579ce8b7f85324996c57b87fdcf"), 10229)
     test.done()
   },
   
   "getCrc": function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.getCrc("d3e1f6c063d0e579ce8b7f85324996c57b87fdcf"), 2262964883)
     test.done()
   },
   
   "estimatedPackFileSize" : function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.estimatedPackFileSize(), 18056)
     test.done()
   },
   
   "has64bOffsets" : function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.has64bOffsets(), false)
     test.done()
   },
   
   "num objects": function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.numObjects(), 124)
     test.done()
   },
   
   "fanout": function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.fanout("d3e1f6c063d0e579ce8b7f85324996c57b87fdcf"), 97)
     test.equal(packIndex.fanout("00e1f6c063d0e579ce8b7f85324996c57b87fdcf"), 0)
     test.done()
   },
   
   "indexOfSha": function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.indexOfSha("d3e1f6c063d0e579ce8b7f85324996c57b87fdcf"), 97)
     test.equal(packIndex.indexOfSha("0d91a54c7d439e84e3dd17d3594f1b2b6737f430"), 8)
     test.equal(packIndex.indexOfSha("0d91aXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"), null)
@@ -54,7 +55,7 @@ exports.PackIndex = {
   },
   
   "shaAtIndex": function(test) {
-    var packIndex = new Git.PackIndex(fixturePackIndex())
+    var packIndex = new PackIndex(fixturePackIndex())
     test.equal(packIndex.shaAtIndex(1), "00c0b86e8a129e66ed0f5e6c85322b71e289d4cb")
     test.equal(packIndex.shaAtIndex(5), "0c62199f16ac1e2d7f7ae75b420c1231325dff4e")
     test.done()
@@ -63,9 +64,9 @@ exports.PackIndex = {
 
 exports.PackIndexHelpers = {
   "assertVersion": function(test) {
-    test.equal(Git.PackIndex.assertVersion([1,1,1,1,0,0,0,2,1,1,1,1], 2), true)
-    test.equal(Git.PackIndex.assertVersion([1,1,1,1,0,0,0,2,1,1,1,1], 3), false)
-    test.equal(Git.PackIndex.assertVersion([1,1,1,1,0,0,0,3,1,1,1,1], 1), false)
+    test.equal(PackIndex.assertVersion([1,1,1,1,0,0,0,2,1,1,1,1], 2), true)
+    test.equal(PackIndex.assertVersion([1,1,1,1,0,0,0,2,1,1,1,1], 3), false)
+    test.equal(PackIndex.assertVersion([1,1,1,1,0,0,0,3,1,1,1,1], 1), false)
     test.done()
   }
 }
diff --git a/test/remote_test.js b/test/remote_test.js
index b2cb901..4744c23 100644
--- a/test/remote_test.js
+++ b/test/remote_test.js
@@ -1,8 +1,8 @@
-
-require('../lib/git-server')
+var GithubProxyRepo = require('../lib/git/github_repo')
+  , Remote = require('../lib/git/remote')
 
 var createTestRepo = function() {
-  return new Git.GithubProxyRepo("danlucraft", "clojure-dojo", "foopw") 
+  return new GithubProxyRepo("danlucraft", "clojure-dojo", "foopw") 
 }
   
 exports.Remote = {
@@ -27,31 +27,31 @@ exports.Remote = {
   },
   
   testMakeUriNoOptions: function(test) {
-    var remote = new Git.Remote(null, null, "http://google.com/")
+    var remote = new Remote(null, null, "http://google.com/")
     test.equals(remote.makeUri("/info/refs"), "http://google.com/info/refs")
     
-    remote = new Git.Remote(null, null, "http://google.com")
+    remote = new Remote(null, null, "http://google.com")
     test.equals(remote.makeUri("/info/refs"), "http://google.com/info/refs")
     
-    remote = new Git.Remote(null, null, "http://google.com")
+    remote = new Remote(null, null, "http://google.com")
     test.equals(remote.makeUri("/info/refs", {username: "danlucraft"}), "http://google.com/info/refs?username=danlucraft")
 
-    remote = new Git.Remote(null, null, "http://google.com")
+    remote = new Remote(null, null, "http://google.com")
     test.equals(remote.makeUri("/info/refs", {username: "danlucraft", password: "asdf"}), "http://google.com/info/refs?username=danlucraft&password=asdf")
     test.done()
   },
   
   testMakeUriWithOptions: function(test) {
-    var remote = new Git.Remote(null, null, "http://google.com?server=github.com")
+    var remote = new Remote(null, null, "http://google.com?server=github.com")
     test.equals(remote.makeUri("/info/refs"), "http://google.com/info/refs?server=github.com")
     
-    remote = new Git.Remote(null, null, "http://google.com/?server=github.com")
+    remote = new Remote(null, null, "http://google.com/?server=github.com")
     test.equals(remote.makeUri("/info/refs"), "http://google.com/info/refs?server=github.com")
     
-    remote = new Git.Remote(null, null, "http://google.com?server=github.com")
+    remote = new Remote(null, null, "http://google.com?server=github.com")
     test.equals(remote.makeUri("/info/refs", {username: "danlucraft"}), "http://google.com/info/refs?server=github.com&username=danlucraft")
     
-    remote = new Git.Remote(null, null, "http://google.com?server=github.com")
+    remote = new Remote(null, null, "http://google.com?server=github.com")
     test.equals(remote.makeUri("/info/refs", {username: "danlucraft", password: "asdf"}), "http://google.com/info/refs?server=github.com&username=danlucraft&password=asdf")
     test.done()
   }
diff --git a/test/smart_http_remote_test.js b/test/smart_http_remote_test.js
index d75e7e1..6558654 100644
--- a/test/smart_http_remote_test.js
+++ b/test/smart_http_remote_test.js
@@ -1,5 +1,4 @@
-
-require('../lib/git-server')
+var SmartHttpRemote = require('../lib/git/smart_http_remote')
 
 SMART_HTTP_REMOTE_TEST_DATA = {
   discovery: {
@@ -17,9 +16,9 @@ SMART_HTTP_REMOTE_TEST_DATA = {
 exports.SmartHttpRemoteTest = {
   parseDiscovery: function(test) {
     test.deepEqual(
-      Git.SmartHttpRemote.parseDiscovery(SMART_HTTP_REMOTE_TEST_DATA.discovery.data), 
+      SmartHttpRemote.parseDiscovery(SMART_HTTP_REMOTE_TEST_DATA.discovery.data), 
       SMART_HTTP_REMOTE_TEST_DATA.discovery.result, 
       "Decodes the capabilities and refs from the discovery response.")
     test.done()
   }
-}
\ No newline at end of file
+}
diff --git a/vendor/diff.js b/vendor/diff.js
index 05707cf..5ec2a05 100644
--- a/vendor/diff.js
+++ b/vendor/diff.js
@@ -20,8 +20,8 @@
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
-
-Diff = {
+var Diff;
+module.exports = Diff = {
     longest_common_subsequence: function(file1, file2) {
         /* Text diff algorithm following Hunt and McIlroy 1976.
          * J. W. Hunt and M. D. McIlroy, An algorithm for differential file
diff --git a/vendor/js-deflate/rawdeflate.js b/vendor/js-deflate/rawdeflate.js
index d6a0752..548af68 100644
--- a/vendor/js-deflate/rawdeflate.js
+++ b/vendor/js-deflate/rawdeflate.js
@@ -1665,7 +1665,6 @@ var zip_deflate = function(str, level) {
     return aout.join("");
 }
 
-if (! window.RawDeflate) RawDeflate = {};
-RawDeflate.deflate = zip_deflate;
+module.exports.deflate = zip_deflate;
 
 })();
diff --git a/vendor/js-deflate/rawinflate.js b/vendor/js-deflate/rawinflate.js
index 5572fae..956bfbd 100644
--- a/vendor/js-deflate/rawinflate.js
+++ b/vendor/js-deflate/rawinflate.js
@@ -749,7 +749,6 @@ var zip_inflate = function(str) {
     return result;
 }
 
-if (! window.RawDeflate) RawDeflate = {};
-RawDeflate.inflate = zip_inflate;
+module.exports = zip_inflate;
 
 })();
diff --git a/vendor/sha1.js b/vendor/sha1.js
index bfc7152..e0c285d 100755
--- a/vendor/sha1.js
+++ b/vendor/sha1.js
@@ -9,7 +9,8 @@
  * Modified slightly by Daniel Lucraft (2010)
  */
 
-Sha1 = {
+var Sha1;
+module.exports = Sha1 = {
   /*
   * Configurable variables. You may need to tweak these to be compatible with
    * the server-side, but the defaults work in most cases.
@@ -336,4 +337,4 @@ Sha1 = {
   {
     return (num << cnt) | (num >>> (32 - cnt));
   }
-}
\ No newline at end of file
+}
diff --git a/vendor/sha2.js b/vendor/sha2.js
index 13b87a2..206caa1 100644
--- a/vendor/sha2.js
+++ b/vendor/sha2.js
@@ -331,4 +331,4 @@ var SHA1 = (function(){
   });
   
   return SHA1;
-})();
\ No newline at end of file
+})();

From 5741842e03e1ee770ab4cc0a03c2b87f49064adb Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Fri, 12 Aug 2011 01:53:03 -0500
Subject: [PATCH 06/19] Add lib/btoa.js for node.js btoa.

---
 lib/btoa.js  | 4 ++++
 package.json | 1 +
 2 files changed, 5 insertions(+)
 create mode 100644 lib/btoa.js

diff --git a/lib/btoa.js b/lib/btoa.js
new file mode 100644
index 0000000..1bbad62
--- /dev/null
+++ b/lib/btoa.js
@@ -0,0 +1,4 @@
+var Buffer = require('buffer').Buffer
+module.exports = function(str) {
+  return (new Buffer(str, 'utf8')).toString('base64')
+}
diff --git a/package.json b/package.json
index 3a0c94f..7e7004d 100644
--- a/package.json
+++ b/package.json
@@ -8,6 +8,7 @@
         "test" : "test"
     },
     "dependencies" : {
+        "underscore":"1.X.X"
     },
     "devDependencies" : {
         "tracejs" : "0.X.X"

From dde2b4ea0f61c3e11c0a76da7002c286c887d6a9 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Fri, 12 Aug 2011 16:21:54 -0500
Subject: [PATCH 07/19] Rework jasmine tests to work with new commonjs pattern

---
 spec/cli-spec.js                     | 16 ++++++++--------
 spec/commands/branch-command-spec.js |  9 +++++----
 spec/commands/diff-command-spec.js   | 13 +++++++------
 spec/commands/log-command-spec.js    | 11 ++++++-----
 spec/commands/show-command-spec.js   | 22 ++++++++++++----------
 5 files changed, 38 insertions(+), 33 deletions(-)

diff --git a/spec/cli-spec.js b/spec/cli-spec.js
index c9735a3..ed60945 100644
--- a/spec/cli-spec.js
+++ b/spec/cli-spec.js
@@ -1,24 +1,24 @@
-require('../lib/git-server')
 var path = require('path')
+var Cli = require('../lib/git/cli')
 
 var mockRunner = {show:function() {}, log:function() {}, branch:function() {}}
 
 describe("--git-dir", function() {
   it("default should be the current working directory + .git", function() {
-    var cli = new Git.Cli()
+    var cli = new Cli()
     
     expect(cli.gitDir).toEqual(path.join(process.cwd(), ".git"))
   })
   
   it("can specify a relative git dir", function() {
-    var cli = new Git.Cli(["--git-dir=.."])
+    var cli = new Cli(["--git-dir=.."])
     
     expect(cli.gitDir).toEqual(path.join(process.cwd(), ".."))
   })
   
   it("can specify an absolute git dir", function() {
     var test_dir = path.join(process.cwd(), "..", "..")
-    var cli = new Git.Cli(["--git-dir=" + test_dir])
+    var cli = new Cli(["--git-dir=" + test_dir])
     
     expect(cli.gitDir).toEqual(path.join(process.cwd(), "..", ".."))
   })
@@ -27,7 +27,7 @@ describe("--git-dir", function() {
 describe("show command", function() {
   it("should pass in commit ids ", function() {
     spyOn(mockRunner, 'show')
-    var cli = new Git.Cli(["show", "123abc"], mockRunner)
+    var cli = new Cli(["show", "123abc"], mockRunner)
     
     cli.run()
     
@@ -38,7 +38,7 @@ describe("show command", function() {
 describe("log command", function() {  
   it("should run the log command", function() {
     spyOn(mockRunner, 'log')
-    var cli = new Git.Cli(["log"], mockRunner)
+    var cli = new Cli(["log"], mockRunner)
     
     cli.run()
     
@@ -49,10 +49,10 @@ describe("log command", function() {
 describe("branch command", function() {  
   it("should run the branch command", function() {
     spyOn(mockRunner, 'branch')
-    var cli = new Git.Cli(["branch"], mockRunner)
+    var cli = new Cli(["branch"], mockRunner)
     
     cli.run()
     
     expect(mockRunner.branch).toHaveBeenCalled()
   })
-})
\ No newline at end of file
+})
diff --git a/spec/commands/branch-command-spec.js b/spec/commands/branch-command-spec.js
index 367d4cf..7f5551f 100644
--- a/spec/commands/branch-command-spec.js
+++ b/spec/commands/branch-command-spec.js
@@ -1,4 +1,5 @@
-require('../../lib/git-server')
+var Repo = require('../../lib/git/repo')
+  , BranchCommand = require('../../lib/git/commands/branch-command')
 
 var path = require('path')
 
@@ -19,15 +20,15 @@ describe("git branch", function() {
   }
 
   beforeEach(function () {
-    repo = new Git.Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
+    repo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
   })
   
   it("should show a list of branches, with the current highlighted", function() {
-    var cmd = new Git.commands.BranchCommand(repo, [])
+    var cmd = new BranchCommand(repo, [])
 
     expectOutput(cmd, function(output) {
       expect(output).toMatch(/branch1/)
-      expect(output).toMatch(/\* master/)
+      expect(output).toMatch(/\* branch2/)
     })
   })
 })
diff --git a/spec/commands/diff-command-spec.js b/spec/commands/diff-command-spec.js
index 86f4144..3113c4c 100644
--- a/spec/commands/diff-command-spec.js
+++ b/spec/commands/diff-command-spec.js
@@ -1,4 +1,5 @@
-require('../../lib/git-server')
+var Repo = require('../../lib/git/repo')
+  , DiffCommand = require('../../lib/git/commands/diff-command')
 
 var path = require('path')
 
@@ -7,8 +8,8 @@ describe("git diff", function() {
   var packedRepo
 
   beforeEach(function () {
-    looseRepo = new Git.Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
-    packedRepo = new Git.Repo(path.join(__dirname, "../../test/fixtures/test-repo1-packed/.git"))
+    looseRepo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
+    packedRepo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1-packed/.git"))
   })
   
   var expectOutput = function(cmd, cb) {
@@ -42,7 +43,7 @@ describe("git diff", function() {
     " 1 files changed, 1 insertions(+), 1 deletions(-)"
    
   it("diff stats two commits (loose)", function() {
-    var cmd = new Git.commands.DiffCommand(looseRepo, ["d0a9e5b650718445b53cd1cab40d21fb3891c98a", "9f00c2ee854534a785ff01115a94a50c9961610d"], ["--stat"])
+    var cmd = new DiffCommand(looseRepo, ["d0a9e5b650718445b53cd1cab40d21fb3891c98a", "9f00c2ee854534a785ff01115a94a50c9961610d"], ["--stat"])
     
     expectOutput(cmd, function(output) {
       expect(output).toEqual(expectedStatOutput)
@@ -50,7 +51,7 @@ describe("git diff", function() {
   })
   
   // it("diffs two commits (loose)", function() {
-  //   var cmd = new Git.commands.DiffCommand(looseRepo, ["d0a9e5b650718445b53cd1cab40d21fb3891c98a", "9f00c2ee854534a785ff01115a94a50c9961610d"])
+  //   var cmd = new commands.DiffCommand(looseRepo, ["d0a9e5b650718445b53cd1cab40d21fb3891c98a", "9f00c2ee854534a785ff01115a94a50c9961610d"])
   //   
   //   expectOutput(cmd, function(output) {
   //     expect(output).toEqual(expectedOutput)
@@ -58,4 +59,4 @@ describe("git diff", function() {
   // })
 })
 
-  
\ No newline at end of file
+  
diff --git a/spec/commands/log-command-spec.js b/spec/commands/log-command-spec.js
index 1cc5b90..308f09b 100644
--- a/spec/commands/log-command-spec.js
+++ b/spec/commands/log-command-spec.js
@@ -1,4 +1,5 @@
-require('../../lib/git-server')
+var Repo = require('../../lib/git/repo')
+  , LogCommand = require('../../lib/git/commands/log-command')
 
 var path = require('path')
 
@@ -20,8 +21,8 @@ describe("git log", function() {
   }
 
   beforeEach(function () {
-    looseRepo = new Git.Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
-    packedRepo = new Git.Repo(path.join(__dirname, "../../test/fixtures/test-repo1-packed/.git"))
+    looseRepo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
+    packedRepo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1-packed/.git"))
   })
   
   var expectLogOutput = 
@@ -44,7 +45,7 @@ describe("git log", function() {
     "Add sample files"
         
   it("should show a list of branches, with the current highlighted (loose)", function() {
-    var cmd = new Git.commands.LogCommand(looseRepo, [])
+    var cmd = new LogCommand(looseRepo, [])
   
     expectOutput(cmd, function(output) {
       expect(output).toEqual(expectLogOutput)
@@ -52,7 +53,7 @@ describe("git log", function() {
   })
 
   it("should show a list of branches, with the current highlighted (packed)", function() {
-    var cmd = new Git.commands.LogCommand(packedRepo, [])
+    var cmd = new LogCommand(packedRepo, [])
   
     expectOutput(cmd, function(output) {
       expect(output).toEqual(expectLogOutput)
diff --git a/spec/commands/show-command-spec.js b/spec/commands/show-command-spec.js
index 1486632..7c94ed8 100644
--- a/spec/commands/show-command-spec.js
+++ b/spec/commands/show-command-spec.js
@@ -1,4 +1,6 @@
-require('../../lib/git-server')
+var Repo = require('../../lib/git/repo')
+  , ShowCommand = require('../../lib/git/commands/log-command')
+
 
 var path = require('path')
 
@@ -20,13 +22,13 @@ describe("git show", function() {
   }
 
   beforeEach(function () {
-    looseRepo = new Git.Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
-    packedRepo = new Git.Repo(path.join(__dirname, "../../test/fixtures/test-repo1-packed/.git"))
+    looseRepo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1/.git"))
+    packedRepo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1-packed/.git"))
   })
   
   it("should show a loose blob", function() {
     var sha = "17cd63e8471b837707bb7840e87b1772579ab784"
-    var cmd = new Git.commands.ShowCommand(looseRepo, [sha])
+    var cmd = new ShowCommand(looseRepo, [sha])
     
     expectOutput(cmd, function(output) {
       expect(output).not.toMatch(/^blob/)
@@ -36,7 +38,7 @@ describe("git show", function() {
   
   it("should show a packed blob", function() {
     var sha = "17cd63e8471b837707bb7840e87b1772579ab784"
-    var cmd = new Git.commands.ShowCommand(packedRepo, [sha])
+    var cmd = new ShowCommand(packedRepo, [sha])
       
     expectOutput(cmd, function(output) {
       expect(output).not.toMatch(/^blob/)
@@ -46,7 +48,7 @@ describe("git show", function() {
   
   it("should show a loose commit", function() {
     var sha = "8e8b973cde2e6470626dedfc5d82716d1450dcda"
-    var cmd = new Git.commands.ShowCommand(looseRepo, [sha])
+    var cmd = new ShowCommand(looseRepo, [sha])
     
     expectOutput(cmd, function(output) {
       expect(output).toMatch(/commit 8e8b973cde2e6470626dedfc5d82716d1450dcda/)
@@ -58,7 +60,7 @@ describe("git show", function() {
   
   it("should show a loose tree", function() {
     var sha = "5541389163ccf38f7138c50c691c05e790d122d1"
-    var cmd = new Git.commands.ShowCommand(looseRepo, [sha])
+    var cmd = new ShowCommand(looseRepo, [sha])
     
     expectOutput(cmd, function(output) {
       expect(output).toMatch(/tree 5541389163ccf38f7138c50c691c05e790d122d1/)
@@ -69,7 +71,7 @@ describe("git show", function() {
   
   it("should show a packed tree", function() {
     var sha = "5541389163ccf38f7138c50c691c05e790d122d1"
-    var cmd = new Git.commands.ShowCommand(packedRepo, [sha])
+    var cmd = new ShowCommand(packedRepo, [sha])
     
     expectOutput(cmd, function(output) {
       expect(output).toMatch(/tree 5541389163ccf38f7138c50c691c05e790d122d1/)
@@ -80,7 +82,7 @@ describe("git show", function() {
   
   it("should show a packed commit", function() {
     var sha = "8e8b973cde2e6470626dedfc5d82716d1450dcda"
-    var cmd = new Git.commands.ShowCommand(packedRepo, [sha])
+    var cmd = new ShowCommand(packedRepo, [sha])
       
     expectOutput(cmd, function(output) {
       expect(output).toMatch(/commit 8e8b973cde2e6470626dedfc5d82716d1450dcda/)
@@ -90,4 +92,4 @@ describe("git show", function() {
     })
   })
   
-})
\ No newline at end of file
+})

From 8af63d6153b82aced6f7ed1ab52c97943bceda77 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Fri, 12 Aug 2011 16:22:08 -0500
Subject: [PATCH 08/19] pack_index requires string_helpers

---
 lib/git/pack_index.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/git/pack_index.js b/lib/git/pack_index.js
index e74a8a4..e8fd4c0 100644
--- a/lib/git/pack_index.js
+++ b/lib/git/pack_index.js
@@ -1,6 +1,8 @@
 var BinaryFile = require('../binary_file')
   , _ = require('underscore')
 
+require('../string_helpers')
+
 // This object partially parses the data contained in a pack-*.idx file, and provides
 // access to the offsets of the objects the packfile and the crc checksums of the objects.
 var PackIndex = function(data) {

From 275d7cfb3a7f0823f4d31995d3a6bd08a372212e Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Sat, 13 Aug 2011 01:23:28 -0500
Subject: [PATCH 09/19] Fix broken spec/commands/ log test

---
 lib/git/objects.js                |  9 +++++++--
 spec/commands/log-command-spec.js | 27 ++++++++++++++++++++-------
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/lib/git/objects.js b/lib/git/objects.js
index 383fcd1..3df8ef1 100644
--- a/lib/git/objects.js
+++ b/lib/git/objects.js
@@ -130,11 +130,16 @@ var Objects = {
     }
     
     var parseAuthor = function(line) {
-      var match = /^(.*) <(.*)> (\d+) [\+\-]\d\d\d\d$/.exec(line)
+      var match = /^(.*) <(.*)> (\d+) ([\+\-]\d\d\d\d)$/.exec(line)
       var result = {}
       result.name = match[1]
       result.email = match[2]
       result.timestamp = parseInt(match[3])
+      result.offset = (1000*60*      parseInt(match[4].slice(-2), 10) +
+                       1000*60*60*   parseInt(match[4].slice(-4, 3), 10)) *
+                       match[4].charAt(0) === '+' ? 1 : -1
+      result.stroffset = match[4]
+
       result.date = new Date(result.timestamp*1000)
       return result
     }
@@ -153,7 +158,7 @@ var Objects = {
     this.toString = function() {
       var str = "commit " + sha + "\n"
       str += "Author: " + this.author.name + " <" + this.author.email + ">\n"
-      str += "Date:   " + this.author.date +"\n"
+      str += "Date:   " + (new Date(+this.author.date + this.author.offset)).toUTCString().slice(0, -4) + ' ' + this.author.stroffset +"\n"
       str += "\n"
       str += this.message
       return str
diff --git a/spec/commands/log-command-spec.js b/spec/commands/log-command-spec.js
index 308f09b..34ae9d5 100644
--- a/spec/commands/log-command-spec.js
+++ b/spec/commands/log-command-spec.js
@@ -25,30 +25,43 @@ describe("git log", function() {
     packedRepo = new Repo(path.join(__dirname, "../../test/fixtures/test-repo1-packed/.git"))
   })
   
-  var expectLogOutput = 
+  var expectPackedLogOutput = 
     "commit 9f00c2ee854534a785ff01115a94a50c9961610d\n" + 
     "Author: Daniel Lucraft <dan@fluentradical.com>\n" + 
-    "Date:   Mon Jan 03 2011 07:22:59 GMT+0000 (GMT)\n" + 
+    "Date:   Mon, 03 Jan 2011 07:22:59 +0000\n" + 
     "\n" + 
     "Modifiying master\n" + 
     "\n" + 
     "commit d0a9e5b650718445b53cd1cab40d21fb3891c98a\n" + 
     "Author: Daniel Lucraft <dan@fluentradical.com>\n" + 
-    "Date:   Mon Jan 03 2011 07:14:11 GMT+0000 (GMT)\n" + 
+    "Date:   Mon, 03 Jan 2011 07:14:11 +0000\n" + 
     "\n" + 
     "Modify README\n" + 
     "\n" + 
     "commit b3453be87b70a0c5dea28aacd49cf34ddb91a8c5\n" + 
     "Author: Daniel Lucraft <dan@fluentradical.com>\n" + 
-    "Date:   Mon Dec 27 2010 12:59:13 GMT+0000 (GMT)\n" + 
+    "Date:   Mon, 27 Dec 2010 12:59:13 +0000\n" + 
     "\n" + 
     "Add sample files"
-        
+
+    var expectLooseLogOutput =
+    'commit 8e8b973cde2e6470626dedfc5d82716d1450dcda\n'+
+    'Author: Daniel Lucraft <dan@fluentradical.com>\n'+
+    'Date:   Mon, 03 Jan 2011 07:08:07 +0000\n'+
+    '\n'+
+    'Thoroughly modified the README\n'+
+    '\n'+
+    'commit b3453be87b70a0c5dea28aacd49cf34ddb91a8c5\n'+
+    'Author: Daniel Lucraft <dan@fluentradical.com>\n'+
+    'Date:   Mon, 27 Dec 2010 12:59:12 +0000\n'+
+    '\n'+
+    'Add sample files'
+
   it("should show a list of branches, with the current highlighted (loose)", function() {
     var cmd = new LogCommand(looseRepo, [])
   
     expectOutput(cmd, function(output) {
-      expect(output).toEqual(expectLogOutput)
+      expect(output).toEqual(expectLooseLogOutput)
     })
   })
 
@@ -56,7 +69,7 @@ describe("git log", function() {
     var cmd = new LogCommand(packedRepo, [])
   
     expectOutput(cmd, function(output) {
-      expect(output).toEqual(expectLogOutput)
+      expect(output).toEqual(expectPackedLogOutput)
     })
   })
 })

From 59a96d435c297aedc0d6bc409022321b227e96e8 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Sun, 14 Aug 2011 15:52:33 -0500
Subject: [PATCH 10/19] Abstract out the http interface.

---
 lib/git/http.js        | 35 +++++++++++++++++++++++++++++++++++
 lib/git/http_remote.js |  8 ++++----
 2 files changed, 39 insertions(+), 4 deletions(-)
 create mode 100644 lib/git/http.js

diff --git a/lib/git/http.js b/lib/git/http.js
new file mode 100644
index 0000000..b906ef6
--- /dev/null
+++ b/lib/git/http.js
@@ -0,0 +1,35 @@
+var get;
+if(typeof XMLHttpRequest !== 'undefined') {
+  var url = require('../../vendor/node_urlparser')
+
+  get = function(uri, ready) {
+    var xhr = new XMLHttpRequest;
+    xhr.onreadystatechange = function() {
+      if(xhr.readyState === 4) {
+        if(xhr.status === 200) {
+          ready(null, xhr.responseText)
+        } else ready(new Error('Got a '+xhr.status+' response from '+uri));
+      }
+    }
+    xhr.open(
+        'GET'
+      , uri
+      , true
+    )
+    xhr.send(null) 
+  }
+} else {
+  var http = require('http')
+    , url  = require('url')
+
+  get = function(uri, ready) {
+    var parsed = url.parse(uri)
+    http.request({
+        host  : parsed.hostname
+      , port  : parseInt(parsed.port || 80)
+      , path  : parsed.pathname + parsed.query + parsed.hash
+    }, ready)
+  }
+}
+
+exports.get = get;
diff --git a/lib/git/http_remote.js b/lib/git/http_remote.js
index a8711ed..aa83419 100644
--- a/lib/git/http_remote.js
+++ b/lib/git/http_remote.js
@@ -6,21 +6,21 @@ var BinaryFile = require('../binary_file')
   , _ = require('underscore')
   , inflate = require('../../vendor/js-deflate/rawinflate')
   , Objects = require('./objects')
+  , http = require('./http')
 
 var HttpRemote = function(repo, name, repoUrl) {
   Remote.call(this, repo, name, repoUrl)
   
   this.fetchRefs = function(callback) {
     var remote = this
-    $.get(
+    http.get(
       this.makeUri('/info/refs'),
-      "",
-      function(data) {
+      function(err, data) {
         var refs = HttpRemote.parseInfoRefs(data)
         _(refs).each(function(ref) {
           remote.addRef(ref.name, ref.sha)
         })
-        if (callback != "undefined") {
+        if (callback !== undefined) {
           callback(refs)
         }
       }

From 01d7ce4d5517953b122022d8f0d6075f489549ea Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Sun, 14 Aug 2011 15:53:01 -0500
Subject: [PATCH 11/19] Compare callback to 'undefined'

---
 lib/git/smart_http_remote.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/git/smart_http_remote.js b/lib/git/smart_http_remote.js
index e4d6a6a..c24eb65 100644
--- a/lib/git/smart_http_remote.js
+++ b/lib/git/smart_http_remote.js
@@ -17,7 +17,7 @@ var SmartHttpRemote = function(repo, name, repoUrl) {
           ref = discInfo.refs[i]
           remote.addRef(ref.name, ref.sha)
         }
-        if (callback != "undefined") {
+        if (callback !== undefined) {
           callback(discInfo.refs)
         }
       }
@@ -51,7 +51,7 @@ var SmartHttpRemote = function(repo, name, repoUrl) {
           var newObject = thisRemote.repo.makeAndAddObject(object.sha, object.type, object.data)
           newObjects.push(newObject)
         }
-        if (callback != "undefined") {
+        if (callback !== undefined) {
           callback(parser.getRemoteLines(), newObjects)
         }
       },

From 29b0e229c20a0a2f9d38aefd832fe2928a1ae010 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Sun, 14 Aug 2011 19:07:17 -0500
Subject: [PATCH 12/19] Rewrite package builder -- browser repo viewer works
 again.

---
 Rakefile                         |   95 +-
 demos/config.ru                  |    4 +-
 demos/repo-viewer/repo-viewer.js |   14 +-
 lib/git.min.js                   | 5253 ------------------------------
 lib/git/http.js                  |    2 -
 lib/git/memory_repo.js           |   10 +-
 vendor/md5.js                    |    7 +-
 7 files changed, 107 insertions(+), 5278 deletions(-)
 delete mode 100644 lib/git.min.js

diff --git a/Rakefile b/Rakefile
index 9958c3e..530dac6 100644
--- a/Rakefile
+++ b/Rakefile
@@ -17,18 +17,95 @@ end
 
 desc "Concatenate the javascript for the client"
 task :package_client do
-  load_file = File.read(File.dirname(__FILE__) + "/lib/git-client.js")
-  paths = load_file.scan(/getScript\("\/([^"]*)"\)/)
-  js = ["jsGitInNode = false"]
-  paths.each do |path|
-    js << File.read(File.dirname(__FILE__) + "/" + path.first)
-  end
+  preamble = <<-PREAMBLE
+    (function(exp) {
+        exp.Git = {}
+        exp.Git.modules = {}
+        var getModule = function(path) {
+            var module = exp.Git.modules[path]
+            if(module)
+                return module
+            module = {
+                exports:{},
+                path:path,
+                execute:null,
+                toString:function() { return '<Module: "'+path+'">'; }
+            }
+            exp.Git.modules[path] = module
+            return module
+        }
+
+        var resolve = function(path) {
+            var bits = path.split('/')
+            var out = []
+            for(var i = 0, len = bits.length; i < len; ++i) {
+                var cur = bits[i]
+                if(bits[i] === '.')
+                    continue;
+                else if(bits[i] === '..')
+                    out.pop()
+                else
+                    out.push(bits[i])
+            }
+            return out.join('/')
+        }
+
+        var getRequire = function(module) {
+            var basename = module.path.split('/').slice(0, -1).join('/');
+            return function(path) {
+                path === 'underscore' &&
+                  (path = 'vendor/underscore-min')
+
+                var first = path.slice(0, 2),
+                    fullpath
+                if(first === './' || first === '..') {
+                    fullpath = resolve(basename+'/'+path)
+                } else {
+                    fullpath = resolve(path)
+                }
+                var mod = exp.Git.modules[fullpath]
+                mod.execute && mod.execute()
+                return mod.exports
+            }
+        }
+
+        exp.GIT__module__ = getModule
+        exp.GIT__require__ = getRequire
+        exp.Git.require = getRequire(getModule('.'))
+    })(window);
+  PREAMBLE
+
+  wrap = <<-WRAP
+    (function() {
+        var module = GIT__module__('%s')
+        var require = GIT__require__(module)
+        module.execute = function() {
+            (function(module, exports, require) {
+                %s
+            })(this, this.exports, require)
+            module.execute = null; 
+        }
+    })();
+  WRAP
+
+  # TODO: replace this hackiness with something better.
+  libraries = Dir['lib/*.js'] + Dir['lib/*/*.js'] + Dir['lib/*/*/*.js']
+  vendor = Dir['vendor/*.js'] + Dir['vendor/*/*.js']
+
+  js = [preamble]
+  (libraries + vendor).each do |path|
+    js << wrap % [ 
+        path.sub('.js', ''),
+        File.read(File.dirname(__FILE__) + "/" + path)
+    ] 
+  end 
+
   total_js = js.join("\n\n")
-  File.open("lib/git.min.js", "w") {|f| f.puts total_js }
-  puts "packaged lib/git.min.js"
+  File.open("build/git.min.js", "w") {|f| f.puts total_js }
+  puts "packaged build/git.min.js"
 end
 
 desc "Run the demo repo-viewer webapp off a local git http instance"
 task :demo => :package_client do
   exec("thin -R demos/config.ru -p 9292 start")
-end
\ No newline at end of file
+end
diff --git a/demos/config.ru b/demos/config.ru
index 99605b8..8716c81 100644
--- a/demos/config.ru
+++ b/demos/config.ru
@@ -16,7 +16,7 @@ class ServeGitJs
   
   def call(env)
     if env["PATH_INFO"] == "/git.min.js"
-      path = File.expand_path(File.dirname(__FILE__) + "/../lib/git.min.js")
+      path = File.expand_path(File.dirname(__FILE__) + "/../build/git.min.js")
       if File.exist?(path)
         content = File.read(path)
         status  = 200
@@ -51,4 +51,4 @@ puts
 puts " * visit #{bold}http://localhost:9292/repo-viewer/index.html#{nobold}"
 puts " * serving git repos from #{bold}#{serve_path}#{nobold}. "
 puts " * Add more (bare) repos here to view them in repo-viewer. (SMALL repos work best) "
-puts
\ No newline at end of file
+puts
diff --git a/demos/repo-viewer/repo-viewer.js b/demos/repo-viewer/repo-viewer.js
index 79f1c72..1adaec4 100644
--- a/demos/repo-viewer/repo-viewer.js
+++ b/demos/repo-viewer/repo-viewer.js
@@ -1,4 +1,10 @@
+var MemoryRepo = Git.require('lib/git/memory_repo')
+  , GithubProxyRepo = Git.require('lib/git/github_repo')
+  , TreeDiff = Git.require('lib/git/tree-diff')
+  , _ = Git.require('underscore')
+  , MyMD5 = Git.require('vendor/md5')
 
+console.log(MyMD5)
 RepoViewer = {
   repo: null,
   
@@ -72,7 +78,7 @@ RepoViewer = {
   displayCommitDiffDiff: function(commit) {
     RepoViewer.repo.getObject(commit.parents[0], function(err, parent) {
       var parentTree = parent ? parent.tree : null
-      var treeDiff = new Git.TreeDiff(RepoViewer.repo, parentTree, commit.tree)
+      var treeDiff = new TreeDiff(RepoViewer.repo, parentTree, commit.tree)
       treeDiff.toHtml(function(html) {
         $("#diff").append(html)
       })
@@ -212,7 +218,7 @@ RepoViewer = {
   },
   
   githubDemo: function(username, reponame, password) {
-    RepoViewer.repo = new Git.GithubProxyRepo(username, reponame, password)
+    RepoViewer.repo = new GithubProxyRepo(username, reponame, password)
     var origin = RepoViewer.repo.getRemote("origin")
     origin.fetchRefs(function() {
       RepoViewer.displayRefs(RepoViewer.repo.getAllRefs())
@@ -229,7 +235,7 @@ RepoViewer = {
     RepoViewer.clearRefs()
     RepoViewer.clearCommits()
     RepoViewer.clearErrors()
-    var repo = new Git.MemoryRepo()
+    var repo = new MemoryRepo()
     RepoViewer.repo = repo
     console.log("creating repo with origin: " + uri)
     // if (uri.indexOf("//github.com")) {
@@ -242,4 +248,4 @@ RepoViewer = {
       })
     
   }
-}
\ No newline at end of file
+}
diff --git a/lib/git.min.js b/lib/git.min.js
deleted file mode 100644
index b5627a3..0000000
--- a/lib/git.min.js
+++ /dev/null
@@ -1,5253 +0,0 @@
-jsGitInNode = false
-
-/**
-*
-*  MD5 (Message-Digest Algorithm)
-*  http://www.webtoolkit.info/
-*
-**/
- 
-MyMD5 = function (string) {
- 
-	function RotateLeft(lValue, iShiftBits) {
-		return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits));
-	}
- 
-	function AddUnsigned(lX,lY) {
-		var lX4,lY4,lX8,lY8,lResult;
-		lX8 = (lX & 0x80000000);
-		lY8 = (lY & 0x80000000);
-		lX4 = (lX & 0x40000000);
-		lY4 = (lY & 0x40000000);
-		lResult = (lX & 0x3FFFFFFF)+(lY & 0x3FFFFFFF);
-		if (lX4 & lY4) {
-			return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
-		}
-		if (lX4 | lY4) {
-			if (lResult & 0x40000000) {
-				return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
-			} else {
-				return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
-			}
-		} else {
-			return (lResult ^ lX8 ^ lY8);
-		}
- 	}
- 
- 	function F(x,y,z) { return (x & y) | ((~x) & z); }
- 	function G(x,y,z) { return (x & z) | (y & (~z)); }
- 	function H(x,y,z) { return (x ^ y ^ z); }
-	function I(x,y,z) { return (y ^ (x | (~z))); }
- 
-	function FF(a,b,c,d,x,s,ac) {
-		a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
-		return AddUnsigned(RotateLeft(a, s), b);
-	};
- 
-	function GG(a,b,c,d,x,s,ac) {
-		a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
-		return AddUnsigned(RotateLeft(a, s), b);
-	};
- 
-	function HH(a,b,c,d,x,s,ac) {
-		a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
-		return AddUnsigned(RotateLeft(a, s), b);
-	};
- 
-	function II(a,b,c,d,x,s,ac) {
-		a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
-		return AddUnsigned(RotateLeft(a, s), b);
-	};
- 
-	function ConvertToWordArray(string) {
-		var lWordCount;
-		var lMessageLength = string.length;
-		var lNumberOfWords_temp1=lMessageLength + 8;
-		var lNumberOfWords_temp2=(lNumberOfWords_temp1-(lNumberOfWords_temp1 % 64))/64;
-		var lNumberOfWords = (lNumberOfWords_temp2+1)*16;
-		var lWordArray=Array(lNumberOfWords-1);
-		var lBytePosition = 0;
-		var lByteCount = 0;
-		while ( lByteCount < lMessageLength ) {
-			lWordCount = (lByteCount-(lByteCount % 4))/4;
-			lBytePosition = (lByteCount % 4)*8;
-			lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount)<<lBytePosition));
-			lByteCount++;
-		}
-		lWordCount = (lByteCount-(lByteCount % 4))/4;
-		lBytePosition = (lByteCount % 4)*8;
-		lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80<<lBytePosition);
-		lWordArray[lNumberOfWords-2] = lMessageLength<<3;
-		lWordArray[lNumberOfWords-1] = lMessageLength>>>29;
-		return lWordArray;
-	};
- 
-	function WordToHex(lValue) {
-		var WordToHexValue="",WordToHexValue_temp="",lByte,lCount;
-		for (lCount = 0;lCount<=3;lCount++) {
-			lByte = (lValue>>>(lCount*8)) & 255;
-			WordToHexValue_temp = "0" + lByte.toString(16);
-			WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length-2,2);
-		}
-		return WordToHexValue;
-	};
- 
-	function Utf8Encode(string) {
-		string = string.replace(/\r\n/g,"\n");
-		var utftext = "";
- 
-		for (var n = 0; n < string.length; n++) {
- 
-			var c = string.charCodeAt(n);
- 
-			if (c < 128) {
-				utftext += String.fromCharCode(c);
-			}
-			else if((c > 127) && (c < 2048)) {
-				utftext += String.fromCharCode((c >> 6) | 192);
-				utftext += String.fromCharCode((c & 63) | 128);
-			}
-			else {
-				utftext += String.fromCharCode((c >> 12) | 224);
-				utftext += String.fromCharCode(((c >> 6) & 63) | 128);
-				utftext += String.fromCharCode((c & 63) | 128);
-			}
- 
-		}
- 
-		return utftext;
-	};
- 
-	var x=Array();
-	var k,AA,BB,CC,DD,a,b,c,d;
-	var S11=7, S12=12, S13=17, S14=22;
-	var S21=5, S22=9 , S23=14, S24=20;
-	var S31=4, S32=11, S33=16, S34=23;
-	var S41=6, S42=10, S43=15, S44=21;
- 
-	string = Utf8Encode(string);
- 
-	x = ConvertToWordArray(string);
- 
-	a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
- 
-	for (k=0;k<x.length;k+=16) {
-		AA=a; BB=b; CC=c; DD=d;
-		a=FF(a,b,c,d,x[k+0], S11,0xD76AA478);
-		d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
-		c=FF(c,d,a,b,x[k+2], S13,0x242070DB);
-		b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
-		a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
-		d=FF(d,a,b,c,x[k+5], S12,0x4787C62A);
-		c=FF(c,d,a,b,x[k+6], S13,0xA8304613);
-		b=FF(b,c,d,a,x[k+7], S14,0xFD469501);
-		a=FF(a,b,c,d,x[k+8], S11,0x698098D8);
-		d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
-		c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
-		b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
-		a=FF(a,b,c,d,x[k+12],S11,0x6B901122);
-		d=FF(d,a,b,c,x[k+13],S12,0xFD987193);
-		c=FF(c,d,a,b,x[k+14],S13,0xA679438E);
-		b=FF(b,c,d,a,x[k+15],S14,0x49B40821);
-		a=GG(a,b,c,d,x[k+1], S21,0xF61E2562);
-		d=GG(d,a,b,c,x[k+6], S22,0xC040B340);
-		c=GG(c,d,a,b,x[k+11],S23,0x265E5A51);
-		b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
-		a=GG(a,b,c,d,x[k+5], S21,0xD62F105D);
-		d=GG(d,a,b,c,x[k+10],S22,0x2441453);
-		c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
-		b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
-		a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
-		d=GG(d,a,b,c,x[k+14],S22,0xC33707D6);
-		c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
-		b=GG(b,c,d,a,x[k+8], S24,0x455A14ED);
-		a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
-		d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
-		c=GG(c,d,a,b,x[k+7], S23,0x676F02D9);
-		b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
-		a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
-		d=HH(d,a,b,c,x[k+8], S32,0x8771F681);
-		c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
-		b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
-		a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
-		d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
-		c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
-		b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
-		a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
-		d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
-		c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
-		b=HH(b,c,d,a,x[k+6], S34,0x4881D05);
-		a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
-		d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
-		c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
-		b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
-		a=II(a,b,c,d,x[k+0], S41,0xF4292244);
-		d=II(d,a,b,c,x[k+7], S42,0x432AFF97);
-		c=II(c,d,a,b,x[k+14],S43,0xAB9423A7);
-		b=II(b,c,d,a,x[k+5], S44,0xFC93A039);
-		a=II(a,b,c,d,x[k+12],S41,0x655B59C3);
-		d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
-		c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
-		b=II(b,c,d,a,x[k+1], S44,0x85845DD1);
-		a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
-		d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
-		c=II(c,d,a,b,x[k+6], S43,0xA3014314);
-		b=II(b,c,d,a,x[k+13],S44,0x4E0811A1);
-		a=II(a,b,c,d,x[k+4], S41,0xF7537E82);
-		d=II(d,a,b,c,x[k+11],S42,0xBD3AF235);
-		c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
-		b=II(b,c,d,a,x[k+9], S44,0xEB86D391);
-		a=AddUnsigned(a,AA);
-		b=AddUnsigned(b,BB);
-		c=AddUnsigned(c,CC);
-		d=AddUnsigned(d,DD);
-	}
- 
-	var temp = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);
- 
-	return temp.toLowerCase();
-}
-
-
-BinaryFile = function(strData, iDataOffset, iDataLength) {
-	var data = strData;
-	var dataOffset = iDataOffset || 0;
-	var dataLength = 0;
-
-	this.getRawData = function() {
-		return data;
-	}
-  
-  this.slice = function(begin, optionalEnd) {
-    var arr = [];
-    var end = optionalEnd || this.getLength();
-    var i;
-    for (i = begin; i < end; i++) {
-      arr.push(this.getByteAt(i));
-    }
-    return arr;
-  }
-  
-  if (typeof strData == "string") {
-		dataLength = iDataLength || data.length;
-
-		this.getByteAt = function(iOffset) {
-			return data.charCodeAt(iOffset + dataOffset) & 0xFF;
-		}
-	} else if (typeof strData == "unknown") {
-		dataLength = iDataLength || IEBinary_getLength(data);
-
-		this.getByteAt = function(iOffset) {
-			return IEBinary_getByteAt(data, iOffset + dataOffset);
-		}
-  } else {
-    throw(Error("BinaryFile was given a " + (typeof strData) + " and doesn't know what to do with it"))
-  }
-
-	this.getLength = function() {
-		return dataLength;
-	}
-
-	this.getSByteAt = function(iOffset) {
-		var iByte = this.getByteAt(iOffset);
-		if (iByte > 127)
-			return iByte - 256;
-		else
-			return iByte;
-	}
-
-	this.getShortAt = function(iOffset, bBigEndian) {
-		var iShort = bBigEndian ? 
-			(this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1)
-			: (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset)
-		if (iShort < 0) iShort += 65536;
-		return iShort;
-	}
-	this.getSShortAt = function(iOffset, bBigEndian) {
-		var iUShort = this.getShortAt(iOffset, bBigEndian);
-		if (iUShort > 32767)
-			return iUShort - 65536;
-		else
-			return iUShort;
-	}
-	this.getLongAt = function(iOffset, bBigEndian) {
-		var iByte1 = this.getByteAt(iOffset),
-			iByte2 = this.getByteAt(iOffset + 1),
-			iByte3 = this.getByteAt(iOffset + 2),
-			iByte4 = this.getByteAt(iOffset + 3);
-
-		var iLong = bBigEndian ? 
-			(((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4
-			: (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1;
-		if (iLong < 0) iLong += 4294967296;
-		return iLong;
-	}
-	this.getSLongAt = function(iOffset, bBigEndian) {
-		var iULong = this.getLongAt(iOffset, bBigEndian);
-		if (iULong > 2147483647)
-			return iULong - 4294967296;
-		else
-			return iULong;
-	}
-	this.getStringAt = function(iOffset, iLength) {
-		var aStr = [];
-		for (var i=iOffset,j=0;i<iOffset+iLength;i++,j++) {
-			aStr[j] = String.fromCharCode(this.getByteAt(i));
-		}
-		return aStr.join("");
-	}
-
-	this.getCharAt = function(iOffset) {
-		return String.fromCharCode(this.getByteAt(iOffset));
-	}
-	this.toBase64 = function() {
-		return window.btoa(data);
-	}
-	this.fromBase64 = function(strBase64) {
-		data = window.atob(strBase64);
-	}
-};
-
-
-String.prototype.repeat = function( num ) {
-	for( var i = 0, buf = ""; i < num; i++ ) buf += this;
-	return buf;
-}
-
-String.prototype.ljust = function( width, padding ) {
-	padding = padding || " ";
-	padding = padding.substr( 0, 1 );
-	if( this.length < width )
-		return this + padding.repeat( width - this.length );
-	else
-		return this.toString();
-}
-
-String.prototype.rjust = function( width, padding ) {
-	padding = padding || " ";
-	padding = padding.substr( 0, 1 );
-	if( this.length < width )
-		return padding.repeat( width - this.length ) + this;
-	else
-		return this.toString();
-}
-
-Array.prototype.compare = function(testArr) {
-    if (this.length != testArr.length) return false;
-    for (var i = 0; i < testArr.length; i++) {
-        if (this[i].compare) { 
-            if (!this[i].compare(testArr[i])) return false;
-        }
-        if (this[i] !== testArr[i]) return false;
-    }
-    return true;
-}
-
-
-/*
- * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
- * in FIPS 180-1
- * Version 2.2 Copyright Paul Johnston 2000 - 2009.
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
- * Distributed under the BSD License
- * See http://pajhome.org.uk/crypt/md5 for details.
- *
- * Modified slightly by Daniel Lucraft (2010)
- */
-
-Sha1 = {
-  /*
-  * Configurable variables. You may need to tweak these to be compatible with
-   * the server-side, but the defaults work in most cases.
-   */
-  hexcase: 0,  /* hex output format. 0 - lowercase; 1 - uppercase        */
-  b64pad:  "", /* base-64 pad character. "=" for strict RFC compliance   */
-  
-  /*
-   * These are the functions you'll usually want to call
-   * They take string arguments and return either hex or base-64 encoded strings
-   */
-  hex_sha1: function(s)    { return Sha1.rstr2hex(Sha1.rstr_sha1(Sha1.str2rstr_utf8(s))); },
-  b64_sha1: function(s)    { return Sha1.rstr2b64(Sha1.rstr_sha1(Sha1.str2rstr_utf8(s))); },
-  any_sha1: function(s, e) { return Sha1.rstr2any(Sha1.rstr_sha1(Sha1.str2rstr_utf8(s)), e); },
-  hex_hmac_sha1: function(k, d)
-    { return Sha1.rstr2hex(Sha1.rstr_hmac_sha1(Sha1.str2rstr_utf8(k), Sha1.str2rstr_utf8(d))); },
-  b64_hmac_sha1: function(k, d)
-    { return Sha1.rstr2b64(Sha1.rstr_hmac_sha1(Sha1.str2rstr_utf8(k), Sha1.str2rstr_utf8(d))); },
-  any_hmac_sha1: function(k, d, e)
-    { return Sha1.rstr2any(Sha1.rstr_hmac_sha1(Sha1.str2rstr_utf8(k), Sha1.str2rstr_utf8(d)), e); },
-  
-  /*
-   * Perform a simple self-test to see if the VM is working
-   */
-  sha1_vm_test: function()
-  {
-    return Sha1.hex_sha1("abc").toLowerCase() == "a9993e364706816aba3e25717850c26c9cd0d89d";
-  },
-  
-  /*
-   * Calculate the SHA1 of a raw string
-   */
-  rstr_sha1: function(s)
-  {
-    return Sha1.binb2rstr(Sha1.binb_sha1(Sha1.rstr2binb(s), s.length * 8));
-  },
-  
-  /*
-   * Calculate the HMAC-SHA1 of a key and some data (raw strings)
-   */
-  rstr_hmac_sha1: function(key, data)
-  {
-    var bkey = Sha1.rstr2binb(key);
-    if(bkey.length > 16) bkey = Sha1.binb_sha1(bkey, key.length * 8);
-  
-    var ipad = Array(16), opad = Array(16);
-    for(var i = 0; i < 16; i++)
-    {
-      ipad[i] = bkey[i] ^ 0x36363636;
-      opad[i] = bkey[i] ^ 0x5C5C5C5C;
-    }
-  
-    var hash = Sha1.binb_sha1(ipad.concat(Sha1.rstr2binb(data)), 512 + data.length * 8);
-    return Sha1.binb2rstr(Sha1.binb_sha1(opad.concat(hash), 512 + 160));
-  },
-  
-  /*
-   * Convert a raw string to a hex string
-   */
-  rstr2hex: function(input)
-  {
-    try { Sha1.hexcase } catch(e) { Sha1.hexcase=0; }
-    var hex_tab = Sha1.hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
-    var output = "";
-    var x;
-    for(var i = 0; i < input.length; i++)
-    {
-      x = input.charCodeAt(i);
-      output += hex_tab.charAt((x >>> 4) & 0x0F)
-             +  hex_tab.charAt( x        & 0x0F);
-    }
-    return output;
-  },
-  
-  /*
-   * Convert a raw string to a base-64 string
-   */
-  rstr2b64: function(input)
-  {
-    try { Sha1.b64pad } catch(e) { Sha1.b64pad=''; }
-    var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    var output = "";
-    var len = input.length;
-    for(var i = 0; i < len; i += 3)
-    {
-      var triplet = (input.charCodeAt(i) << 16)
-                  | (i + 1 < len ? input.charCodeAt(i+1) << 8 : 0)
-                  | (i + 2 < len ? input.charCodeAt(i+2)      : 0);
-      for(var j = 0; j < 4; j++)
-      {
-        if(i * 8 + j * 6 > input.length * 8) output += b64pad;
-        else output += tab.charAt((triplet >>> 6*(3-j)) & 0x3F);
-      }
-    }
-    return output;
-  },
-  
-  /*
-   * Convert a raw string to an arbitrary string encoding
-   */
-  rstr2any: function(input, encoding)
-  {
-    var divisor = encoding.length;
-    var remainders = Array();
-    var i, q, x, quotient;
-  
-    /* Convert to an array of 16-bit big-endian values, forming the dividend */
-    var dividend = Array(Math.ceil(input.length / 2));
-    for(i = 0; i < dividend.length; i++)
-    {
-      dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
-    }
-  
-    /*
-     * Repeatedly perform a long division. The binary array forms the dividend,
-     * the length of the encoding is the divisor. Once computed, the quotient
-     * forms the dividend for the next step. We stop when the dividend is zero.
-     * All remainders are stored for later use.
-     */
-    while(dividend.length > 0)
-    {
-      quotient = Array();
-      x = 0;
-      for(i = 0; i < dividend.length; i++)
-      {
-        x = (x << 16) + dividend[i];
-        q = Math.floor(x / divisor);
-        x -= q * divisor;
-        if(quotient.length > 0 || q > 0)
-          quotient[quotient.length] = q;
-      }
-      remainders[remainders.length] = x;
-      dividend = quotient;
-    }
-  
-    /* Convert the remainders to the output string */
-    var output = "";
-    for(i = remainders.length - 1; i >= 0; i--)
-      output += encoding.charAt(remainders[i]);
-  
-    /* Append leading zero equivalents */
-    var full_length = Math.ceil(input.length * 8 /
-                                      (Math.log(encoding.length) / Math.log(2)))
-    for(i = output.length; i < full_length; i++)
-      output = encoding[0] + output;
-  
-    return output;
-  },
-  
-  /*
-   * Encode a string as utf-8.
-   * For efficiency, this assumes the input is valid utf-16.
-   */
-  str2rstr_utf8: function(input)
-  {
-    var output = "";
-    var i = -1;
-    var x, y;
-  
-    while(++i < input.length)
-    {
-      /* Decode utf-16 surrogate pairs */
-      x = input.charCodeAt(i);
-      y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
-      if(0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF)
-      {
-        x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
-        i++;
-      }
-  
-      /* Encode output as utf-8 */
-      if(x <= 0x7F)
-        output += String.fromCharCode(x);
-      else if(x <= 0x7FF)
-        output += String.fromCharCode(0xC0 | ((x >>> 6 ) & 0x1F),
-                                      0x80 | ( x         & 0x3F));
-      else if(x <= 0xFFFF)
-        output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),
-                                      0x80 | ((x >>> 6 ) & 0x3F),
-                                      0x80 | ( x         & 0x3F));
-      else if(x <= 0x1FFFFF)
-        output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),
-                                      0x80 | ((x >>> 12) & 0x3F),
-                                      0x80 | ((x >>> 6 ) & 0x3F),
-                                      0x80 | ( x         & 0x3F));
-    }
-    return output;
-  }, 
-  
-  /*
-   * Encode a string as utf-16
-   */
-  str2rstr_utf16le: function(input)
-  {
-    var output = "";
-    for(var i = 0; i < input.length; i++)
-      output += String.fromCharCode( input.charCodeAt(i)        & 0xFF,
-                                    (input.charCodeAt(i) >>> 8) & 0xFF);
-    return output;
-  },
-  
-  str2rstr_utf16be: function(input)
-  {
-    var output = "";
-    for(var i = 0; i < input.length; i++)
-      output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF,
-                                     input.charCodeAt(i)        & 0xFF);
-    return output;
-  },
-  
-  /*
-   * Convert a raw string to an array of big-endian words
-   * Characters >255 have their high-byte silently ignored.
-   */
-  rstr2binb: function(input)
-  {
-    var output = Array(input.length >> 2);
-    for(var i = 0; i < output.length; i++)
-      output[i] = 0;
-    for(var i = 0; i < input.length * 8; i += 8)
-      output[i>>5] |= (input.charCodeAt(i / 8) & 0xFF) << (24 - i % 32);
-    return output;
-  },
-  
-  /*
-   * Convert an array of big-endian words to a string
-   */
-  binb2rstr: function(input)
-  {
-    var output = "";
-    for(var i = 0; i < input.length * 32; i += 8)
-      output += String.fromCharCode((input[i>>5] >>> (24 - i % 32)) & 0xFF);
-    return output;
-  },
-  
-  /*
-   * Calculate the SHA-1 of an array of big-endian words, and a bit length
-   */
-  binb_sha1: function(x, len)
-  {
-    /* append padding */
-    x[len >> 5] |= 0x80 << (24 - len % 32);
-    x[((len + 64 >> 9) << 4) + 15] = len;
-  
-    var w = Array(80);
-    var a =  1732584193;
-    var b = -271733879;
-    var c = -1732584194;
-    var d =  271733878;
-    var e = -1009589776;
-    
-    var bit_rol = Sha1.bit_rol
-    var safe_add = Sha1.safe_add
-    var sha1_ft = Sha1.sha1_ft
-    var sha1_kt = Sha1.sha1_kt
-    
-    for(var i = 0; i < x.length; i += 16)
-    {
-      var olda = a;
-      var oldb = b;
-      var oldc = c;
-      var oldd = d;
-      var olde = e;
-  
-      for(var j = 0; j < 80; j++)
-      {
-        if(j < 16) w[j] = x[i + j];
-        else w[j] = bit_rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
-        var t = safe_add(safe_add(bit_rol(a, 5), sha1_ft(j, b, c, d)),
-                         safe_add(safe_add(e, w[j]), sha1_kt(j)));
-        e = d;
-        d = c;
-        c = bit_rol(b, 30);
-        b = a;
-        a = t;
-      }
-  
-      a = safe_add(a, olda);
-      b = safe_add(b, oldb);
-      c = safe_add(c, oldc);
-      d = safe_add(d, oldd);
-      e = safe_add(e, olde);
-    }
-    return Array(a, b, c, d, e);
-  
-  },
-  
-  /*
-   * Perform the appropriate triplet combination function for the current
-   * iteration
-   */
-  sha1_ft: function(t, b, c, d)
-  {
-    if(t < 20) return (b & c) | ((~b) & d);
-    if(t < 40) return b ^ c ^ d;
-    if(t < 60) return (b & c) | (b & d) | (c & d);
-    return b ^ c ^ d;
-  },
-  
-  /*
-   * Determine the appropriate additive constant for the current iteration
-   */
-  sha1_kt: function(t)
-  {
-    return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
-           (t < 60) ? -1894007588 : -899497514;
-  },
-  
-  /*
-   * Add integers, wrapping at 2^32. This uses 16-bit operations internally
-   * to work around bugs in some JS interpreters.
-   */
-  safe_add: function(x, y)
-  {
-    var lsw = (x & 0xFFFF) + (y & 0xFFFF);
-    var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
-    return (msw << 16) | (lsw & 0xFFFF);
-  },
-  
-  /*
-   * Bitwise rotate a 32-bit number to the left.
-   */
-  bit_rol: function(num, cnt)
-  {
-    return (num << cnt) | (num >>> (32 - cnt));
-  }
-}
-
-/*
- * The JavaScript implementation of the Secure Hash Algorithm 1
- *
- *   Copyright (c) 2008  Takanori Ishikawa  <takanori.ishikawa@gmail.com>
- *   All rights reserved.
- *
- *   Redistribution and use in source and binary forms, with or without
- *   modification, are permitted provided that the following conditions
- *   are met:
- * 
- *   1. Redistributions of source code must retain the above copyright
- *      notice, this list of conditions and the following disclaimer.
- *
- *   2. Redistributions in binary form must reproduce the above copyright
- *      notice, this list of conditions and the following disclaimer in the
- *      documentation and/or other materials provided with the distribution.
- *
- *   3. Neither the name of the authors nor the names of its contributors
- *      may be used to endorse or promote products derived from this
- *      software without specific prior written permission.
- *
- *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
- *   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/**
- * This is the javascript file for code which implements
- * the Secure Hash Algorithm 1 as defined in FIPS 180-1 published April 17, 1995.
- *
- *   Author: Takanori Ishikawa <takanori.ishikawa@gmail.com>
- *   Copyright: Takanori Ishikawa 2008
- *   License: BSD License (see above)
- *
- * NOTE:
- *   Only 8-bit string is supported, please use encodeURIComponent() function 
- *   if you want to hash multibyte string.
- *
- * Supported Browsers:
- *   [Win] IE 6, Firefox 2
- *   [Mac] Safari 3, Firefox 2
- *
- * Usage:
- *   var hexdigest = new SHA1("Hello.").hexdigest(); // "9b56d519ccd9e1e5b2a725e186184cdc68de0731"
- *
- * See Also:
- *   FIPS 180-1 - Secure Hash Standard
- *   http://www.itl.nist.gov/fipspubs/fip180-1.htm
- *
- */
-
-var SHA1 = (function(){
-
-  /**
-   * Spec is the BDD style test utilities.
-   */
-  var Spec = {
-    /** Replace the Spec.describe function with empty function if false. */
-    enabled: true,
-    
-    /** Indicates whether object 'a' is "equal to" 'b'. */
-    equals: function(a, b) {
-      if (a instanceof Array && b instanceof Array) {
-        if (a.length != b.length) return false;
-        for (var i = 0; i < a.length; i++) if (!Spec.equals(a[i], b[i])) return false;
-        return true;
-      }
-      if ((a != null && b != null) && (typeof a == "object" && typeof b == "object")) {
-        for (var i in a) if (!Spec.equals(a[i], b[i])) return false;
-        return true;
-      }
-      return (a == b);
-    },
-    
-    /** equivalent to xUint's assert */
-    should: function(expection, message) {
-      Spec.currentIndicator++;
-      if (!expection) {
-        var warning = [
-          "[Spec failed",
-          Spec.currentTitle ? " (" + Spec.currentTitle + ")] " : "] ",
-          (message || (Spec.currentMessage + " " + Spec.currentIndicator) || "")
-        ].join("");
-        
-        alert(warning);
-        throw warning;
-      }
-      return !!expection;
-    },
-    
-    /** Write your specification by using describe method. */
-    describe: function(title, spec) {
-      Spec.currentTitle = title;
-      for (var name in spec) {
-        Spec.currentMessage = name;
-        Spec.currentIndicator = 0;
-        spec[name]();
-        Spec.currentIndicator = null;
-      }
-      Spec.currentMessage = Spec.currentTitle = null;
-    },
-    Version: "0.1"
-  };
-  
-  // Other BDD style stuffs.
-  Spec.should.equal = function(a, b, message) { return Spec.should(Spec.equals(a, b), message); };
-  Spec.should.not = function(a, message) { return Spec.should(!a, message); };
-  Spec.should.not.equal = function(a, b, message) { return Spec.should(!Spec.equals(a, b), message); };
-  if (!Spec.enabled) Spec.describe = function(){};
-  
-  
-  // self test
-  Spec.describe("Spec object", {
-    "should": function() {
-      Spec.should(true);
-      Spec.should(1);
-    }, 
-    "should.not": function() {
-      Spec.should.not(false);
-      Spec.should.not(0);
-    },
-    "should.equal": function() {
-      Spec.should.equal(null, null);
-      Spec.should.equal("", "");
-      Spec.should.equal(12345, 12345);
-      Spec.should.equal([0,1,2], [0,1,2]);
-      Spec.should.equal([0,1,[0,1,2]], [0,1,[0,1,2]]);
-      Spec.should.equal({}, {});
-      Spec.should.equal({x:1}, {x:1});
-      Spec.should.equal({x:[1]}, {x:[1]});
-    },
-    "should.not.equal": function() {
-      Spec.should.not.equal([1,2,3], [1,2,3,4]);
-      Spec.should.not.equal({x:1}, [1,2,3,4]);
-    }
-  });
-
-
-  // -----------------------------------------------------------
-  // Utilities
-  // -----------------------------------------------------------
-  // int32 -> hexdigits string (e.g. 0x123 -> '00000123')
-  function strfhex32(i32) {
-    i32 &= 0xffffffff;
-    if (i32 < 0) i32 += 0x100000000;
-    var hex = Number(i32).toString(16);
-    if (hex.length < 8) hex = "00000000".substr(0, 8 - hex.length) + hex;
-    return hex;
-  }
-  Spec.describe("sha1", {
-    "strfhex32": function() {
-      Spec.should.equal(strfhex32(0x0),          "00000000");
-      Spec.should.equal(strfhex32(0x123),        "00000123");
-      Spec.should.equal(strfhex32(0xffffffff),   "ffffffff");
-    }
-  });
-
-  // int32 -> string (e.g. 123 -> '00000000 00000000 00000000 01111011')
-  function strfbits(i32) {
-    if (typeof arguments.callee.ZERO32 == 'undefined') {
-      arguments.callee.ZERO32 = new Array(33).join("0");
-    }
-    
-    var bits = Number(i32).toString(2);
-    // '0' padding 
-    if (bits.length < 32) bits = arguments.callee.ZERO32.substr(0, 32 - bits.length) + bits;
-    // split by 8 bits
-    return bits.replace(/(\d{8})/g, '$1 ')
-               .replace(/^\s*(.*?)\s*$/, '$1');
-  }
-  Spec.describe("sha1", {
-    "strfbits": function() {
-      Spec.should.equal(strfbits(0),   "00000000 00000000 00000000 00000000");
-      Spec.should.equal(strfbits(1),   "00000000 00000000 00000000 00000001");
-      Spec.should.equal(strfbits(123), "00000000 00000000 00000000 01111011");
-    }
-  });
-
-
-  // -----------------------------------------------------------
-  // SHA-1
-  // -----------------------------------------------------------
-  // Returns Number(32bit unsigned integer) array size to fit for blocks (512-bit strings)
-  function padding_size(nbits) {
-    var n = nbits + 1 + 64
-    return 512 * Math.ceil(n / 512) / 32;
-  }
-  Spec.describe("sha1", {
-    "padding_size": function() {
-      Spec.should.equal(padding_size(0),             16);
-      Spec.should.equal(padding_size(1),             16);
-      Spec.should.equal(padding_size(512 - 64 - 1),  16);
-      Spec.should.equal(padding_size(512 - 64),      32);
-    }
-  });
-
-  // 8bit string -> uint32[]
-  function word_array(m) {
-    var nchar = m.length;
-    var size = padding_size(nchar * 8);
-    var words = new Array(size);
-    for (var i = 0, j = 0; i < nchar; ) {
-      words[j++] = ((m.charCodeAt(i++) & 0xff) << 24) | 
-                   ((m.charCodeAt(i++) & 0xff) << 16) | 
-                   ((m.charCodeAt(i++) & 0xff) << 8)  | 
-                   ((m.charCodeAt(i++) & 0xff))
-    }
-    while (j < size) words[j++] = 0;
-    return words;
-  }
-  Spec.describe("sha1", {
-    "word_array": function() {
-      Spec.should.equal(word_array(""), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
-      Spec.should.equal(word_array("1234")[0], 0x31323334);
-    }
-  });
-
-  function write_nbits(words, length, nbits) {
-    if (nbits > 0xffffffff) {
-      var lo = nbits & 0xffffffff;
-      if (lo < 0) lo += 0x100000000;
-      words[length - 1] = lo;
-      words[length - 2] = (nbits - lo) / 0x100000000;
-    } else {
-      words[length - 1] = nbits;
-      words[length - 2] = 0x0;
-    }
-    return words;
-  }
-  Spec.describe("sha1", {
-    "write_nbits": function() {
-      Spec.should.equal(write_nbits([0, 0], 2, 1),             [0, 1]);
-      Spec.should.equal(write_nbits([0, 0], 2, 0xffffffff),    [0, 0xffffffff]);
-      Spec.should.equal(write_nbits([0, 0], 2, 0x100000000),   [1, 0]);
-      Spec.should.equal(write_nbits([0, 0], 2, 0x1ffffffff),   [1, 0xffffffff]);
-      Spec.should.equal(write_nbits([0, 0], 2, 0x12300000000), [0x123, 0]);
-      Spec.should.equal(write_nbits([0, 0], 2, 0x123abcdef12), [0x123, 0xabcdef12]);
-    }
-  });
-
-  function padding(words, nbits) {
-    var i = Math.floor(nbits / 32);
-    
-    words[i] |= (1 << (((i + 1) * 32) - nbits - 1));
-    write_nbits(words, padding_size(nbits), nbits);
-    return words;
-  }
-
-  function digest(words) {
-    var i = 0, t = 0;
-    var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
-    
-    while (i < words.length) {
-      var W = new Array(80);
-      
-      // (a)
-      for (t = 0;  t < 16; t++) W[t] = words[i++];
-      
-      // (b)
-      for (t = 16; t < 80; t++) {
-        var w = W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16];
-        W[t] = (w << 1) | (w >>> 31);
-      }
-      
-      // (c)
-      var A = H[0], B = H[1], C = H[2], D = H[3], E = H[4];
-      
-      // (d) TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt;
-      //     E = D; D = C; C = S30(B); B = A; A = TEMP;
-      for (t = 0; t < 80; t++) {
-        var tmp = ((A << 5) | (A >>> 27)) + E + W[t];
-        
-        if      (t >=  0 && t <= 19) tmp += ((B & C) | ((~B) & D))        + 0x5a827999;
-        else if (t >= 20 && t <= 39) tmp += (B ^ C ^ D)                   + 0x6ed9eba1;
-        else if (t >= 40 && t <= 59) tmp += ((B & C) | (B & D) | (C & D)) + 0x8f1bbcdc;
-        else if (t >= 60 && t <= 79) tmp += (B ^ C ^ D)                   + 0xca62c1d6;
-        
-        E = D; D = C; C = ((B << 30) | (B >>> 2)); B = A; A = tmp;
-      }
-      
-      // (e) H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
-      H[0] = (H[0] + A) & 0xffffffff;
-      H[1] = (H[1] + B) & 0xffffffff;
-      H[2] = (H[2] + C) & 0xffffffff;
-      H[3] = (H[3] + D) & 0xffffffff;
-      H[4] = (H[4] + E) & 0xffffffff;
-      if (H[0] < 0) H[0] += 0x100000000;
-      if (H[1] < 0) H[1] += 0x100000000;
-      if (H[2] < 0) H[2] += 0x100000000;
-      if (H[3] < 0) H[3] += 0x100000000;
-      if (H[4] < 0) H[4] += 0x100000000;
-    }
-    
-    return H;
-  }
-
-  // message: 8bit string
-  var SHA1 = function(message) {
-    this.message = message;
-  }
-
-  SHA1.prototype = {
-    digest: function() {
-      var nbits = this.message.length * 8;
-      var words = padding(word_array(this.message), nbits);
-      return digest(words);
-    },
-
-    hexdigest: function() {
-      var digest = this.digest();
-      for (var i = 0; i < digest.length; i++) digest[i] = strfhex32(digest[i]);
-      return digest.join("");
-    }
-  };
-  
-  Spec.describe("sha1", {
-    "SHA1#hexdigest": function() {
-      Spec.should.equal(new SHA1("").hexdigest(),       "da39a3ee5e6b4b0d3255bfef95601890afd80709");
-      Spec.should.equal(new SHA1("1").hexdigest(),      "356a192b7913b04c54574d18c28d46e6395428ab");
-      Spec.should.equal(new SHA1("Hello.").hexdigest(), "9b56d519ccd9e1e5b2a725e186184cdc68de0731");
-      Spec.should.equal(new SHA1("9b56d519ccd9e1e5b2a725e186184cdc68de0731").hexdigest(), "f042dc98a62cbad68dbe21f11bbc1e9d416d2bf6");
-      Spec.should.equal(new SHA1("MD5abZRVSXZVRcasdfasdddddddddddddddds+BNRJFSLKJFN+SEONBBJFJXLKCJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wurJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wurJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wurJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wuraddddddasdfasdfd").hexdigest(), "662dbf4ebc9cdb4224766e87634e5ba9e6de672b");
-    }
-  });
-  
-  return SHA1;
-})();
-
-// Underscore.js 1.1.3
-// (c) 2010 Jeremy Ashkenas, DocumentCloud Inc.
-// Underscore is freely distributable under the MIT license.
-// Portions of Underscore are inspired or borrowed from Prototype,
-// Oliver Steele's Functional, and John Resig's Micro-Templating.
-// For all details and documentation:
-// http://documentcloud.github.com/underscore
-(function(){var p=this,C=p._,m={},j=Array.prototype,n=Object.prototype,i=j.slice,D=j.unshift,E=n.toString,q=n.hasOwnProperty,s=j.forEach,t=j.map,u=j.reduce,v=j.reduceRight,w=j.filter,x=j.every,y=j.some,o=j.indexOf,z=j.lastIndexOf;n=Array.isArray;var F=Object.keys,c=function(a){return new l(a)};if(typeof module!=="undefined"&&module.exports){module.exports=c;c._=c}else p._=c;c.VERSION="1.1.3";var k=c.each=c.forEach=function(a,b,d){if(s&&a.forEach===s)a.forEach(b,d);else if(c.isNumber(a.length))for(var e=
-0,f=a.length;e<f;e++){if(b.call(d,a[e],e,a)===m)break}else for(e in a)if(q.call(a,e))if(b.call(d,a[e],e,a)===m)break};c.map=function(a,b,d){if(t&&a.map===t)return a.map(b,d);var e=[];k(a,function(f,g,h){e[e.length]=b.call(d,f,g,h)});return e};c.reduce=c.foldl=c.inject=function(a,b,d,e){var f=d!==void 0;if(u&&a.reduce===u){if(e)b=c.bind(b,e);return f?a.reduce(b,d):a.reduce(b)}k(a,function(g,h,G){d=!f&&h===0?g:b.call(e,d,g,h,G)});return d};c.reduceRight=c.foldr=function(a,b,d,e){if(v&&a.reduceRight===
-v){if(e)b=c.bind(b,e);return d!==void 0?a.reduceRight(b,d):a.reduceRight(b)}a=(c.isArray(a)?a.slice():c.toArray(a)).reverse();return c.reduce(a,b,d,e)};c.find=c.detect=function(a,b,d){var e;A(a,function(f,g,h){if(b.call(d,f,g,h)){e=f;return true}});return e};c.filter=c.select=function(a,b,d){if(w&&a.filter===w)return a.filter(b,d);var e=[];k(a,function(f,g,h){if(b.call(d,f,g,h))e[e.length]=f});return e};c.reject=function(a,b,d){var e=[];k(a,function(f,g,h){b.call(d,f,g,h)||(e[e.length]=f)});return e};
-c.every=c.all=function(a,b,d){b=b||c.identity;if(x&&a.every===x)return a.every(b,d);var e=true;k(a,function(f,g,h){if(!(e=e&&b.call(d,f,g,h)))return m});return e};var A=c.some=c.any=function(a,b,d){b=b||c.identity;if(y&&a.some===y)return a.some(b,d);var e=false;k(a,function(f,g,h){if(e=b.call(d,f,g,h))return m});return e};c.include=c.contains=function(a,b){if(o&&a.indexOf===o)return a.indexOf(b)!=-1;var d=false;A(a,function(e){if(d=e===b)return true});return d};c.invoke=function(a,b){var d=i.call(arguments,
-2);return c.map(a,function(e){return(b?e[b]:e).apply(e,d)})};c.pluck=function(a,b){return c.map(a,function(d){return d[b]})};c.max=function(a,b,d){if(!b&&c.isArray(a))return Math.max.apply(Math,a);var e={computed:-Infinity};k(a,function(f,g,h){g=b?b.call(d,f,g,h):f;g>=e.computed&&(e={value:f,computed:g})});return e.value};c.min=function(a,b,d){if(!b&&c.isArray(a))return Math.min.apply(Math,a);var e={computed:Infinity};k(a,function(f,g,h){g=b?b.call(d,f,g,h):f;g<e.computed&&(e={value:f,computed:g})});
-return e.value};c.sortBy=function(a,b,d){return c.pluck(c.map(a,function(e,f,g){return{value:e,criteria:b.call(d,e,f,g)}}).sort(function(e,f){var g=e.criteria,h=f.criteria;return g<h?-1:g>h?1:0}),"value")};c.sortedIndex=function(a,b,d){d=d||c.identity;for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(b)?e=g+1:f=g}return e};c.toArray=function(a){if(!a)return[];if(a.toArray)return a.toArray();if(c.isArray(a))return a;if(c.isArguments(a))return i.call(a);return c.values(a)};c.size=function(a){return c.toArray(a).length};
-c.first=c.head=function(a,b,d){return b&&!d?i.call(a,0,b):a[0]};c.rest=c.tail=function(a,b,d){return i.call(a,c.isUndefined(b)||d?1:b)};c.last=function(a){return a[a.length-1]};c.compact=function(a){return c.filter(a,function(b){return!!b})};c.flatten=function(a){return c.reduce(a,function(b,d){if(c.isArray(d))return b.concat(c.flatten(d));b[b.length]=d;return b},[])};c.without=function(a){var b=i.call(arguments,1);return c.filter(a,function(d){return!c.include(b,d)})};c.uniq=c.unique=function(a,
-b){return c.reduce(a,function(d,e,f){if(0==f||(b===true?c.last(d)!=e:!c.include(d,e)))d[d.length]=e;return d},[])};c.intersect=function(a){var b=i.call(arguments,1);return c.filter(c.uniq(a),function(d){return c.every(b,function(e){return c.indexOf(e,d)>=0})})};c.zip=function(){for(var a=i.call(arguments),b=c.max(c.pluck(a,"length")),d=Array(b),e=0;e<b;e++)d[e]=c.pluck(a,""+e);return d};c.indexOf=function(a,b){if(o&&a.indexOf===o)return a.indexOf(b);for(var d=0,e=a.length;d<e;d++)if(a[d]===b)return d;
-return-1};c.lastIndexOf=function(a,b){if(z&&a.lastIndexOf===z)return a.lastIndexOf(b);for(var d=a.length;d--;)if(a[d]===b)return d;return-1};c.range=function(a,b,d){var e=i.call(arguments),f=e.length<=1;a=f?0:e[0];b=f?e[0]:e[1];d=e[2]||1;e=Math.max(Math.ceil((b-a)/d),0);f=0;for(var g=Array(e);f<e;){g[f++]=a;a+=d}return g};c.bind=function(a,b){var d=i.call(arguments,2);return function(){return a.apply(b||{},d.concat(i.call(arguments)))}};c.bindAll=function(a){var b=i.call(arguments,1);if(b.length==
-0)b=c.functions(a);k(b,function(d){a[d]=c.bind(a[d],a)});return a};c.memoize=function(a,b){var d={};b=b||c.identity;return function(){var e=b.apply(this,arguments);return e in d?d[e]:d[e]=a.apply(this,arguments)}};c.delay=function(a,b){var d=i.call(arguments,2);return setTimeout(function(){return a.apply(a,d)},b)};c.defer=function(a){return c.delay.apply(c,[a,1].concat(i.call(arguments,1)))};var B=function(a,b,d){var e;return function(){var f=this,g=arguments,h=function(){e=null;a.apply(f,g)};d&&
-clearTimeout(e);if(d||!e)e=setTimeout(h,b)}};c.throttle=function(a,b){return B(a,b,false)};c.debounce=function(a,b){return B(a,b,true)};c.wrap=function(a,b){return function(){var d=[a].concat(i.call(arguments));return b.apply(b,d)}};c.compose=function(){var a=i.call(arguments);return function(){for(var b=i.call(arguments),d=a.length-1;d>=0;d--)b=[a[d].apply(this,b)];return b[0]}};c.keys=F||function(a){if(c.isArray(a))return c.range(0,a.length);var b=[],d;for(d in a)if(q.call(a,d))b[b.length]=d;return b};
-c.values=function(a){return c.map(a,c.identity)};c.functions=c.methods=function(a){return c.filter(c.keys(a),function(b){return c.isFunction(a[b])}).sort()};c.extend=function(a){k(i.call(arguments,1),function(b){for(var d in b)a[d]=b[d]});return a};c.clone=function(a){return c.isArray(a)?a.slice():c.extend({},a)};c.tap=function(a,b){b(a);return a};c.isEqual=function(a,b){if(a===b)return true;var d=typeof a;if(d!=typeof b)return false;if(a==b)return true;if(!a&&b||a&&!b)return false;if(a.isEqual)return a.isEqual(b);
-if(c.isDate(a)&&c.isDate(b))return a.getTime()===b.getTime();if(c.isNaN(a)&&c.isNaN(b))return false;if(c.isRegExp(a)&&c.isRegExp(b))return a.source===b.source&&a.global===b.global&&a.ignoreCase===b.ignoreCase&&a.multiline===b.multiline;if(d!=="object")return false;if(a.length&&a.length!==b.length)return false;d=c.keys(a);var e=c.keys(b);if(d.length!=e.length)return false;for(var f in a)if(!(f in b)||!c.isEqual(a[f],b[f]))return false;return true};c.isEmpty=function(a){if(c.isArray(a)||c.isString(a))return a.length===
-0;for(var b in a)if(q.call(a,b))return false;return true};c.isElement=function(a){return!!(a&&a.nodeType==1)};c.isArray=n||function(a){return!!(a&&a.concat&&a.unshift&&!a.callee)};c.isArguments=function(a){return!!(a&&a.callee)};c.isFunction=function(a){return!!(a&&a.constructor&&a.call&&a.apply)};c.isString=function(a){return!!(a===""||a&&a.charCodeAt&&a.substr)};c.isNumber=function(a){return!!(a===0||a&&a.toExponential&&a.toFixed)};c.isNaN=function(a){return E.call(a)==="[object Number]"&&isNaN(a)};
-c.isBoolean=function(a){return a===true||a===false};c.isDate=function(a){return!!(a&&a.getTimezoneOffset&&a.setUTCFullYear)};c.isRegExp=function(a){return!!(a&&a.test&&a.exec&&(a.ignoreCase||a.ignoreCase===false))};c.isNull=function(a){return a===null};c.isUndefined=function(a){return a===void 0};c.noConflict=function(){p._=C;return this};c.identity=function(a){return a};c.times=function(a,b,d){for(var e=0;e<a;e++)b.call(d,e)};c.mixin=function(a){k(c.functions(a),function(b){H(b,c[b]=a[b])})};var I=
-0;c.uniqueId=function(a){var b=I++;return a?a+b:b};c.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g};c.template=function(a,b){var d=c.templateSettings;d="var __p=[],print=function(){__p.push.apply(__p,arguments);};with(obj||{}){__p.push('"+a.replace(/\\/g,"\\\\").replace(/'/g,"\\'").replace(d.interpolate,function(e,f){return"',"+f.replace(/\\'/g,"'")+",'"}).replace(d.evaluate||null,function(e,f){return"');"+f.replace(/\\'/g,"'").replace(/[\r\n\t]/g," ")+"__p.push('"}).replace(/\r/g,
-"\\r").replace(/\n/g,"\\n").replace(/\t/g,"\\t")+"');}return __p.join('');";d=new Function("obj",d);return b?d(b):d};var l=function(a){this._wrapped=a};c.prototype=l.prototype;var r=function(a,b){return b?c(a).chain():a},H=function(a,b){l.prototype[a]=function(){var d=i.call(arguments);D.call(d,this._wrapped);return r(b.apply(c,d),this._chain)}};c.mixin(c);k(["pop","push","reverse","shift","sort","splice","unshift"],function(a){var b=j[a];l.prototype[a]=function(){b.apply(this._wrapped,arguments);
-return r(this._wrapped,this._chain)}});k(["concat","join","slice"],function(a){var b=j[a];l.prototype[a]=function(){return r(b.apply(this._wrapped,arguments),this._chain)}});l.prototype.chain=function(){this._chain=true;return this};l.prototype.value=function(){return this._wrapped}})();
-
-
-/*
- * $Id: rawinflate.js,v 0.2 2009/03/01 18:32:24 dankogai Exp $
- *
- * original:
- * http://www.onicos.com/staff/iz/amuse/javascript/expert/inflate.txt
- */
-
-(function(){
-
-/* Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
- * Version: 1.0.0.1
- * LastModified: Dec 25 1999
- */
-
-/* Interface:
- * data = zip_inflate(src);
- */
-
-/* constant parameters */
-var zip_WSIZE = 32768;		// Sliding Window size
-var zip_STORED_BLOCK = 0;
-var zip_STATIC_TREES = 1;
-var zip_DYN_TREES    = 2;
-
-/* for inflate */
-var zip_lbits = 9; 		// bits in base literal/length lookup table
-var zip_dbits = 6; 		// bits in base distance lookup table
-var zip_INBUFSIZ = 32768;	// Input buffer size
-var zip_INBUF_EXTRA = 64;	// Extra buffer
-
-/* variables (inflate) */
-var zip_slide;
-var zip_wp;			// current position in slide
-var zip_fixed_tl = null;	// inflate static
-var zip_fixed_td;		// inflate static
-var zip_fixed_bl, fixed_bd;	// inflate static
-var zip_bit_buf;		// bit buffer
-var zip_bit_len;		// bits in bit buffer
-var zip_method;
-var zip_eof;
-var zip_copy_leng;
-var zip_copy_dist;
-var zip_tl, zip_td;	// literal/length and distance decoder tables
-var zip_bl, zip_bd;	// number of bits decoded by tl and td
-
-var zip_inflate_data;
-var zip_inflate_pos;
-
-
-/* constant tables (inflate) */
-var zip_MASK_BITS = new Array(
-    0x0000,
-    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
-    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff);
-// Tables for deflate from PKZIP's appnote.txt.
-var zip_cplens = new Array( // Copy lengths for literal codes 257..285
-    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
-    35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0);
-/* note: see note #13 above about the 258 in this list. */
-var zip_cplext = new Array( // Extra bits for literal codes 257..285
-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
-    3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99); // 99==invalid
-var zip_cpdist = new Array( // Copy offsets for distance codes 0..29
-    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
-    257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
-    8193, 12289, 16385, 24577);
-var zip_cpdext = new Array( // Extra bits for distance codes
-    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
-    7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
-    12, 12, 13, 13);
-var zip_border = new Array(  // Order of the bit length code lengths
-    16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15);
-/* objects (inflate) */
-
-var zip_HuftList = function() {
-    this.next = null;
-    this.list = null;
-}
-
-var zip_HuftNode = function() {
-    this.e = 0; // number of extra bits or operation
-    this.b = 0; // number of bits in this code or subcode
-
-    // union
-    this.n = 0; // literal, length base, or distance base
-    this.t = null; // (zip_HuftNode) pointer to next level of table
-}
-
-var zip_HuftBuild = function(b,	// code lengths in bits (all assumed <= BMAX)
-		       n,	// number of codes (assumed <= N_MAX)
-		       s,	// number of simple-valued codes (0..s-1)
-		       d,	// list of base values for non-simple codes
-		       e,	// list of extra bits for non-simple codes
-		       mm	// maximum lookup bits
-		   ) {
-    this.BMAX = 16;   // maximum bit length of any code
-    this.N_MAX = 288; // maximum number of codes in any set
-    this.status = 0;	// 0: success, 1: incomplete table, 2: bad input
-    this.root = null;	// (zip_HuftList) starting table
-    this.m = 0;		// maximum lookup bits, returns actual
-
-/* Given a list of code lengths and a maximum table size, make a set of
-   tables to decode that set of codes.	Return zero on success, one if
-   the given code set is incomplete (the tables are still built in this
-   case), two if the input is invalid (all zero length codes or an
-   oversubscribed set of lengths), and three if not enough memory.
-   The code with value 256 is special, and the tables are constructed
-   so that no bits beyond that code are fetched when that code is
-   decoded. */
-    {
-	var a;			// counter for codes of length k
-	var c = new Array(this.BMAX+1);	// bit length count table
-	var el;			// length of EOB code (value 256)
-	var f;			// i repeats in table every f entries
-	var g;			// maximum code length
-	var h;			// table level
-	var i;			// counter, current code
-	var j;			// counter
-	var k;			// number of bits in current code
-	var lx = new Array(this.BMAX+1);	// stack of bits per table
-	var p;			// pointer into c[], b[], or v[]
-	var pidx;		// index of p
-	var q;			// (zip_HuftNode) points to current table
-	var r = new zip_HuftNode(); // table entry for structure assignment
-	var u = new Array(this.BMAX); // zip_HuftNode[BMAX][]  table stack
-	var v = new Array(this.N_MAX); // values in order of bit length
-	var w;
-	var x = new Array(this.BMAX+1);// bit offsets, then code stack
-	var xp;			// pointer into x or c
-	var y;			// number of dummy codes added
-	var z;			// number of entries in current table
-	var o;
-	var tail;		// (zip_HuftList)
-
-	tail = this.root = null;
-	for(i = 0; i < c.length; i++)
-	    c[i] = 0;
-	for(i = 0; i < lx.length; i++)
-	    lx[i] = 0;
-	for(i = 0; i < u.length; i++)
-	    u[i] = null;
-	for(i = 0; i < v.length; i++)
-	    v[i] = 0;
-	for(i = 0; i < x.length; i++)
-	    x[i] = 0;
-
-	// Generate counts for each bit length
-	el = n > 256 ? b[256] : this.BMAX; // set length of EOB code, if any
-	p = b; pidx = 0;
-	i = n;
-	do {
-	    c[p[pidx]]++;	// assume all entries <= BMAX
-	    pidx++;
-	} while(--i > 0);
-	if(c[0] == n) {	// null input--all zero length codes
-	    this.root = null;
-	    this.m = 0;
-	    this.status = 0;
-	    return;
-	}
-
-	// Find minimum and maximum length, bound *m by those
-	for(j = 1; j <= this.BMAX; j++)
-	    if(c[j] != 0)
-		break;
-	k = j;			// minimum code length
-	if(mm < j)
-	    mm = j;
-	for(i = this.BMAX; i != 0; i--)
-	    if(c[i] != 0)
-		break;
-	g = i;			// maximum code length
-	if(mm > i)
-	    mm = i;
-
-	// Adjust last length count to fill out codes, if needed
-	for(y = 1 << j; j < i; j++, y <<= 1)
-	    if((y -= c[j]) < 0) {
-		this.status = 2;	// bad input: more codes than bits
-		this.m = mm;
-		return;
-	    }
-	if((y -= c[i]) < 0) {
-	    this.status = 2;
-	    this.m = mm;
-	    return;
-	}
-	c[i] += y;
-
-	// Generate starting offsets into the value table for each length
-	x[1] = j = 0;
-	p = c;
-	pidx = 1;
-	xp = 2;
-	while(--i > 0)		// note that i == g from above
-	    x[xp++] = (j += p[pidx++]);
-
-	// Make a table of values in order of bit lengths
-	p = b; pidx = 0;
-	i = 0;
-	do {
-	    if((j = p[pidx++]) != 0)
-		v[x[j]++] = i;
-	} while(++i < n);
-	n = x[g];			// set n to length of v
-
-	// Generate the Huffman codes and for each, make the table entries
-	x[0] = i = 0;		// first Huffman code is zero
-	p = v; pidx = 0;		// grab values in bit order
-	h = -1;			// no tables yet--level -1
-	w = lx[0] = 0;		// no bits decoded yet
-	q = null;			// ditto
-	z = 0;			// ditto
-
-	// go through the bit lengths (k already is bits in shortest code)
-	for(; k <= g; k++) {
-	    a = c[k];
-	    while(a-- > 0) {
-		// here i is the Huffman code of length k bits for value p[pidx]
-		// make tables up to required level
-		while(k > w + lx[1 + h]) {
-		    w += lx[1 + h]; // add bits already decoded
-		    h++;
-
-		    // compute minimum size table less than or equal to *m bits
-		    z = (z = g - w) > mm ? mm : z; // upper limit
-		    if((f = 1 << (j = k - w)) > a + 1) { // try a k-w bit table
-			// too few codes for k-w bit table
-			f -= a + 1;	// deduct codes from patterns left
-			xp = k;
-			while(++j < z) { // try smaller tables up to z bits
-			    if((f <<= 1) <= c[++xp])
-				break;	// enough codes to use up j bits
-			    f -= c[xp];	// else deduct codes from patterns
-			}
-		    }
-		    if(w + j > el && w < el)
-			j = el - w;	// make EOB code end at table
-		    z = 1 << j;	// table entries for j-bit table
-		    lx[1 + h] = j; // set table size in stack
-
-		    // allocate and link in new table
-		    q = new Array(z);
-		    for(o = 0; o < z; o++) {
-			q[o] = new zip_HuftNode();
-		    }
-
-		    if(tail == null)
-			tail = this.root = new zip_HuftList();
-		    else
-			tail = tail.next = new zip_HuftList();
-		    tail.next = null;
-		    tail.list = q;
-		    u[h] = q;	// table starts after link
-
-		    /* connect to last table, if there is one */
-		    if(h > 0) {
-			x[h] = i;		// save pattern for backing up
-			r.b = lx[h];	// bits to dump before this table
-			r.e = 16 + j;	// bits in this table
-			r.t = q;		// pointer to this table
-			j = (i & ((1 << w) - 1)) >> (w - lx[h]);
-			u[h-1][j].e = r.e;
-			u[h-1][j].b = r.b;
-			u[h-1][j].n = r.n;
-			u[h-1][j].t = r.t;
-		    }
-		}
-
-		// set up table entry in r
-		r.b = k - w;
-		if(pidx >= n)
-		    r.e = 99;		// out of values--invalid code
-		else if(p[pidx] < s) {
-		    r.e = (p[pidx] < 256 ? 16 : 15); // 256 is end-of-block code
-		    r.n = p[pidx++];	// simple code is just the value
-		} else {
-		    r.e = e[p[pidx] - s];	// non-simple--look up in lists
-		    r.n = d[p[pidx++] - s];
-		}
-
-		// fill code-like entries with r //
-		f = 1 << (k - w);
-		for(j = i >> w; j < z; j += f) {
-		    q[j].e = r.e;
-		    q[j].b = r.b;
-		    q[j].n = r.n;
-		    q[j].t = r.t;
-		}
-
-		// backwards increment the k-bit code i
-		for(j = 1 << (k - 1); (i & j) != 0; j >>= 1)
-		    i ^= j;
-		i ^= j;
-
-		// backup over finished tables
-		while((i & ((1 << w) - 1)) != x[h]) {
-		    w -= lx[h];		// don't need to update q
-		    h--;
-		}
-	    }
-	}
-
-	/* return actual size of base table */
-	this.m = lx[1];
-
-	/* Return true (1) if we were given an incomplete table */
-	this.status = ((y != 0 && g != 1) ? 1 : 0);
-    } /* end of constructor */
-}
-
-
-/* routines (inflate) */
-
-var zip_GET_BYTE = function() {
-    if(zip_inflate_data.length == zip_inflate_pos)
-	return -1;
-    return zip_inflate_data.charCodeAt(zip_inflate_pos++) & 0xff;
-}
-
-var zip_NEEDBITS = function(n) {
-    while(zip_bit_len < n) {
-	zip_bit_buf |= zip_GET_BYTE() << zip_bit_len;
-	zip_bit_len += 8;
-    }
-}
-
-var zip_GETBITS = function(n) {
-    return zip_bit_buf & zip_MASK_BITS[n];
-}
-
-var zip_DUMPBITS = function(n) {
-    zip_bit_buf >>= n;
-    zip_bit_len -= n;
-}
-
-var zip_inflate_codes = function(buff, off, size) {
-    /* inflate (decompress) the codes in a deflated (compressed) block.
-       Return an error code or zero if it all goes ok. */
-    var e;		// table entry flag/number of extra bits
-    var t;		// (zip_HuftNode) pointer to table entry
-    var n;
-
-    if(size == 0)
-      return 0;
-
-    // inflate the coded data
-    n = 0;
-    for(;;) {			// do until end of block
-	zip_NEEDBITS(zip_bl);
-	t = zip_tl.list[zip_GETBITS(zip_bl)];
-	e = t.e;
-	while(e > 16) {
-	    if(e == 99)
-		return -1;
-	    zip_DUMPBITS(t.b);
-	    e -= 16;
-	    zip_NEEDBITS(e);
-	    t = t.t[zip_GETBITS(e)];
-	    e = t.e;
-	}
-	zip_DUMPBITS(t.b);
-
-	if(e == 16) {		// then it's a literal
-	    zip_wp &= zip_WSIZE - 1;
-	    buff[off + n++] = zip_slide[zip_wp++] = t.n;
-	    if(n == size)
-		return size;
-	    continue;
-	}
-
-	// exit if end of block
-	if(e == 15)
-	    break;
-
-	// it's an EOB or a length
-
-	// get length of block to copy
-	zip_NEEDBITS(e);
-	zip_copy_leng = t.n + zip_GETBITS(e);
-	zip_DUMPBITS(e);
-
-	// decode distance of block to copy
-	zip_NEEDBITS(zip_bd);
-	t = zip_td.list[zip_GETBITS(zip_bd)];
-	e = t.e;
-
-	while(e > 16) {
-	    if(e == 99)
-		return -1;
-	    zip_DUMPBITS(t.b);
-	    e -= 16;
-	    zip_NEEDBITS(e);
-	    t = t.t[zip_GETBITS(e)];
-	    e = t.e;
-	}
-	zip_DUMPBITS(t.b);
-	zip_NEEDBITS(e);
-	zip_copy_dist = zip_wp - t.n - zip_GETBITS(e);
-	zip_DUMPBITS(e);
-
-	// do the copy
-	while(zip_copy_leng > 0 && n < size) {
-	    zip_copy_leng--;
-	    zip_copy_dist &= zip_WSIZE - 1;
-	    zip_wp &= zip_WSIZE - 1;
-	    buff[off + n++] = zip_slide[zip_wp++]
-		= zip_slide[zip_copy_dist++];
-	}
-
-	if(n == size)
-	    return size;
-    }
-
-    zip_method = -1; // done
-    return n;
-}
-
-var zip_inflate_stored = function(buff, off, size) {
-    /* "decompress" an inflated type 0 (stored) block. */
-    var n;
-
-    // go to byte boundary
-    n = zip_bit_len & 7;
-    zip_DUMPBITS(n);
-
-    // get the length and its complement
-    zip_NEEDBITS(16);
-    n = zip_GETBITS(16);
-    zip_DUMPBITS(16);
-    zip_NEEDBITS(16);
-    if(n != ((~zip_bit_buf) & 0xffff))
-	return -1;			// error in compressed data
-    zip_DUMPBITS(16);
-
-    // read and output the compressed data
-    zip_copy_leng = n;
-
-    n = 0;
-    while(zip_copy_leng > 0 && n < size) {
-	zip_copy_leng--;
-	zip_wp &= zip_WSIZE - 1;
-	zip_NEEDBITS(8);
-	buff[off + n++] = zip_slide[zip_wp++] =
-	    zip_GETBITS(8);
-	zip_DUMPBITS(8);
-    }
-
-    if(zip_copy_leng == 0)
-      zip_method = -1; // done
-    return n;
-}
-
-var zip_inflate_fixed = function(buff, off, size) {
-    /* decompress an inflated type 1 (fixed Huffman codes) block.  We should
-       either replace this with a custom decoder, or at least precompute the
-       Huffman tables. */
-
-    // if first time, set up tables for fixed blocks
-    if(zip_fixed_tl == null) {
-	var i;			// temporary variable
-	var l = new Array(288);	// length list for huft_build
-	var h;	// zip_HuftBuild
-
-	// literal table
-	for(i = 0; i < 144; i++)
-	    l[i] = 8;
-	for(; i < 256; i++)
-	    l[i] = 9;
-	for(; i < 280; i++)
-	    l[i] = 7;
-	for(; i < 288; i++)	// make a complete, but wrong code set
-	    l[i] = 8;
-	zip_fixed_bl = 7;
-
-	h = new zip_HuftBuild(l, 288, 257, zip_cplens, zip_cplext,
-			      zip_fixed_bl);
-	if(h.status != 0) {
-	    alert("HufBuild error: "+h.status);
-	    return -1;
-	}
-	zip_fixed_tl = h.root;
-	zip_fixed_bl = h.m;
-
-	// distance table
-	for(i = 0; i < 30; i++)	// make an incomplete code set
-	    l[i] = 5;
-	zip_fixed_bd = 5;
-
-	h = new zip_HuftBuild(l, 30, 0, zip_cpdist, zip_cpdext, zip_fixed_bd);
-	if(h.status > 1) {
-	    zip_fixed_tl = null;
-	    alert("HufBuild error: "+h.status);
-	    return -1;
-	}
-	zip_fixed_td = h.root;
-	zip_fixed_bd = h.m;
-    }
-
-    zip_tl = zip_fixed_tl;
-    zip_td = zip_fixed_td;
-    zip_bl = zip_fixed_bl;
-    zip_bd = zip_fixed_bd;
-    return zip_inflate_codes(buff, off, size);
-}
-
-var zip_inflate_dynamic = function(buff, off, size) {
-    // decompress an inflated type 2 (dynamic Huffman codes) block.
-    var i;		// temporary variables
-    var j;
-    var l;		// last length
-    var n;		// number of lengths to get
-    var t;		// (zip_HuftNode) literal/length code table
-    var nb;		// number of bit length codes
-    var nl;		// number of literal/length codes
-    var nd;		// number of distance codes
-    var ll = new Array(286+30); // literal/length and distance code lengths
-    var h;		// (zip_HuftBuild)
-
-    for(i = 0; i < ll.length; i++)
-	ll[i] = 0;
-
-    // read in table lengths
-    zip_NEEDBITS(5);
-    nl = 257 + zip_GETBITS(5);	// number of literal/length codes
-    zip_DUMPBITS(5);
-    zip_NEEDBITS(5);
-    nd = 1 + zip_GETBITS(5);	// number of distance codes
-    zip_DUMPBITS(5);
-    zip_NEEDBITS(4);
-    nb = 4 + zip_GETBITS(4);	// number of bit length codes
-    zip_DUMPBITS(4);
-    if(nl > 286 || nd > 30)
-      return -1;		// bad lengths
-
-    // read in bit-length-code lengths
-    for(j = 0; j < nb; j++)
-    {
-	zip_NEEDBITS(3);
-	ll[zip_border[j]] = zip_GETBITS(3);
-	zip_DUMPBITS(3);
-    }
-    for(; j < 19; j++)
-	ll[zip_border[j]] = 0;
-
-    // build decoding table for trees--single level, 7 bit lookup
-    zip_bl = 7;
-    h = new zip_HuftBuild(ll, 19, 19, null, null, zip_bl);
-    if(h.status != 0)
-	return -1;	// incomplete code set
-
-    zip_tl = h.root;
-    zip_bl = h.m;
-
-    // read in literal and distance code lengths
-    n = nl + nd;
-    i = l = 0;
-    while(i < n) {
-	zip_NEEDBITS(zip_bl);
-	t = zip_tl.list[zip_GETBITS(zip_bl)];
-	j = t.b;
-	zip_DUMPBITS(j);
-	j = t.n;
-	if(j < 16)		// length of code in bits (0..15)
-	    ll[i++] = l = j;	// save last length in l
-	else if(j == 16) {	// repeat last length 3 to 6 times
-	    zip_NEEDBITS(2);
-	    j = 3 + zip_GETBITS(2);
-	    zip_DUMPBITS(2);
-	    if(i + j > n)
-		return -1;
-	    while(j-- > 0)
-		ll[i++] = l;
-	} else if(j == 17) {	// 3 to 10 zero length codes
-	    zip_NEEDBITS(3);
-	    j = 3 + zip_GETBITS(3);
-	    zip_DUMPBITS(3);
-	    if(i + j > n)
-		return -1;
-	    while(j-- > 0)
-		ll[i++] = 0;
-	    l = 0;
-	} else {		// j == 18: 11 to 138 zero length codes
-	    zip_NEEDBITS(7);
-	    j = 11 + zip_GETBITS(7);
-	    zip_DUMPBITS(7);
-	    if(i + j > n)
-		return -1;
-	    while(j-- > 0)
-		ll[i++] = 0;
-	    l = 0;
-	}
-    }
-
-    // build the decoding tables for literal/length and distance codes
-    zip_bl = zip_lbits;
-    h = new zip_HuftBuild(ll, nl, 257, zip_cplens, zip_cplext, zip_bl);
-    if(zip_bl == 0)	// no literals or lengths
-	h.status = 1;
-    if(h.status != 0) {
-	if(h.status == 1)
-	    ;// **incomplete literal tree**
-	return -1;		// incomplete code set
-    }
-    zip_tl = h.root;
-    zip_bl = h.m;
-
-    for(i = 0; i < nd; i++)
-	ll[i] = ll[i + nl];
-    zip_bd = zip_dbits;
-    h = new zip_HuftBuild(ll, nd, 0, zip_cpdist, zip_cpdext, zip_bd);
-    zip_td = h.root;
-    zip_bd = h.m;
-
-    if(zip_bd == 0 && nl > 257) {   // lengths but no distances
-	// **incomplete distance tree**
-	return -1;
-    }
-
-    if(h.status == 1) {
-	;// **incomplete distance tree**
-    }
-    if(h.status != 0)
-	return -1;
-
-    // decompress until an end-of-block code
-    return zip_inflate_codes(buff, off, size);
-}
-
-var zip_inflate_start = function() {
-    var i;
-
-    if(zip_slide == null)
-	zip_slide = new Array(2 * zip_WSIZE);
-    zip_wp = 0;
-    zip_bit_buf = 0;
-    zip_bit_len = 0;
-    zip_method = -1;
-    zip_eof = false;
-    zip_copy_leng = zip_copy_dist = 0;
-    zip_tl = null;
-}
-
-var zip_inflate_internal = function(buff, off, size) {
-    // decompress an inflated entry
-    var n, i;
-
-    n = 0;
-    while(n < size) {
-	if(zip_eof && zip_method == -1)
-	    return n;
-
-	if(zip_copy_leng > 0) {
-	    if(zip_method != zip_STORED_BLOCK) {
-		// STATIC_TREES or DYN_TREES
-		while(zip_copy_leng > 0 && n < size) {
-		    zip_copy_leng--;
-		    zip_copy_dist &= zip_WSIZE - 1;
-		    zip_wp &= zip_WSIZE - 1;
-		    buff[off + n++] = zip_slide[zip_wp++] =
-			zip_slide[zip_copy_dist++];
-		}
-	    } else {
-		while(zip_copy_leng > 0 && n < size) {
-		    zip_copy_leng--;
-		    zip_wp &= zip_WSIZE - 1;
-		    zip_NEEDBITS(8);
-		    buff[off + n++] = zip_slide[zip_wp++] = zip_GETBITS(8);
-		    zip_DUMPBITS(8);
-		}
-		if(zip_copy_leng == 0)
-		    zip_method = -1; // done
-	    }
-	    if(n == size)
-		return n;
-	}
-
-	if(zip_method == -1) {
-	    if(zip_eof)
-		break;
-
-	    // read in last block bit
-	    zip_NEEDBITS(1);
-	    if(zip_GETBITS(1) != 0)
-		zip_eof = true;
-	    zip_DUMPBITS(1);
-
-	    // read in block type
-	    zip_NEEDBITS(2);
-	    zip_method = zip_GETBITS(2);
-	    zip_DUMPBITS(2);
-	    zip_tl = null;
-	    zip_copy_leng = 0;
-	}
-
-	switch(zip_method) {
-	  case 0: // zip_STORED_BLOCK
-	    i = zip_inflate_stored(buff, off + n, size - n);
-	    break;
-
-	  case 1: // zip_STATIC_TREES
-	    if(zip_tl != null)
-		i = zip_inflate_codes(buff, off + n, size - n);
-	    else
-		i = zip_inflate_fixed(buff, off + n, size - n);
-	    break;
-
-	  case 2: // zip_DYN_TREES
-	    if(zip_tl != null)
-		i = zip_inflate_codes(buff, off + n, size - n);
-	    else
-		i = zip_inflate_dynamic(buff, off + n, size - n);
-	    break;
-
-	  default: // error
-	    i = -1;
-	    break;
-	}
-
-	if(i == -1) {
-	    if(zip_eof)
-		return 0;
-	    return -1;
-	}
-	n += i;
-    }
-    return n;
-}
-
-var zip_inflate = function(str) {
-    var i, j;
-
-    zip_inflate_start();
-    zip_inflate_data = str;
-    zip_inflate_pos = 0;
-
-    var buff = new Array(1024);
-    var aout = [];
-    while((i = zip_inflate_internal(buff, 0, buff.length)) > 0) {
-        var cbuf = new Array(i);
-        for(j = 0; j < i; j++) {
-          cbuf[j] = String.fromCharCode(buff[j]);
-        }
-        aout[aout.length] = cbuf.join("");
-    }
-    zip_inflate_data = null; // G.C.
-    var result = new String(aout.join(""));
-    result.compressedLength = zip_inflate_pos;
-    return result;
-}
-
-if (! window.RawDeflate) RawDeflate = {};
-RawDeflate.inflate = zip_inflate;
-
-})();
-
-
-/*
- * $Id: rawdeflate.js,v 0.3 2009/03/01 19:05:05 dankogai Exp dankogai $
- *
- * Original:
- *   http://www.onicos.com/staff/iz/amuse/javascript/expert/deflate.txt
- */
-
-(function(){
-
-/* Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
- * Version: 1.0.1
- * LastModified: Dec 25 1999
- */
-
-/* Interface:
- * data = zip_deflate(src);
- */
-
-/* constant parameters */
-var zip_WSIZE = 32768;		// Sliding Window size
-var zip_STORED_BLOCK = 0;
-var zip_STATIC_TREES = 1;
-var zip_DYN_TREES    = 2;
-
-/* for deflate */
-var zip_DEFAULT_LEVEL = 6;
-var zip_FULL_SEARCH = true;
-var zip_INBUFSIZ = 32768;	// Input buffer size
-var zip_INBUF_EXTRA = 64;	// Extra buffer
-var zip_OUTBUFSIZ = 1024 * 8;
-var zip_window_size = 2 * zip_WSIZE;
-var zip_MIN_MATCH = 3;
-var zip_MAX_MATCH = 258;
-var zip_BITS = 16;
-// for SMALL_MEM
-var zip_LIT_BUFSIZE = 0x2000;
-var zip_HASH_BITS = 13;
-// for MEDIUM_MEM
-// var zip_LIT_BUFSIZE = 0x4000;
-// var zip_HASH_BITS = 14;
-// for BIG_MEM
-// var zip_LIT_BUFSIZE = 0x8000;
-// var zip_HASH_BITS = 15;
-if(zip_LIT_BUFSIZE > zip_INBUFSIZ)
-    alert("error: zip_INBUFSIZ is too small");
-if((zip_WSIZE<<1) > (1<<zip_BITS))
-    alert("error: zip_WSIZE is too large");
-if(zip_HASH_BITS > zip_BITS-1)
-    alert("error: zip_HASH_BITS is too large");
-if(zip_HASH_BITS < 8 || zip_MAX_MATCH != 258)
-    alert("error: Code too clever");
-var zip_DIST_BUFSIZE = zip_LIT_BUFSIZE;
-var zip_HASH_SIZE = 1 << zip_HASH_BITS;
-var zip_HASH_MASK = zip_HASH_SIZE - 1;
-var zip_WMASK = zip_WSIZE - 1;
-var zip_NIL = 0; // Tail of hash chains
-var zip_TOO_FAR = 4096;
-var zip_MIN_LOOKAHEAD = zip_MAX_MATCH + zip_MIN_MATCH + 1;
-var zip_MAX_DIST = zip_WSIZE - zip_MIN_LOOKAHEAD;
-var zip_SMALLEST = 1;
-var zip_MAX_BITS = 15;
-var zip_MAX_BL_BITS = 7;
-var zip_LENGTH_CODES = 29;
-var zip_LITERALS =256;
-var zip_END_BLOCK = 256;
-var zip_L_CODES = zip_LITERALS + 1 + zip_LENGTH_CODES;
-var zip_D_CODES = 30;
-var zip_BL_CODES = 19;
-var zip_REP_3_6 = 16;
-var zip_REPZ_3_10 = 17;
-var zip_REPZ_11_138 = 18;
-var zip_HEAP_SIZE = 2 * zip_L_CODES + 1;
-var zip_H_SHIFT = parseInt((zip_HASH_BITS + zip_MIN_MATCH - 1) /
-			   zip_MIN_MATCH);
-
-/* variables */
-var zip_free_queue;
-var zip_qhead, zip_qtail;
-var zip_initflag;
-var zip_outbuf = null;
-var zip_outcnt, zip_outoff;
-var zip_complete;
-var zip_window;
-var zip_d_buf;
-var zip_l_buf;
-var zip_prev;
-var zip_bi_buf;
-var zip_bi_valid;
-var zip_block_start;
-var zip_ins_h;
-var zip_hash_head;
-var zip_prev_match;
-var zip_match_available;
-var zip_match_length;
-var zip_prev_length;
-var zip_strstart;
-var zip_match_start;
-var zip_eofile;
-var zip_lookahead;
-var zip_max_chain_length;
-var zip_max_lazy_match;
-var zip_compr_level;
-var zip_good_match;
-var zip_nice_match;
-var zip_dyn_ltree;
-var zip_dyn_dtree;
-var zip_static_ltree;
-var zip_static_dtree;
-var zip_bl_tree;
-var zip_l_desc;
-var zip_d_desc;
-var zip_bl_desc;
-var zip_bl_count;
-var zip_heap;
-var zip_heap_len;
-var zip_heap_max;
-var zip_depth;
-var zip_length_code;
-var zip_dist_code;
-var zip_base_length;
-var zip_base_dist;
-var zip_flag_buf;
-var zip_last_lit;
-var zip_last_dist;
-var zip_last_flags;
-var zip_flags;
-var zip_flag_bit;
-var zip_opt_len;
-var zip_static_len;
-var zip_deflate_data;
-var zip_deflate_pos;
-
-/* objects (deflate) */
-
-var zip_DeflateCT = function() {
-    this.fc = 0; // frequency count or bit string
-    this.dl = 0; // father node in Huffman tree or length of bit string
-}
-
-var zip_DeflateTreeDesc = function() {
-    this.dyn_tree = null;	// the dynamic tree
-    this.static_tree = null;	// corresponding static tree or NULL
-    this.extra_bits = null;	// extra bits for each code or NULL
-    this.extra_base = 0;	// base index for extra_bits
-    this.elems = 0;		// max number of elements in the tree
-    this.max_length = 0;	// max bit length for the codes
-    this.max_code = 0;		// largest code with non zero frequency
-}
-
-/* Values for max_lazy_match, good_match and max_chain_length, depending on
- * the desired pack level (0..9). The values given below have been tuned to
- * exclude worst case performance for pathological files. Better values may be
- * found for specific files.
- */
-var zip_DeflateConfiguration = function(a, b, c, d) {
-    this.good_length = a; // reduce lazy search above this match length
-    this.max_lazy = b;    // do not perform lazy search above this match length
-    this.nice_length = c; // quit search above this match length
-    this.max_chain = d;
-}
-
-var zip_DeflateBuffer = function() {
-    this.next = null;
-    this.len = 0;
-    this.ptr = new Array(zip_OUTBUFSIZ);
-    this.off = 0;
-}
-
-/* constant tables */
-var zip_extra_lbits = new Array(
-    0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0);
-var zip_extra_dbits = new Array(
-    0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13);
-var zip_extra_blbits = new Array(
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7);
-var zip_bl_order = new Array(
-    16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15);
-var zip_configuration_table = new Array(
-	new zip_DeflateConfiguration(0,    0,   0,    0),
-	new zip_DeflateConfiguration(4,    4,   8,    4),
-	new zip_DeflateConfiguration(4,    5,  16,    8),
-	new zip_DeflateConfiguration(4,    6,  32,   32),
-	new zip_DeflateConfiguration(4,    4,  16,   16),
-	new zip_DeflateConfiguration(8,   16,  32,   32),
-	new zip_DeflateConfiguration(8,   16, 128,  128),
-	new zip_DeflateConfiguration(8,   32, 128,  256),
-	new zip_DeflateConfiguration(32, 128, 258, 1024),
-	new zip_DeflateConfiguration(32, 258, 258, 4096));
-
-
-/* routines (deflate) */
-
-var zip_deflate_start = function(level) {
-    var i;
-
-    if(!level)
-	level = zip_DEFAULT_LEVEL;
-    else if(level < 1)
-	level = 1;
-    else if(level > 9)
-	level = 9;
-
-    zip_compr_level = level;
-    zip_initflag = false;
-    zip_eofile = false;
-    if(zip_outbuf != null)
-	return;
-
-    zip_free_queue = zip_qhead = zip_qtail = null;
-    zip_outbuf = new Array(zip_OUTBUFSIZ);
-    zip_window = new Array(zip_window_size);
-    zip_d_buf = new Array(zip_DIST_BUFSIZE);
-    zip_l_buf = new Array(zip_INBUFSIZ + zip_INBUF_EXTRA);
-    zip_prev = new Array(1 << zip_BITS);
-    zip_dyn_ltree = new Array(zip_HEAP_SIZE);
-    for(i = 0; i < zip_HEAP_SIZE; i++)
-	zip_dyn_ltree[i] = new zip_DeflateCT();
-    zip_dyn_dtree = new Array(2*zip_D_CODES+1);
-    for(i = 0; i < 2*zip_D_CODES+1; i++)
-	zip_dyn_dtree[i] = new zip_DeflateCT();
-    zip_static_ltree = new Array(zip_L_CODES+2);
-    for(i = 0; i < zip_L_CODES+2; i++)
-	zip_static_ltree[i] = new zip_DeflateCT();
-    zip_static_dtree = new Array(zip_D_CODES);
-    for(i = 0; i < zip_D_CODES; i++)
-	zip_static_dtree[i] = new zip_DeflateCT();
-    zip_bl_tree = new Array(2*zip_BL_CODES+1);
-    for(i = 0; i < 2*zip_BL_CODES+1; i++)
-	zip_bl_tree[i] = new zip_DeflateCT();
-    zip_l_desc = new zip_DeflateTreeDesc();
-    zip_d_desc = new zip_DeflateTreeDesc();
-    zip_bl_desc = new zip_DeflateTreeDesc();
-    zip_bl_count = new Array(zip_MAX_BITS+1);
-    zip_heap = new Array(2*zip_L_CODES+1);
-    zip_depth = new Array(2*zip_L_CODES+1);
-    zip_length_code = new Array(zip_MAX_MATCH-zip_MIN_MATCH+1);
-    zip_dist_code = new Array(512);
-    zip_base_length = new Array(zip_LENGTH_CODES);
-    zip_base_dist = new Array(zip_D_CODES);
-    zip_flag_buf = new Array(parseInt(zip_LIT_BUFSIZE / 8));
-}
-
-var zip_deflate_end = function() {
-    zip_free_queue = zip_qhead = zip_qtail = null;
-    zip_outbuf = null;
-    zip_window = null;
-    zip_d_buf = null;
-    zip_l_buf = null;
-    zip_prev = null;
-    zip_dyn_ltree = null;
-    zip_dyn_dtree = null;
-    zip_static_ltree = null;
-    zip_static_dtree = null;
-    zip_bl_tree = null;
-    zip_l_desc = null;
-    zip_d_desc = null;
-    zip_bl_desc = null;
-    zip_bl_count = null;
-    zip_heap = null;
-    zip_depth = null;
-    zip_length_code = null;
-    zip_dist_code = null;
-    zip_base_length = null;
-    zip_base_dist = null;
-    zip_flag_buf = null;
-}
-
-var zip_reuse_queue = function(p) {
-    p.next = zip_free_queue;
-    zip_free_queue = p;
-}
-
-var zip_new_queue = function() {
-    var p;
-
-    if(zip_free_queue != null)
-    {
-	p = zip_free_queue;
-	zip_free_queue = zip_free_queue.next;
-    }
-    else
-	p = new zip_DeflateBuffer();
-    p.next = null;
-    p.len = p.off = 0;
-
-    return p;
-}
-
-var zip_head1 = function(i) {
-    return zip_prev[zip_WSIZE + i];
-}
-
-var zip_head2 = function(i, val) {
-    return zip_prev[zip_WSIZE + i] = val;
-}
-
-/* put_byte is used for the compressed output, put_ubyte for the
- * uncompressed output. However unlzw() uses window for its
- * suffix table instead of its output buffer, so it does not use put_ubyte
- * (to be cleaned up).
- */
-var zip_put_byte = function(c) {
-    zip_outbuf[zip_outoff + zip_outcnt++] = c;
-    if(zip_outoff + zip_outcnt == zip_OUTBUFSIZ)
-	zip_qoutbuf();
-}
-
-/* Output a 16 bit value, lsb first */
-var zip_put_short = function(w) {
-    w &= 0xffff;
-    if(zip_outoff + zip_outcnt < zip_OUTBUFSIZ - 2) {
-	zip_outbuf[zip_outoff + zip_outcnt++] = (w & 0xff);
-	zip_outbuf[zip_outoff + zip_outcnt++] = (w >>> 8);
-    } else {
-	zip_put_byte(w & 0xff);
-	zip_put_byte(w >>> 8);
-    }
-}
-
-/* ==========================================================================
- * Insert string s in the dictionary and set match_head to the previous head
- * of the hash chain (the most recent string with same hash key). Return
- * the previous length of the hash chain.
- * IN  assertion: all calls to to INSERT_STRING are made with consecutive
- *    input characters and the first MIN_MATCH bytes of s are valid
- *    (except for the last MIN_MATCH-1 bytes of the input file).
- */
-var zip_INSERT_STRING = function() {
-    zip_ins_h = ((zip_ins_h << zip_H_SHIFT)
-		 ^ (zip_window[zip_strstart + zip_MIN_MATCH - 1] & 0xff))
-	& zip_HASH_MASK;
-    zip_hash_head = zip_head1(zip_ins_h);
-    zip_prev[zip_strstart & zip_WMASK] = zip_hash_head;
-    zip_head2(zip_ins_h, zip_strstart);
-}
-
-/* Send a code of the given tree. c and tree must not have side effects */
-var zip_SEND_CODE = function(c, tree) {
-    zip_send_bits(tree[c].fc, tree[c].dl);
-}
-
-/* Mapping from a distance to a distance code. dist is the distance - 1 and
- * must not have side effects. dist_code[256] and dist_code[257] are never
- * used.
- */
-var zip_D_CODE = function(dist) {
-    return (dist < 256 ? zip_dist_code[dist]
-	    : zip_dist_code[256 + (dist>>7)]) & 0xff;
-}
-
-/* ==========================================================================
- * Compares to subtrees, using the tree depth as tie breaker when
- * the subtrees have equal frequency. This minimizes the worst case length.
- */
-var zip_SMALLER = function(tree, n, m) {
-    return tree[n].fc < tree[m].fc ||
-      (tree[n].fc == tree[m].fc && zip_depth[n] <= zip_depth[m]);
-}
-
-/* ==========================================================================
- * read string data
- */
-var zip_read_buff = function(buff, offset, n) {
-    var i;
-    for(i = 0; i < n && zip_deflate_pos < zip_deflate_data.length; i++)
-	buff[offset + i] =
-	    zip_deflate_data.charCodeAt(zip_deflate_pos++) & 0xff;
-    return i;
-}
-
-/* ==========================================================================
- * Initialize the "longest match" routines for a new file
- */
-var zip_lm_init = function() {
-    var j;
-
-    /* Initialize the hash table. */
-    for(j = 0; j < zip_HASH_SIZE; j++)
-//	zip_head2(j, zip_NIL);
-	zip_prev[zip_WSIZE + j] = 0;
-    /* prev will be initialized on the fly */
-
-    /* Set the default configuration parameters:
-     */
-    zip_max_lazy_match = zip_configuration_table[zip_compr_level].max_lazy;
-    zip_good_match     = zip_configuration_table[zip_compr_level].good_length;
-    if(!zip_FULL_SEARCH)
-	zip_nice_match = zip_configuration_table[zip_compr_level].nice_length;
-    zip_max_chain_length = zip_configuration_table[zip_compr_level].max_chain;
-
-    zip_strstart = 0;
-    zip_block_start = 0;
-
-    zip_lookahead = zip_read_buff(zip_window, 0, 2 * zip_WSIZE);
-    if(zip_lookahead <= 0) {
-	zip_eofile = true;
-	zip_lookahead = 0;
-	return;
-    }
-    zip_eofile = false;
-    /* Make sure that we always have enough lookahead. This is important
-     * if input comes from a device such as a tty.
-     */
-    while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
-	zip_fill_window();
-
-    /* If lookahead < MIN_MATCH, ins_h is garbage, but this is
-     * not important since only literal bytes will be emitted.
-     */
-    zip_ins_h = 0;
-    for(j = 0; j < zip_MIN_MATCH - 1; j++) {
-//      UPDATE_HASH(ins_h, window[j]);
-	zip_ins_h = ((zip_ins_h << zip_H_SHIFT) ^ (zip_window[j] & 0xff)) & zip_HASH_MASK;
-    }
-}
-
-/* ==========================================================================
- * Set match_start to the longest match starting at the given string and
- * return its length. Matches shorter or equal to prev_length are discarded,
- * in which case the result is equal to prev_length and match_start is
- * garbage.
- * IN assertions: cur_match is the head of the hash chain for the current
- *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
- */
-var zip_longest_match = function(cur_match) {
-    var chain_length = zip_max_chain_length; // max hash chain length
-    var scanp = zip_strstart; // current string
-    var matchp;		// matched string
-    var len;		// length of current match
-    var best_len = zip_prev_length;	// best match length so far
-
-    /* Stop when cur_match becomes <= limit. To simplify the code,
-     * we prevent matches with the string of window index 0.
-     */
-    var limit = (zip_strstart > zip_MAX_DIST ? zip_strstart - zip_MAX_DIST : zip_NIL);
-
-    var strendp = zip_strstart + zip_MAX_MATCH;
-    var scan_end1 = zip_window[scanp + best_len - 1];
-    var scan_end  = zip_window[scanp + best_len];
-
-    /* Do not waste too much time if we already have a good match: */
-    if(zip_prev_length >= zip_good_match)
-	chain_length >>= 2;
-
-//  Assert(encoder->strstart <= window_size-MIN_LOOKAHEAD, "insufficient lookahead");
-
-    do {
-//    Assert(cur_match < encoder->strstart, "no future");
-	matchp = cur_match;
-
-	/* Skip to next match if the match length cannot increase
-	    * or if the match length is less than 2:
-	*/
-	if(zip_window[matchp + best_len]	!= scan_end  ||
-	   zip_window[matchp + best_len - 1]	!= scan_end1 ||
-	   zip_window[matchp]			!= zip_window[scanp] ||
-	   zip_window[++matchp]			!= zip_window[scanp + 1]) {
-	    continue;
-	}
-
-	/* The check at best_len-1 can be removed because it will be made
-         * again later. (This heuristic is not always a win.)
-         * It is not necessary to compare scan[2] and match[2] since they
-         * are always equal when the other bytes match, given that
-         * the hash keys are equal and that HASH_BITS >= 8.
-         */
-	scanp += 2;
-	matchp++;
-
-	/* We check for insufficient lookahead only every 8th comparison;
-         * the 256th check will be made at strstart+258.
-         */
-	do {
-	} while(zip_window[++scanp] == zip_window[++matchp] &&
-		zip_window[++scanp] == zip_window[++matchp] &&
-		zip_window[++scanp] == zip_window[++matchp] &&
-		zip_window[++scanp] == zip_window[++matchp] &&
-		zip_window[++scanp] == zip_window[++matchp] &&
-		zip_window[++scanp] == zip_window[++matchp] &&
-		zip_window[++scanp] == zip_window[++matchp] &&
-		zip_window[++scanp] == zip_window[++matchp] &&
-		scanp < strendp);
-
-      len = zip_MAX_MATCH - (strendp - scanp);
-      scanp = strendp - zip_MAX_MATCH;
-
-      if(len > best_len) {
-	  zip_match_start = cur_match;
-	  best_len = len;
-	  if(zip_FULL_SEARCH) {
-	      if(len >= zip_MAX_MATCH) break;
-	  } else {
-	      if(len >= zip_nice_match) break;
-	  }
-
-	  scan_end1  = zip_window[scanp + best_len-1];
-	  scan_end   = zip_window[scanp + best_len];
-      }
-    } while((cur_match = zip_prev[cur_match & zip_WMASK]) > limit
-	    && --chain_length != 0);
-
-    return best_len;
-}
-
-/* ==========================================================================
- * Fill the window when the lookahead becomes insufficient.
- * Updates strstart and lookahead, and sets eofile if end of input file.
- * IN assertion: lookahead < MIN_LOOKAHEAD && strstart + lookahead > 0
- * OUT assertions: at least one byte has been read, or eofile is set;
- *    file reads are performed for at least two bytes (required for the
- *    translate_eol option).
- */
-var zip_fill_window = function() {
-    var n, m;
-
-    // Amount of free space at the end of the window.
-    var more = zip_window_size - zip_lookahead - zip_strstart;
-
-    /* If the window is almost full and there is insufficient lookahead,
-     * move the upper half to the lower one to make room in the upper half.
-     */
-    if(more == -1) {
-	/* Very unlikely, but possible on 16 bit machine if strstart == 0
-         * and lookahead == 1 (input done one byte at time)
-         */
-	more--;
-    } else if(zip_strstart >= zip_WSIZE + zip_MAX_DIST) {
-	/* By the IN assertion, the window is not empty so we can't confuse
-         * more == 0 with more == 64K on a 16 bit machine.
-         */
-//	Assert(window_size == (ulg)2*WSIZE, "no sliding with BIG_MEM");
-
-//	System.arraycopy(window, WSIZE, window, 0, WSIZE);
-	for(n = 0; n < zip_WSIZE; n++)
-	    zip_window[n] = zip_window[n + zip_WSIZE];
-      
-	zip_match_start -= zip_WSIZE;
-	zip_strstart    -= zip_WSIZE; /* we now have strstart >= MAX_DIST: */
-	zip_block_start -= zip_WSIZE;
-
-	for(n = 0; n < zip_HASH_SIZE; n++) {
-	    m = zip_head1(n);
-	    zip_head2(n, m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL);
-	}
-	for(n = 0; n < zip_WSIZE; n++) {
-	    /* If n is not on any hash chain, prev[n] is garbage but
-	     * its value will never be used.
-	     */
-	    m = zip_prev[n];
-	    zip_prev[n] = (m >= zip_WSIZE ? m - zip_WSIZE : zip_NIL);
-	}
-	more += zip_WSIZE;
-    }
-    // At this point, more >= 2
-    if(!zip_eofile) {
-	n = zip_read_buff(zip_window, zip_strstart + zip_lookahead, more);
-	if(n <= 0)
-	    zip_eofile = true;
-	else
-	    zip_lookahead += n;
-    }
-}
-
-/* ==========================================================================
- * Processes a new input file and return its compressed length. This
- * function does not perform lazy evaluationof matches and inserts
- * new strings in the dictionary only for unmatched strings or for short
- * matches. It is used only for the fast compression options.
- */
-var zip_deflate_fast = function() {
-    while(zip_lookahead != 0 && zip_qhead == null) {
-	var flush; // set if current block must be flushed
-
-	/* Insert the string window[strstart .. strstart+2] in the
-	 * dictionary, and set hash_head to the head of the hash chain:
-	 */
-	zip_INSERT_STRING();
-
-	/* Find the longest match, discarding those <= prev_length.
-	 * At this point we have always match_length < MIN_MATCH
-	 */
-	if(zip_hash_head != zip_NIL &&
-	   zip_strstart - zip_hash_head <= zip_MAX_DIST) {
-	    /* To simplify the code, we prevent matches with the string
-	     * of window index 0 (in particular we have to avoid a match
-	     * of the string with itself at the start of the input file).
-	     */
-	    zip_match_length = zip_longest_match(zip_hash_head);
-	    /* longest_match() sets match_start */
-	    if(zip_match_length > zip_lookahead)
-		zip_match_length = zip_lookahead;
-	}
-	if(zip_match_length >= zip_MIN_MATCH) {
-//	    check_match(strstart, match_start, match_length);
-
-	    flush = zip_ct_tally(zip_strstart - zip_match_start,
-				 zip_match_length - zip_MIN_MATCH);
-	    zip_lookahead -= zip_match_length;
-
-	    /* Insert new strings in the hash table only if the match length
-	     * is not too large. This saves time but degrades compression.
-	     */
-	    if(zip_match_length <= zip_max_lazy_match) {
-		zip_match_length--; // string at strstart already in hash table
-		do {
-		    zip_strstart++;
-		    zip_INSERT_STRING();
-		    /* strstart never exceeds WSIZE-MAX_MATCH, so there are
-		     * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
-		     * these bytes are garbage, but it does not matter since
-		     * the next lookahead bytes will be emitted as literals.
-		     */
-		} while(--zip_match_length != 0);
-		zip_strstart++;
-	    } else {
-		zip_strstart += zip_match_length;
-		zip_match_length = 0;
-		zip_ins_h = zip_window[zip_strstart] & 0xff;
-//		UPDATE_HASH(ins_h, window[strstart + 1]);
-		zip_ins_h = ((zip_ins_h<<zip_H_SHIFT) ^ (zip_window[zip_strstart + 1] & 0xff)) & zip_HASH_MASK;
-
-//#if MIN_MATCH != 3
-//		Call UPDATE_HASH() MIN_MATCH-3 more times
-//#endif
-
-	    }
-	} else {
-	    /* No match, output a literal byte */
-	    flush = zip_ct_tally(0, zip_window[zip_strstart] & 0xff);
-	    zip_lookahead--;
-	    zip_strstart++;
-	}
-	if(flush) {
-	    zip_flush_block(0);
-	    zip_block_start = zip_strstart;
-	}
-
-	/* Make sure that we always have enough lookahead, except
-	 * at the end of the input file. We need MAX_MATCH bytes
-	 * for the next match, plus MIN_MATCH bytes to insert the
-	 * string following the next match.
-	 */
-	while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
-	    zip_fill_window();
-    }
-}
-
-var zip_deflate_better = function() {
-    /* Process the input block. */
-    while(zip_lookahead != 0 && zip_qhead == null) {
-	/* Insert the string window[strstart .. strstart+2] in the
-	 * dictionary, and set hash_head to the head of the hash chain:
-	 */
-	zip_INSERT_STRING();
-
-	/* Find the longest match, discarding those <= prev_length.
-	 */
-	zip_prev_length = zip_match_length;
-	zip_prev_match = zip_match_start;
-	zip_match_length = zip_MIN_MATCH - 1;
-
-	if(zip_hash_head != zip_NIL &&
-	   zip_prev_length < zip_max_lazy_match &&
-	   zip_strstart - zip_hash_head <= zip_MAX_DIST) {
-	    /* To simplify the code, we prevent matches with the string
-	     * of window index 0 (in particular we have to avoid a match
-	     * of the string with itself at the start of the input file).
-	     */
-	    zip_match_length = zip_longest_match(zip_hash_head);
-	    /* longest_match() sets match_start */
-	    if(zip_match_length > zip_lookahead)
-		zip_match_length = zip_lookahead;
-
-	    /* Ignore a length 3 match if it is too distant: */
-	    if(zip_match_length == zip_MIN_MATCH &&
-	       zip_strstart - zip_match_start > zip_TOO_FAR) {
-		/* If prev_match is also MIN_MATCH, match_start is garbage
-		 * but we will ignore the current match anyway.
-		 */
-		zip_match_length--;
-	    }
-	}
-	/* If there was a match at the previous step and the current
-	 * match is not better, output the previous match:
-	 */
-	if(zip_prev_length >= zip_MIN_MATCH &&
-	   zip_match_length <= zip_prev_length) {
-	    var flush; // set if current block must be flushed
-
-//	    check_match(strstart - 1, prev_match, prev_length);
-	    flush = zip_ct_tally(zip_strstart - 1 - zip_prev_match,
-				 zip_prev_length - zip_MIN_MATCH);
-
-	    /* Insert in hash table all strings up to the end of the match.
-	     * strstart-1 and strstart are already inserted.
-	     */
-	    zip_lookahead -= zip_prev_length - 1;
-	    zip_prev_length -= 2;
-	    do {
-		zip_strstart++;
-		zip_INSERT_STRING();
-		/* strstart never exceeds WSIZE-MAX_MATCH, so there are
-		 * always MIN_MATCH bytes ahead. If lookahead < MIN_MATCH
-		 * these bytes are garbage, but it does not matter since the
-		 * next lookahead bytes will always be emitted as literals.
-		 */
-	    } while(--zip_prev_length != 0);
-	    zip_match_available = 0;
-	    zip_match_length = zip_MIN_MATCH - 1;
-	    zip_strstart++;
-	    if(flush) {
-		zip_flush_block(0);
-		zip_block_start = zip_strstart;
-	    }
-	} else if(zip_match_available != 0) {
-	    /* If there was no match at the previous position, output a
-	     * single literal. If there was a match but the current match
-	     * is longer, truncate the previous match to a single literal.
-	     */
-	    if(zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff)) {
-		zip_flush_block(0);
-		zip_block_start = zip_strstart;
-	    }
-	    zip_strstart++;
-	    zip_lookahead--;
-	} else {
-	    /* There is no previous match to compare with, wait for
-	     * the next step to decide.
-	     */
-	    zip_match_available = 1;
-	    zip_strstart++;
-	    zip_lookahead--;
-	}
-
-	/* Make sure that we always have enough lookahead, except
-	 * at the end of the input file. We need MAX_MATCH bytes
-	 * for the next match, plus MIN_MATCH bytes to insert the
-	 * string following the next match.
-	 */
-	while(zip_lookahead < zip_MIN_LOOKAHEAD && !zip_eofile)
-	    zip_fill_window();
-    }
-}
-
-var zip_init_deflate = function() {
-    if(zip_eofile)
-	return;
-    zip_bi_buf = 0;
-    zip_bi_valid = 0;
-    zip_ct_init();
-    zip_lm_init();
-
-    zip_qhead = null;
-    zip_outcnt = 0;
-    zip_outoff = 0;
-
-    if(zip_compr_level <= 3)
-    {
-	zip_prev_length = zip_MIN_MATCH - 1;
-	zip_match_length = 0;
-    }
-    else
-    {
-	zip_match_length = zip_MIN_MATCH - 1;
-	zip_match_available = 0;
-    }
-
-    zip_complete = false;
-}
-
-/* ==========================================================================
- * Same as above, but achieves better compression. We use a lazy
- * evaluation for matches: a match is finally adopted only if there is
- * no better match at the next window position.
- */
-var zip_deflate_internal = function(buff, off, buff_size) {
-    var n;
-
-    if(!zip_initflag)
-    {
-	zip_init_deflate();
-	zip_initflag = true;
-	if(zip_lookahead == 0) { // empty
-	    zip_complete = true;
-	    return 0;
-	}
-    }
-
-    if((n = zip_qcopy(buff, off, buff_size)) == buff_size)
-	return buff_size;
-
-    if(zip_complete)
-	return n;
-
-    if(zip_compr_level <= 3) // optimized for speed
-	zip_deflate_fast();
-    else
-	zip_deflate_better();
-    if(zip_lookahead == 0) {
-	if(zip_match_available != 0)
-	    zip_ct_tally(0, zip_window[zip_strstart - 1] & 0xff);
-	zip_flush_block(1);
-	zip_complete = true;
-    }
-    return n + zip_qcopy(buff, n + off, buff_size - n);
-}
-
-var zip_qcopy = function(buff, off, buff_size) {
-    var n, i, j;
-
-    n = 0;
-    while(zip_qhead != null && n < buff_size)
-    {
-	i = buff_size - n;
-	if(i > zip_qhead.len)
-	    i = zip_qhead.len;
-//      System.arraycopy(qhead.ptr, qhead.off, buff, off + n, i);
-	for(j = 0; j < i; j++)
-	    buff[off + n + j] = zip_qhead.ptr[zip_qhead.off + j];
-	
-	zip_qhead.off += i;
-	zip_qhead.len -= i;
-	n += i;
-	if(zip_qhead.len == 0) {
-	    var p;
-	    p = zip_qhead;
-	    zip_qhead = zip_qhead.next;
-	    zip_reuse_queue(p);
-	}
-    }
-
-    if(n == buff_size)
-	return n;
-
-    if(zip_outoff < zip_outcnt) {
-	i = buff_size - n;
-	if(i > zip_outcnt - zip_outoff)
-	    i = zip_outcnt - zip_outoff;
-	// System.arraycopy(outbuf, outoff, buff, off + n, i);
-	for(j = 0; j < i; j++)
-	    buff[off + n + j] = zip_outbuf[zip_outoff + j];
-	zip_outoff += i;
-	n += i;
-	if(zip_outcnt == zip_outoff)
-	    zip_outcnt = zip_outoff = 0;
-    }
-    return n;
-}
-
-/* ==========================================================================
- * Allocate the match buffer, initialize the various tables and save the
- * location of the internal file attribute (ascii/binary) and method
- * (DEFLATE/STORE).
- */
-var zip_ct_init = function() {
-    var n;	// iterates over tree elements
-    var bits;	// bit counter
-    var length;	// length value
-    var code;	// code value
-    var dist;	// distance index
-
-    if(zip_static_dtree[0].dl != 0) return; // ct_init already called
-
-    zip_l_desc.dyn_tree		= zip_dyn_ltree;
-    zip_l_desc.static_tree	= zip_static_ltree;
-    zip_l_desc.extra_bits	= zip_extra_lbits;
-    zip_l_desc.extra_base	= zip_LITERALS + 1;
-    zip_l_desc.elems		= zip_L_CODES;
-    zip_l_desc.max_length	= zip_MAX_BITS;
-    zip_l_desc.max_code		= 0;
-
-    zip_d_desc.dyn_tree		= zip_dyn_dtree;
-    zip_d_desc.static_tree	= zip_static_dtree;
-    zip_d_desc.extra_bits	= zip_extra_dbits;
-    zip_d_desc.extra_base	= 0;
-    zip_d_desc.elems		= zip_D_CODES;
-    zip_d_desc.max_length	= zip_MAX_BITS;
-    zip_d_desc.max_code		= 0;
-
-    zip_bl_desc.dyn_tree	= zip_bl_tree;
-    zip_bl_desc.static_tree	= null;
-    zip_bl_desc.extra_bits	= zip_extra_blbits;
-    zip_bl_desc.extra_base	= 0;
-    zip_bl_desc.elems		= zip_BL_CODES;
-    zip_bl_desc.max_length	= zip_MAX_BL_BITS;
-    zip_bl_desc.max_code	= 0;
-
-    // Initialize the mapping length (0..255) -> length code (0..28)
-    length = 0;
-    for(code = 0; code < zip_LENGTH_CODES-1; code++) {
-	zip_base_length[code] = length;
-	for(n = 0; n < (1<<zip_extra_lbits[code]); n++)
-	    zip_length_code[length++] = code;
-    }
-    // Assert (length == 256, "ct_init: length != 256");
-
-    /* Note that the length 255 (match length 258) can be represented
-     * in two different ways: code 284 + 5 bits or code 285, so we
-     * overwrite length_code[255] to use the best encoding:
-     */
-    zip_length_code[length-1] = code;
-
-    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
-    dist = 0;
-    for(code = 0 ; code < 16; code++) {
-	zip_base_dist[code] = dist;
-	for(n = 0; n < (1<<zip_extra_dbits[code]); n++) {
-	    zip_dist_code[dist++] = code;
-	}
-    }
-    // Assert (dist == 256, "ct_init: dist != 256");
-    dist >>= 7; // from now on, all distances are divided by 128
-    for( ; code < zip_D_CODES; code++) {
-	zip_base_dist[code] = dist << 7;
-	for(n = 0; n < (1<<(zip_extra_dbits[code]-7)); n++)
-	    zip_dist_code[256 + dist++] = code;
-    }
-    // Assert (dist == 256, "ct_init: 256+dist != 512");
-
-    // Construct the codes of the static literal tree
-    for(bits = 0; bits <= zip_MAX_BITS; bits++)
-	zip_bl_count[bits] = 0;
-    n = 0;
-    while(n <= 143) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; }
-    while(n <= 255) { zip_static_ltree[n++].dl = 9; zip_bl_count[9]++; }
-    while(n <= 279) { zip_static_ltree[n++].dl = 7; zip_bl_count[7]++; }
-    while(n <= 287) { zip_static_ltree[n++].dl = 8; zip_bl_count[8]++; }
-    /* Codes 286 and 287 do not exist, but we must include them in the
-     * tree construction to get a canonical Huffman tree (longest code
-     * all ones)
-     */
-    zip_gen_codes(zip_static_ltree, zip_L_CODES + 1);
-
-    /* The static distance tree is trivial: */
-    for(n = 0; n < zip_D_CODES; n++) {
-	zip_static_dtree[n].dl = 5;
-	zip_static_dtree[n].fc = zip_bi_reverse(n, 5);
-    }
-
-    // Initialize the first block of the first file:
-    zip_init_block();
-}
-
-/* ==========================================================================
- * Initialize a new block.
- */
-var zip_init_block = function() {
-    var n; // iterates over tree elements
-
-    // Initialize the trees.
-    for(n = 0; n < zip_L_CODES;  n++) zip_dyn_ltree[n].fc = 0;
-    for(n = 0; n < zip_D_CODES;  n++) zip_dyn_dtree[n].fc = 0;
-    for(n = 0; n < zip_BL_CODES; n++) zip_bl_tree[n].fc = 0;
-
-    zip_dyn_ltree[zip_END_BLOCK].fc = 1;
-    zip_opt_len = zip_static_len = 0;
-    zip_last_lit = zip_last_dist = zip_last_flags = 0;
-    zip_flags = 0;
-    zip_flag_bit = 1;
-}
-
-/* ==========================================================================
- * Restore the heap property by moving down the tree starting at node k,
- * exchanging a node with the smallest of its two sons if necessary, stopping
- * when the heap property is re-established (each father smaller than its
- * two sons).
- */
-var zip_pqdownheap = function(
-    tree,	// the tree to restore
-    k) {	// node to move down
-    var v = zip_heap[k];
-    var j = k << 1;	// left son of k
-
-    while(j <= zip_heap_len) {
-	// Set j to the smallest of the two sons:
-	if(j < zip_heap_len &&
-	   zip_SMALLER(tree, zip_heap[j + 1], zip_heap[j]))
-	    j++;
-
-	// Exit if v is smaller than both sons
-	if(zip_SMALLER(tree, v, zip_heap[j]))
-	    break;
-
-	// Exchange v with the smallest son
-	zip_heap[k] = zip_heap[j];
-	k = j;
-
-	// And continue down the tree, setting j to the left son of k
-	j <<= 1;
-    }
-    zip_heap[k] = v;
-}
-
-/* ==========================================================================
- * Compute the optimal bit lengths for a tree and update the total bit length
- * for the current block.
- * IN assertion: the fields freq and dad are set, heap[heap_max] and
- *    above are the tree nodes sorted by increasing frequency.
- * OUT assertions: the field len is set to the optimal bit length, the
- *     array bl_count contains the frequencies for each bit length.
- *     The length opt_len is updated; static_len is also updated if stree is
- *     not null.
- */
-var zip_gen_bitlen = function(desc) { // the tree descriptor
-    var tree		= desc.dyn_tree;
-    var extra		= desc.extra_bits;
-    var base		= desc.extra_base;
-    var max_code	= desc.max_code;
-    var max_length	= desc.max_length;
-    var stree		= desc.static_tree;
-    var h;		// heap index
-    var n, m;		// iterate over the tree elements
-    var bits;		// bit length
-    var xbits;		// extra bits
-    var f;		// frequency
-    var overflow = 0;	// number of elements with bit length too large
-
-    for(bits = 0; bits <= zip_MAX_BITS; bits++)
-	zip_bl_count[bits] = 0;
-
-    /* In a first pass, compute the optimal bit lengths (which may
-     * overflow in the case of the bit length tree).
-     */
-    tree[zip_heap[zip_heap_max]].dl = 0; // root of the heap
-
-    for(h = zip_heap_max + 1; h < zip_HEAP_SIZE; h++) {
-	n = zip_heap[h];
-	bits = tree[tree[n].dl].dl + 1;
-	if(bits > max_length) {
-	    bits = max_length;
-	    overflow++;
-	}
-	tree[n].dl = bits;
-	// We overwrite tree[n].dl which is no longer needed
-
-	if(n > max_code)
-	    continue; // not a leaf node
-
-	zip_bl_count[bits]++;
-	xbits = 0;
-	if(n >= base)
-	    xbits = extra[n - base];
-	f = tree[n].fc;
-	zip_opt_len += f * (bits + xbits);
-	if(stree != null)
-	    zip_static_len += f * (stree[n].dl + xbits);
-    }
-    if(overflow == 0)
-	return;
-
-    // This happens for example on obj2 and pic of the Calgary corpus
-
-    // Find the first bit length which could increase:
-    do {
-	bits = max_length - 1;
-	while(zip_bl_count[bits] == 0)
-	    bits--;
-	zip_bl_count[bits]--;		// move one leaf down the tree
-	zip_bl_count[bits + 1] += 2;	// move one overflow item as its brother
-	zip_bl_count[max_length]--;
-	/* The brother of the overflow item also moves one step up,
-	 * but this does not affect bl_count[max_length]
-	 */
-	overflow -= 2;
-    } while(overflow > 0);
-
-    /* Now recompute all bit lengths, scanning in increasing frequency.
-     * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
-     * lengths instead of fixing only the wrong ones. This idea is taken
-     * from 'ar' written by Haruhiko Okumura.)
-     */
-    for(bits = max_length; bits != 0; bits--) {
-	n = zip_bl_count[bits];
-	while(n != 0) {
-	    m = zip_heap[--h];
-	    if(m > max_code)
-		continue;
-	    if(tree[m].dl != bits) {
-		zip_opt_len += (bits - tree[m].dl) * tree[m].fc;
-		tree[m].fc = bits;
-	    }
-	    n--;
-	}
-    }
-}
-
-  /* ==========================================================================
-   * Generate the codes for a given tree and bit counts (which need not be
-   * optimal).
-   * IN assertion: the array bl_count contains the bit length statistics for
-   * the given tree and the field len is set for all tree elements.
-   * OUT assertion: the field code is set for all tree elements of non
-   *     zero code length.
-   */
-var zip_gen_codes = function(tree,	// the tree to decorate
-		   max_code) {	// largest code with non zero frequency
-    var next_code = new Array(zip_MAX_BITS+1); // next code value for each bit length
-    var code = 0;		// running code value
-    var bits;			// bit index
-    var n;			// code index
-
-    /* The distribution counts are first used to generate the code values
-     * without bit reversal.
-     */
-    for(bits = 1; bits <= zip_MAX_BITS; bits++) {
-	code = ((code + zip_bl_count[bits-1]) << 1);
-	next_code[bits] = code;
-    }
-
-    /* Check that the bit counts in bl_count are consistent. The last code
-     * must be all ones.
-     */
-//    Assert (code + encoder->bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
-//	    "inconsistent bit counts");
-//    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
-
-    for(n = 0; n <= max_code; n++) {
-	var len = tree[n].dl;
-	if(len == 0)
-	    continue;
-	// Now reverse the bits
-	tree[n].fc = zip_bi_reverse(next_code[len]++, len);
-
-//      Tracec(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
-//	  n, (isgraph(n) ? n : ' '), len, tree[n].fc, next_code[len]-1));
-    }
-}
-
-/* ==========================================================================
- * Construct one Huffman tree and assigns the code bit strings and lengths.
- * Update the total bit length for the current block.
- * IN assertion: the field freq is set for all tree elements.
- * OUT assertions: the fields len and code are set to the optimal bit length
- *     and corresponding code. The length opt_len is updated; static_len is
- *     also updated if stree is not null. The field max_code is set.
- */
-var zip_build_tree = function(desc) { // the tree descriptor
-    var tree	= desc.dyn_tree;
-    var stree	= desc.static_tree;
-    var elems	= desc.elems;
-    var n, m;		// iterate over heap elements
-    var max_code = -1;	// largest code with non zero frequency
-    var node = elems;	// next internal node of the tree
-
-    /* Construct the initial heap, with least frequent element in
-     * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
-     * heap[0] is not used.
-     */
-    zip_heap_len = 0;
-    zip_heap_max = zip_HEAP_SIZE;
-
-    for(n = 0; n < elems; n++) {
-	if(tree[n].fc != 0) {
-	    zip_heap[++zip_heap_len] = max_code = n;
-	    zip_depth[n] = 0;
-	} else
-	    tree[n].dl = 0;
-    }
-
-    /* The pkzip format requires that at least one distance code exists,
-     * and that at least one bit should be sent even if there is only one
-     * possible code. So to avoid special checks later on we force at least
-     * two codes of non zero frequency.
-     */
-    while(zip_heap_len < 2) {
-	var xnew = zip_heap[++zip_heap_len] = (max_code < 2 ? ++max_code : 0);
-	tree[xnew].fc = 1;
-	zip_depth[xnew] = 0;
-	zip_opt_len--;
-	if(stree != null)
-	    zip_static_len -= stree[xnew].dl;
-	// new is 0 or 1 so it does not have extra bits
-    }
-    desc.max_code = max_code;
-
-    /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
-     * establish sub-heaps of increasing lengths:
-     */
-    for(n = zip_heap_len >> 1; n >= 1; n--)
-	zip_pqdownheap(tree, n);
-
-    /* Construct the Huffman tree by repeatedly combining the least two
-     * frequent nodes.
-     */
-    do {
-	n = zip_heap[zip_SMALLEST];
-	zip_heap[zip_SMALLEST] = zip_heap[zip_heap_len--];
-	zip_pqdownheap(tree, zip_SMALLEST);
-
-	m = zip_heap[zip_SMALLEST];  // m = node of next least frequency
-
-	// keep the nodes sorted by frequency
-	zip_heap[--zip_heap_max] = n;
-	zip_heap[--zip_heap_max] = m;
-
-	// Create a new node father of n and m
-	tree[node].fc = tree[n].fc + tree[m].fc;
-//	depth[node] = (char)(MAX(depth[n], depth[m]) + 1);
-	if(zip_depth[n] > zip_depth[m] + 1)
-	    zip_depth[node] = zip_depth[n];
-	else
-	    zip_depth[node] = zip_depth[m] + 1;
-	tree[n].dl = tree[m].dl = node;
-
-	// and insert the new node in the heap
-	zip_heap[zip_SMALLEST] = node++;
-	zip_pqdownheap(tree, zip_SMALLEST);
-
-    } while(zip_heap_len >= 2);
-
-    zip_heap[--zip_heap_max] = zip_heap[zip_SMALLEST];
-
-    /* At this point, the fields freq and dad are set. We can now
-     * generate the bit lengths.
-     */
-    zip_gen_bitlen(desc);
-
-    // The field len is now set, we can generate the bit codes
-    zip_gen_codes(tree, max_code);
-}
-
-/* ==========================================================================
- * Scan a literal or distance tree to determine the frequencies of the codes
- * in the bit length tree. Updates opt_len to take into account the repeat
- * counts. (The contribution of the bit length codes will be added later
- * during the construction of bl_tree.)
- */
-var zip_scan_tree = function(tree,// the tree to be scanned
-		       max_code) {  // and its largest code of non zero frequency
-    var n;			// iterates over all tree elements
-    var prevlen = -1;		// last emitted length
-    var curlen;			// length of current code
-    var nextlen = tree[0].dl;	// length of next code
-    var count = 0;		// repeat count of the current code
-    var max_count = 7;		// max repeat count
-    var min_count = 4;		// min repeat count
-
-    if(nextlen == 0) {
-	max_count = 138;
-	min_count = 3;
-    }
-    tree[max_code + 1].dl = 0xffff; // guard
-
-    for(n = 0; n <= max_code; n++) {
-	curlen = nextlen;
-	nextlen = tree[n + 1].dl;
-	if(++count < max_count && curlen == nextlen)
-	    continue;
-	else if(count < min_count)
-	    zip_bl_tree[curlen].fc += count;
-	else if(curlen != 0) {
-	    if(curlen != prevlen)
-		zip_bl_tree[curlen].fc++;
-	    zip_bl_tree[zip_REP_3_6].fc++;
-	} else if(count <= 10)
-	    zip_bl_tree[zip_REPZ_3_10].fc++;
-	else
-	    zip_bl_tree[zip_REPZ_11_138].fc++;
-	count = 0; prevlen = curlen;
-	if(nextlen == 0) {
-	    max_count = 138;
-	    min_count = 3;
-	} else if(curlen == nextlen) {
-	    max_count = 6;
-	    min_count = 3;
-	} else {
-	    max_count = 7;
-	    min_count = 4;
-	}
-    }
-}
-
-  /* ==========================================================================
-   * Send a literal or distance tree in compressed form, using the codes in
-   * bl_tree.
-   */
-var zip_send_tree = function(tree, // the tree to be scanned
-		   max_code) { // and its largest code of non zero frequency
-    var n;			// iterates over all tree elements
-    var prevlen = -1;		// last emitted length
-    var curlen;			// length of current code
-    var nextlen = tree[0].dl;	// length of next code
-    var count = 0;		// repeat count of the current code
-    var max_count = 7;		// max repeat count
-    var min_count = 4;		// min repeat count
-
-    /* tree[max_code+1].dl = -1; */  /* guard already set */
-    if(nextlen == 0) {
-      max_count = 138;
-      min_count = 3;
-    }
-
-    for(n = 0; n <= max_code; n++) {
-	curlen = nextlen;
-	nextlen = tree[n+1].dl;
-	if(++count < max_count && curlen == nextlen) {
-	    continue;
-	} else if(count < min_count) {
-	    do { zip_SEND_CODE(curlen, zip_bl_tree); } while(--count != 0);
-	} else if(curlen != 0) {
-	    if(curlen != prevlen) {
-		zip_SEND_CODE(curlen, zip_bl_tree);
-		count--;
-	    }
-	    // Assert(count >= 3 && count <= 6, " 3_6?");
-	    zip_SEND_CODE(zip_REP_3_6, zip_bl_tree);
-	    zip_send_bits(count - 3, 2);
-	} else if(count <= 10) {
-	    zip_SEND_CODE(zip_REPZ_3_10, zip_bl_tree);
-	    zip_send_bits(count-3, 3);
-	} else {
-	    zip_SEND_CODE(zip_REPZ_11_138, zip_bl_tree);
-	    zip_send_bits(count-11, 7);
-	}
-	count = 0;
-	prevlen = curlen;
-	if(nextlen == 0) {
-	    max_count = 138;
-	    min_count = 3;
-	} else if(curlen == nextlen) {
-	    max_count = 6;
-	    min_count = 3;
-	} else {
-	    max_count = 7;
-	    min_count = 4;
-	}
-    }
-}
-
-/* ==========================================================================
- * Construct the Huffman tree for the bit lengths and return the index in
- * bl_order of the last bit length code to send.
- */
-var zip_build_bl_tree = function() {
-    var max_blindex;  // index of last bit length code of non zero freq
-
-    // Determine the bit length frequencies for literal and distance trees
-    zip_scan_tree(zip_dyn_ltree, zip_l_desc.max_code);
-    zip_scan_tree(zip_dyn_dtree, zip_d_desc.max_code);
-
-    // Build the bit length tree:
-    zip_build_tree(zip_bl_desc);
-    /* opt_len now includes the length of the tree representations, except
-     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
-     */
-
-    /* Determine the number of bit length codes to send. The pkzip format
-     * requires that at least 4 bit length codes be sent. (appnote.txt says
-     * 3 but the actual value used is 4.)
-     */
-    for(max_blindex = zip_BL_CODES-1; max_blindex >= 3; max_blindex--) {
-	if(zip_bl_tree[zip_bl_order[max_blindex]].dl != 0) break;
-    }
-    /* Update opt_len to include the bit length tree and counts */
-    zip_opt_len += 3*(max_blindex+1) + 5+5+4;
-//    Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
-//	    encoder->opt_len, encoder->static_len));
-
-    return max_blindex;
-}
-
-/* ==========================================================================
- * Send the header for a block using dynamic Huffman trees: the counts, the
- * lengths of the bit length codes, the literal tree and the distance tree.
- * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
- */
-var zip_send_all_trees = function(lcodes, dcodes, blcodes) { // number of codes for each tree
-    var rank; // index in bl_order
-
-//    Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
-//    Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
-//	    "too many codes");
-//    Tracev((stderr, "\nbl counts: "));
-    zip_send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt
-    zip_send_bits(dcodes-1,   5);
-    zip_send_bits(blcodes-4,  4); // not -3 as stated in appnote.txt
-    for(rank = 0; rank < blcodes; rank++) {
-//      Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
-	zip_send_bits(zip_bl_tree[zip_bl_order[rank]].dl, 3);
-    }
-
-    // send the literal tree
-    zip_send_tree(zip_dyn_ltree,lcodes-1);
-
-    // send the distance tree
-    zip_send_tree(zip_dyn_dtree,dcodes-1);
-}
-
-/* ==========================================================================
- * Determine the best encoding for the current block: dynamic trees, static
- * trees or store, and output the encoded block to the zip file.
- */
-var zip_flush_block = function(eof) { // true if this is the last block for a file
-    var opt_lenb, static_lenb; // opt_len and static_len in bytes
-    var max_blindex;	// index of last bit length code of non zero freq
-    var stored_len;	// length of input block
-
-    stored_len = zip_strstart - zip_block_start;
-    zip_flag_buf[zip_last_flags] = zip_flags; // Save the flags for the last 8 items
-
-    // Construct the literal and distance trees
-    zip_build_tree(zip_l_desc);
-//    Tracev((stderr, "\nlit data: dyn %ld, stat %ld",
-//	    encoder->opt_len, encoder->static_len));
-
-    zip_build_tree(zip_d_desc);
-//    Tracev((stderr, "\ndist data: dyn %ld, stat %ld",
-//	    encoder->opt_len, encoder->static_len));
-    /* At this point, opt_len and static_len are the total bit lengths of
-     * the compressed block data, excluding the tree representations.
-     */
-
-    /* Build the bit length tree for the above two trees, and get the index
-     * in bl_order of the last bit length code to send.
-     */
-    max_blindex = zip_build_bl_tree();
-
-    // Determine the best encoding. Compute first the block length in bytes
-    opt_lenb	= (zip_opt_len   +3+7)>>3;
-    static_lenb = (zip_static_len+3+7)>>3;
-
-//    Trace((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u dist %u ",
-//	   opt_lenb, encoder->opt_len,
-//	   static_lenb, encoder->static_len, stored_len,
-//	   encoder->last_lit, encoder->last_dist));
-
-    if(static_lenb <= opt_lenb)
-	opt_lenb = static_lenb;
-    if(stored_len + 4 <= opt_lenb // 4: two words for the lengths
-       && zip_block_start >= 0) {
-	var i;
-
-	/* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
-	 * Otherwise we can't have processed more than WSIZE input bytes since
-	 * the last block flush, because compression would have been
-	 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
-	 * transform a block into a stored block.
-	 */
-	zip_send_bits((zip_STORED_BLOCK<<1)+eof, 3);  /* send block type */
-	zip_bi_windup();		 /* align on byte boundary */
-	zip_put_short(stored_len);
-	zip_put_short(~stored_len);
-
-      // copy block
-/*
-      p = &window[block_start];
-      for(i = 0; i < stored_len; i++)
-	put_byte(p[i]);
-*/
-	for(i = 0; i < stored_len; i++)
-	    zip_put_byte(zip_window[zip_block_start + i]);
-
-    } else if(static_lenb == opt_lenb) {
-	zip_send_bits((zip_STATIC_TREES<<1)+eof, 3);
-	zip_compress_block(zip_static_ltree, zip_static_dtree);
-    } else {
-	zip_send_bits((zip_DYN_TREES<<1)+eof, 3);
-	zip_send_all_trees(zip_l_desc.max_code+1,
-			   zip_d_desc.max_code+1,
-			   max_blindex+1);
-	zip_compress_block(zip_dyn_ltree, zip_dyn_dtree);
-    }
-
-    zip_init_block();
-
-    if(eof != 0)
-	zip_bi_windup();
-}
-
-/* ==========================================================================
- * Save the match info and tally the frequency counts. Return true if
- * the current block must be flushed.
- */
-var zip_ct_tally = function(
-	dist, // distance of matched string
-	lc) { // match length-MIN_MATCH or unmatched char (if dist==0)
-    zip_l_buf[zip_last_lit++] = lc;
-    if(dist == 0) {
-	// lc is the unmatched char
-	zip_dyn_ltree[lc].fc++;
-    } else {
-	// Here, lc is the match length - MIN_MATCH
-	dist--;		    // dist = match distance - 1
-//      Assert((ush)dist < (ush)MAX_DIST &&
-//	     (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
-//	     (ush)D_CODE(dist) < (ush)D_CODES,  "ct_tally: bad match");
-
-	zip_dyn_ltree[zip_length_code[lc]+zip_LITERALS+1].fc++;
-	zip_dyn_dtree[zip_D_CODE(dist)].fc++;
-
-	zip_d_buf[zip_last_dist++] = dist;
-	zip_flags |= zip_flag_bit;
-    }
-    zip_flag_bit <<= 1;
-
-    // Output the flags if they fill a byte
-    if((zip_last_lit & 7) == 0) {
-	zip_flag_buf[zip_last_flags++] = zip_flags;
-	zip_flags = 0;
-	zip_flag_bit = 1;
-    }
-    // Try to guess if it is profitable to stop the current block here
-    if(zip_compr_level > 2 && (zip_last_lit & 0xfff) == 0) {
-	// Compute an upper bound for the compressed length
-	var out_length = zip_last_lit * 8;
-	var in_length = zip_strstart - zip_block_start;
-	var dcode;
-
-	for(dcode = 0; dcode < zip_D_CODES; dcode++) {
-	    out_length += zip_dyn_dtree[dcode].fc * (5 + zip_extra_dbits[dcode]);
-	}
-	out_length >>= 3;
-//      Trace((stderr,"\nlast_lit %u, last_dist %u, in %ld, out ~%ld(%ld%%) ",
-//	     encoder->last_lit, encoder->last_dist, in_length, out_length,
-//	     100L - out_length*100L/in_length));
-	if(zip_last_dist < parseInt(zip_last_lit/2) &&
-	   out_length < parseInt(in_length/2))
-	    return true;
-    }
-    return (zip_last_lit == zip_LIT_BUFSIZE-1 ||
-	    zip_last_dist == zip_DIST_BUFSIZE);
-    /* We avoid equality with LIT_BUFSIZE because of wraparound at 64K
-     * on 16 bit machines and because stored blocks are restricted to
-     * 64K-1 bytes.
-     */
-}
-
-  /* ==========================================================================
-   * Send the block data compressed using the given Huffman trees
-   */
-var zip_compress_block = function(
-	ltree,	// literal tree
-	dtree) {	// distance tree
-    var dist;		// distance of matched string
-    var lc;		// match length or unmatched char (if dist == 0)
-    var lx = 0;		// running index in l_buf
-    var dx = 0;		// running index in d_buf
-    var fx = 0;		// running index in flag_buf
-    var flag = 0;	// current flags
-    var code;		// the code to send
-    var extra;		// number of extra bits to send
-
-    if(zip_last_lit != 0) do {
-	if((lx & 7) == 0)
-	    flag = zip_flag_buf[fx++];
-	lc = zip_l_buf[lx++] & 0xff;
-	if((flag & 1) == 0) {
-	    zip_SEND_CODE(lc, ltree); /* send a literal byte */
-//	Tracecv(isgraph(lc), (stderr," '%c' ", lc));
-	} else {
-	    // Here, lc is the match length - MIN_MATCH
-	    code = zip_length_code[lc];
-	    zip_SEND_CODE(code+zip_LITERALS+1, ltree); // send the length code
-	    extra = zip_extra_lbits[code];
-	    if(extra != 0) {
-		lc -= zip_base_length[code];
-		zip_send_bits(lc, extra); // send the extra length bits
-	    }
-	    dist = zip_d_buf[dx++];
-	    // Here, dist is the match distance - 1
-	    code = zip_D_CODE(dist);
-//	Assert (code < D_CODES, "bad d_code");
-
-	    zip_SEND_CODE(code, dtree);	  // send the distance code
-	    extra = zip_extra_dbits[code];
-	    if(extra != 0) {
-		dist -= zip_base_dist[code];
-		zip_send_bits(dist, extra);   // send the extra distance bits
-	    }
-	} // literal or match pair ?
-	flag >>= 1;
-    } while(lx < zip_last_lit);
-
-    zip_SEND_CODE(zip_END_BLOCK, ltree);
-}
-
-/* ==========================================================================
- * Send a value on a given number of bits.
- * IN assertion: length <= 16 and value fits in length bits.
- */
-var zip_Buf_size = 16; // bit size of bi_buf
-var zip_send_bits = function(
-	value,	// value to send
-	length) {	// number of bits
-    /* If not enough room in bi_buf, use (valid) bits from bi_buf and
-     * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
-     * unused bits in value.
-     */
-    if(zip_bi_valid > zip_Buf_size - length) {
-	zip_bi_buf |= (value << zip_bi_valid);
-	zip_put_short(zip_bi_buf);
-	zip_bi_buf = (value >> (zip_Buf_size - zip_bi_valid));
-	zip_bi_valid += length - zip_Buf_size;
-    } else {
-	zip_bi_buf |= value << zip_bi_valid;
-	zip_bi_valid += length;
-    }
-}
-
-/* ==========================================================================
- * Reverse the first len bits of a code, using straightforward code (a faster
- * method would use a table)
- * IN assertion: 1 <= len <= 15
- */
-var zip_bi_reverse = function(
-	code,	// the value to invert
-	len) {	// its bit length
-    var res = 0;
-    do {
-	res |= code & 1;
-	code >>= 1;
-	res <<= 1;
-    } while(--len > 0);
-    return res >> 1;
-}
-
-/* ==========================================================================
- * Write out any remaining bits in an incomplete byte.
- */
-var zip_bi_windup = function() {
-    if(zip_bi_valid > 8) {
-	zip_put_short(zip_bi_buf);
-    } else if(zip_bi_valid > 0) {
-	zip_put_byte(zip_bi_buf);
-    }
-    zip_bi_buf = 0;
-    zip_bi_valid = 0;
-}
-
-var zip_qoutbuf = function() {
-    if(zip_outcnt != 0) {
-	var q, i;
-	q = zip_new_queue();
-	if(zip_qhead == null)
-	    zip_qhead = zip_qtail = q;
-	else
-	    zip_qtail = zip_qtail.next = q;
-	q.len = zip_outcnt - zip_outoff;
-//      System.arraycopy(zip_outbuf, zip_outoff, q.ptr, 0, q.len);
-	for(i = 0; i < q.len; i++)
-	    q.ptr[i] = zip_outbuf[zip_outoff + i];
-	zip_outcnt = zip_outoff = 0;
-    }
-}
-
-var zip_deflate = function(str, level) {
-    var i, j;
-
-    zip_deflate_data = str;
-    zip_deflate_pos = 0;
-    if(typeof level == "undefined")
-	level = zip_DEFAULT_LEVEL;
-    zip_deflate_start(level);
-
-    var buff = new Array(1024);
-    var aout = [];
-    while((i = zip_deflate_internal(buff, 0, buff.length)) > 0) {
-	var cbuf = new Array(i);
-	for(j = 0; j < i; j++){
-	    cbuf[j] = String.fromCharCode(buff[j]);
-	}
-	aout[aout.length] = cbuf.join("");
-    }
-    zip_deflate_data = null; // G.C.
-    return aout.join("");
-}
-
-if (! window.RawDeflate) RawDeflate = {};
-RawDeflate.deflate = zip_deflate;
-
-})();
-
-
-
-/* Main object */
-Git = {
-  OBJECT_TYPES: ["tag", "commit", "tree", "blob"],
-  REMOTE_TYPE: "HttpRemote",
-  
-  // Print an error either to the console if in node, or to div#jsgit-errors
-  // if in the client.
-  handleError: function(message) {
-    if (jsGitInNode) {
-      console.log(message)
-    }
-    else {
-      $('#jsgit-errors').append(message)
-    }
-  },
-  
-  // Turn an array of bytes into a String
-  bytesToString: function(bytes) {
-    var result = "";
-    var i;
-    for (i = 0; i < bytes.length; i++) {
-      result = result.concat(String.fromCharCode(bytes[i]));
-    }
-    return result;
-  },
-  
-  stringToBytes: function(string) {
-    var bytes = []; 
-    var i; 
-    for(i = 0; i < string.length; i++) {
-      bytes.push(string.charCodeAt(i) & 0xff);
-    }
-    return bytes;
-  },
-    
-  toBinaryString: function(binary) {
-    if (Array.isArray(binary)) {
-      return Git.bytesToString(binary)
-    }
-    else {
-      return binary
-    }
-  },
-    
-  // returns the next pkt-line
-  nextPktLine: function(data) {
-    var length = parseInt(data.substring(0, 4), 16);
-    return data.substring(4, length);
-  },
-  
-  // zlib files contain a two byte header. (RFC 1950)
-  stripZlibHeader: function(zlib) {
-    return zlib.slice(2)
-  },
-  
-  escapeHTML: function(s) {
-    return s
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;');
-  }
-}
-
-
-
-
-// A parser for the response to /git-upload-pack, which contains some
-// progress information and a pack file. Delegates parsing the packfile to 
-// the packFileParser.
-// 
-// Has methods parse, getRemoteLines and getObjects.
-Git.UploadPackParser = function(binary) {
-  var binaryString = Git.toBinaryString(binary)
-  var data   = new BinaryFile(binaryString);
-  var offset = 0;
-  var remoteLines = null;
-  var objects = null;
-  
-  var peek = function(length) {
-    return data.slice(offset, offset + length);
-  };
-  
-  var advance = function(length) {
-    offset += length;
-  };
-  
-  // A pkt-line is defined in http://git-scm.com/gitserver.txt
-  var nextPktLine = function() {
-    var pktLine = null;
-    var length;
-    length = parseInt(Git.bytesToString(peek(4)), 16);
-    advance(4);
-    if (length == 0) {
-    //   return nextPktLine()
-    } else {
-      pktLine = peek(length - 4);
-      advance(length - 4);
-    }
-    return pktLine;
-  };
-  
-  this.getRemoteLines = function() {
-    return remoteLines;
-  };
-  
-  this.getObjects = function() {
-    return objects;
-  };
-  
-  this.parse = function() {
-    console.log("Parsing upload pack of  " + binaryString.length + " bytes")
-    var startTime = new Date()
-    var pktLine = nextPktLine()
-    var packFileParser
-    var remoteLine = ""
-    var packData = ""
-    var gotAckOrNak = false
-    
-    while (Git.bytesToString(pktLine).slice(0, 7) === "shallow") {
-      pktLine = nextPktLine()
-    }
-    while (Git.bytesToString(pktLine) === "NAK\n" || 
-            Git.bytesToString(pktLine).slice(0, 3) === "ACK") {
-      pktLine = nextPktLine()
-      gotAckOrNak = true
-    }
-    
-    if (!gotAckOrNak) {
-      throw(Error("got neither ACK nor NAK in upload pack response"))
-    }
-    
-    while (pktLine !== null) {
-      // sideband format. "2" indicates progress messages, "1" pack data
-      if (pktLine[0] == 2) {
-        var lineString = Git.bytesToString(pktLine)
-        lineString = lineString.slice(1, lineString.length)
-        remoteLine += lineString
-      }
-      else if (pktLine[0] == 1) {
-        packData += Git.bytesToString(pktLine.slice(1))
-      }
-      else if (pktLine[0] == 3) {
-        throw(Error("fatal error in packet line"))
-      }
-      pktLine = nextPktLine()
-    }
-    
-    packFileParser = new Git.Pack(packData)
-    packFileParser.parseAll()
-    objects = packFileParser.getObjects()
-          
-    remoteLines = []
-    var newLineLines = remoteLine.split("\n")
-    for (var i = 0; i < newLineLines.length; i++) {
-      var crLines = newLineLines[i].split("\r")
-      var newRemoteLine = crLines[crLines.length - 1]
-      if (newRemoteLine !== "") {
-        remoteLines.push(newRemoteLine)
-      }
-    }
-    console.log("took " + (new Date().getTime() - startTime.getTime()) + "ms")
-  };
-}
-
-
-
-
-
-// Encapsulates a pack file, with methods to extract objects:
-//
-//  getObjectAtOffset(offset)
-//
-// Also the entire file can be parsed, but this can take quite
-// some time for all but the smallest pack files.
-//
-//  parseAll()
-Git.Pack = function(binary) {
-  var binaryString = Git.toBinaryString(binary)
-  var data = new BinaryFile(binaryString)
-  var offset = 0
-  var objects = null
-  
-  if (typeof require === "undefined") {
-    var myDebug = function(obj) { console.log(obj) }
-  }
-  else {
-    var myDebug = require('util').debug
-  }
-  
-  var peek = function(length) {
-    return data.slice(offset, offset + length)
-  }
-  
-  var rest = function() {
-    return data.slice(offset)
-  }
-  
-  var advance = function(length) {
-    offset += length
-  }
-  
-  var matchPrefix = function() {
-    if (Git.bytesToString(peek(4)) === "PACK") {
-      advance(4)
-    }
-    else {
-      throw(Error("couldn't match PACK"))
-    }
-  }
-  
-  var matchVersion = function(expectedVersion) {
-    var actualVersion = peek(4)[3]
-    advance(4)
-    if (actualVersion !== expectedVersion) {
-      throw("expected packfile version " + expectedVersion + ", but got " + actualVersion)
-    }
-  }
-  
-  var matchNumberOfObjects = function() {
-    var num = 0
-    _(peek(4)).each(function(b) {
-      num = num << 8
-      num += b
-    })
-    advance(4);
-    return num;
-  }
-  
-  var objectSizeInfosToSize = function(sizeInfos) {
-    var current = 0,
-        currentShift = 0,
-        i,
-        sizeInfo;
-        
-    for (i = 0; i < sizeInfos.length; i++) {
-      sizeInfo = sizeInfos[i]
-      current += (parseInt(sizeInfo, 2) << currentShift)
-      currentShift += sizeInfo.length
-    }
-    return current
-  }
-  
-  var getType = function(typeStr) {
-    return {
-      "001":"commit",
-      "010":"tree",
-      "011":"blob",
-      "100":"tag",
-      "110":"ofs_delta",
-      "111":"ref_delta"
-      }[typeStr]
-  }
-    
-  var matchObjectHeader = function() {
-    var sizeInfos       = []
-    var hintTypeAndSize = peek(1)[0].toString(2).rjust(8, "0")
-    var typeStr         = hintTypeAndSize.slice(1, 4)
-    var needMore        = (hintTypeAndSize[0] == "1")
-    var hintAndSize     = null
-    var objectStartOffset = offset
-    
-    sizeInfos.push(hintTypeAndSize.slice(4, 8))
-    advance(1)
-
-    while (needMore) {
-      hintAndSize = peek(1)[0].toString(2).rjust(8, "0")
-      needMore    = (hintAndSize[0] == "1")
-      sizeInfos.push(hintAndSize.slice(1))
-      advance(1)
-    }
-    return {size:objectSizeInfosToSize(sizeInfos), type:getType(typeStr), offset: objectStartOffset}
-  }
-  
-  // Defined in RFC 1950
-  var adler32 = function(string) {
-    var s1 = 1,
-        s2 = 0,
-        i;
-    var bytes = Git.stringToBytes(string)
-    for(i = 0; i < bytes.length; i++) {
-      s1 = s1 + bytes[i]
-      s2 = s2 + s1
-      s1 = s1 % 65521
-      s2 = s2 % 65521
-    }
-    return s2*65536 + s1
-  }
-  
-  var intToBytes = function(val, atLeast) {
-    var bytes = []
-    var current = val
-    while (current > 0) { 
-      bytes.push(current % 256)
-      current = Math.floor(current / 256)
-    }
-    while (atLeast && bytes.length < atLeast) {
-      bytes.push(0)
-    }
-    return bytes.reverse()
-  }
-  
-  var matchBytes = function(bytes) {
-    var i
-    var nextByte
-    for (i = 0; i < bytes.length; i++) {
-      nextByte = peek(1)[0]
-      if (nextByte !== bytes[i]) {
-        throw(Error("adler32 checksum didn't match"))
-      }
-      advance(1)
-    }
-  }
-  
-  var advanceToBytes = function(bytes) {
-    var nextByte
-    var matchedByteCount = 0
-    while (matchedByteCount < bytes.length) {
-      nextByte = peek(1)[0]
-      if (nextByte == bytes[matchedByteCount]) {
-        matchedByteCount++
-      } else {
-        matchedByteCount = 0
-      }
-      advance(1)
-    }
-  }
-  
-  var objectHash = function(type, content) {
-    var data = type + " " + content.length + "\0" + content
-    // return new SHA1(data).hexdigest()
-    return Sha1.rstr2hex(Sha1.rstr_sha1(data))
-  }
-  
-  var matchOffsetDeltaObject = function(header) {
-    var offsetBytes       = []
-    var hintAndOffsetBits = peek(1)[0].toString(2).rjust(8, "0")
-    var needMore          = (hintAndOffsetBits[0] == "1")
-    
-    offsetBytes.push(hintAndOffsetBits.slice(1, 8))
-    advance(1)
-
-    while (needMore) {
-      hintAndOffsetBits = peek(1)[0].toString(2).rjust(8, "0")
-      needMore          = (hintAndOffsetBits[0] == "1")
-      offsetBytes.push(hintAndOffsetBits.slice(1, 8))
-      advance(1)
-    }
-    
-    var longOffsetString = _(offsetBytes).reduce(function(memo, byteString) {
-      return memo + byteString
-    }, "")
-    
-    var offsetDelta = parseInt(longOffsetString, 2)
-    var n = 1
-    _(offsetBytes.length - 1).times(function() {
-      offsetDelta += Math.pow(2, 7*n)
-      n += 1
-    })
-
-    var deflated = Git.stripZlibHeader(rest())
-    var uncompressedData = RawDeflate.inflate(Git.bytesToString(deflated))
-    var checksum = adler32(uncompressedData)
-    advance(2 + uncompressedData.compressedLength)
-    matchBytes(intToBytes(checksum, 4))
-    return {
-      type: header.type,
-      sha: null,
-      desiredOffset: header.offset - offsetDelta,
-      offset: header.offset,
-      data: Git.stringToBytes(uncompressedData.toString())
-    }
-  }
-  
-  var matchNonDeltaObject = function(header) {
-    var deflated = Git.stripZlibHeader(rest())
-    var uncompressedData = RawDeflate.inflate(Git.bytesToString(deflated))
-    var checksum = adler32(uncompressedData)
-    advance(2 + uncompressedData.compressedLength)
-    matchBytes(intToBytes(checksum, 4))
-    
-    return {
-      offset: header.offset,
-      type: header.type,
-      sha: objectHash(header.type, uncompressedData),
-      data: uncompressedData.toString()
-    }
-  }
-  
-  var matchObjectData = function(header) {
-    if (header.type == "ofs_delta") {
-      return matchOffsetDeltaObject(header)
-    }
-    else if (header.type == "ref_delta") {
-      var shaBytes = peek(20)
-      advance(20)
-      var sha = _(shaBytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
-      throw(Error("found ref_delta"))
-    }
-    else {
-      return matchNonDeltaObject(header)
-    }
-  }
-  
-  var matchObjectAtOffset = function(startOffset) {
-    offset = startOffset
-    var header = matchObjectHeader()
-    return matchObjectData(header)
-  }
-  
-  var stripOffsetsFromObjects = function() {
-    _(objects).each(function(object) {
-      delete object.offset
-    })
-  }
-  
-  var objectAtOffset = function(offset) {
-    return _(objects).detect(function(obj) { return obj.offset == offset })
-  }
-  
-  var expandOffsetDeltas = function() {
-    _(objects).each(function(object) {
-      expandDelta(object)
-    })
-  }
-  
-  var expandDelta = function(object) {
-    if (object.type == "ofs_delta") {
-      expandOffsetDelta(object)
-    }
-  }
-  
-  var getObjectAtOffset = function(offset) {
-    if (objects) {
-      return objectAtOffset(offset)
-    }
-    var rawObject = matchObjectAtOffset(offset)
-    expandDelta(rawObject)
-    var newObject = Git.objects.make(rawObject.sha, rawObject.type, rawObject.data)
-    return newObject
-  }
-  
-  var expandOffsetDelta = function(object) {
-    var baseObject = getObjectAtOffset(object.desiredOffset)
-    if (baseObject.type == "ofs_delta" || baseObject.type == "ref_delta") {
-      throw(Error("delta pointing to delta, can't handle this yet"))
-    }
-    else {
-      var expandedData = Git.applyDelta(baseObject.data, object.data)
-      object.type = baseObject.type
-      object.fromDelta = {type: "ofs_delta", data: object.data, base: baseObject.sha}
-      delete object.desiredOffset
-      object.data = expandedData
-      object.sha = objectHash(object.type, object.data)
-    }
-  }
-
-  this.parseAll = function() {
-    try {
-      var numObjects
-      var i
-      objects = []
-      
-      matchPrefix()
-      matchVersion(2)
-      numObjects = matchNumberOfObjects()
-      
-      for (i = 0; i < numObjects; i++) {
-        var object = matchObjectAtOffset(offset)
-        objects.push(object)
-      }
-      expandOffsetDeltas()
-      stripOffsetsFromObjects()
-    }
-    catch(e) {
-      console.log("Error caught in pack file parsing data") // + Git.stringToBytes(data.getRawData()))
-      throw(e)
-    }
-    return this
-  }
-  
-  this.getObjects = function() {
-    return objects
-  }
-  
-  this.getObjectAtOffset = getObjectAtOffset
-}
-
-
-
-Git.MemoryRepo = function() {
-  var refs = {}
-  var that = {}
-  var remotes = {}
-  var objects = {}
-
-  that.getRef = function(refname) {
-    return refs[refname]
-  }
-  
-  that.getRefs = function() {
-    return _(refs).values()
-  }
-  
-  that.haveRefs = function(refs) {
-    var have = []
-    _(refs).each(function(ref) {
-      if (objects[ref.sha] != null) {
-        have.push(ref)
-      }
-    })
-    return have
-  }
-  
-  that.getAllRefs = function() {
-    return _(that.getRemotes()).reduce(function(memo, remote) {
-      return memo.concat(remote.getRefs())
-    }, that.getRefs())
-  }
-  
-  // Add a ref to this repo. fullName is of the form:
-  //   refs/heads/master or refs/tags/123
-  that.addRef = function(fullName, sha) {
-    var type = fullName.split("/")[1]
-    var name = fullName.split("/")[2]
-    refs[name] = {name:name, sha:sha, remote:null, type:type}
-  }
-  
-  that.getRemote = function(name) {
-    return remotes[name]
-  }
-  
-  that.getRemotes = function() {
-    return _(remotes).values()
-  }
-  
-  that.addRemote = function(name, url) { 
-    remotes[name] = new Git[Git.REMOTE_TYPE](this, name, url)
-  }
-  
-  that.addRemoteObject = function(name, remote) {
-    remotes[name] = remote
-  }
-  
-  that.makeAndAddObject = function(sha, type, content) {
-    objects[sha] = Git.objects.make(sha, type, content)
-    return objects[sha]
-  }
-  
-  that.addObject = function(object) {
-    objects[object.sha] = object
-    return object
-  }
-  
-  that.getObjectShas = function(sha) {
-    return _(objects).keys()
-  }
-  
-  that.objectCount = function() {
-    return _(objects).keys().length
-  }
-  
-  that.getObject = function(sha, callback) {
-    var already = objects[sha]
-    if (already) { return callback(null, already) }
-  
-    var remote = that.getRemotes()[0]
-    remote.getObject(sha, function(object) {
-      if (object) {
-        that.addObject(object)
-      }
-      callback(null, object)
-    })
-  }
-  
-  return that
-}
-
-// Helper for creating Repos for a Github proxy
-Git.GithubProxyRepo = function(username, reponame, password) {
-  var repo = new Git.MemoryRepo()
-  var githubCredentials = "password=" + encodeURI(password) + "&username=" + username
-  var remoteUrl = "http://localhost:3000/" + username + "/" + reponame + ".git?server=" + encodeURI("https://github.com") + "&" + githubCredentials
-  repo.addRemote("origin", remoteUrl)
-  return repo
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Git.Remote = function(repo, name, repoUrl) {
-  this.repo = repo
-  this.name = name
-  this.refs = {}
-  this.url = repoUrl.replace(/\?.*/, "").replace(/\/$/, "")
-  this.urlOptions = Git.Remote.queryParams(repoUrl)
-
-  this.makeUri = function(path, extraOptions) {
-    var uri = this.url + path
-    var options = _(this.urlOptions).extend(extraOptions || {})
-    if (options && _(options).size() > 0) {
-      var optionKeys = _(options).keys()
-      var optionPairs = _(optionKeys).map(function(optionName) {
-        return optionName + "=" + encodeURI(options[optionName])
-      })
-
-      return uri + "?" + optionPairs.join("&")
-    }
-    else {
-      return uri
-    }
-  }
-
-  // Add a ref to this remote. fullName is of the form:
-  //   refs/heads/master or refs/tags/123
-  this.addRef = function(fullName, sha) {
-    var type, name
-    if (fullName.slice(0, 5) == "refs/") {
-      type = fullName.split("/")[1]
-      name = this.name + "/" + fullName.split("/")[2]
-    }
-    else {
-      type = "HEAD"
-      name = this.name + "/" + "HEAD"
-    }
-    this.refs[name] = {name:name, sha:sha, remote:this, type:type}
-  }
-  
-  this.getRefs = function() {
-    return _(this.refs).values()
-  }
-  
-  this.getRef = function(name) {
-    return this.refs[this.name + "/" + name]
-  }
-}
-
-Git.Remote.queryParams = function(uri) {
-  var paramString = uri.split("?")[1]
-  if (!paramString) {
-    return {}
-  }
-  
-  var paramStrings = paramString.split("&")
-  var params = {}
-  _(paramStrings).each(function(paramString) {
-    var pair = paramString.split("=")
-    params[pair[0]] = decodeURI(pair[1])
-  })
-  return params
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Git.HttpRemote = function(repo, name, repoUrl) {
-  Git.Remote.apply(this, [repo, name, repoUrl])
-  
-  this.fetchRefs = function(callback) {
-    var remote = this
-    $.get(
-      this.makeUri('/info/refs'),
-      "",
-      function(data) {
-        var refs = Git.HttpRemote.parseInfoRefs(data)
-        _(refs).each(function(ref) {
-          remote.addRef(ref.name, ref.sha)
-        })
-        if (callback != "undefined") {
-          callback(refs)
-        }
-      }
-    )
-  }
-  
-  this.getObject = function(sha, callback) {
-    if (sha == "" || !sha) { return callback(null) }
-    var remote = this
-    var object = this.getObjectFromCachedPacks(sha)
-    if (object) {
-      return callback(object)
-    }
-    this.fetchObjectLoose(sha, function(object) {
-      if (object) { 
-        callback(object)
-      } else {
-        remote.fetchObjectPacked(sha, callback)
-      }
-    })
-  }
-  
-  this.getObjectFromCachedPacks = function(sha) {
-    var remote = this
-    if (this.packs) {
-      var foundObject = null
-      _(_(this.packs).keys()).each(function(packSha) {
-        var packInfo = remote.packs[packSha]
-        if (packInfo.index && packInfo.pack) {
-          var offset = packInfo.index.getOffset(sha)
-          if (offset) {
-            thisObject = packInfo.pack.getObjectAtOffset(offset)
-            if (thisObject) {
-              foundObject = thisObject
-            }
-          }
-        }
-      })
-      if (foundObject) {
-        return foundObject
-      }
-    }
-  }
-  
-  this.fetchObjectLoose = function(sha, callback) {
-    var uri = this.makeObjectUri(sha)
-    $.ajax({
-      url: uri,
-      type: "GET",
-      beforeSend: function(xhr, settings) {
-        xhr.overrideMimeType('text/plain; charset=x-user-defined')
-      },
-      success: function(data) {
-        callback(Git.HttpRemote.parseObjectData(sha, data))
-      },
-      error: function(xhr) {
-        callback(null)
-      }
-    })
-  }
-  
-  this.fetchObjectPacked = function(sha, callback) {
-    var remote = this
-    this.fetchPackList(function(packs) {
-      _(_(packs).keys()).each(function(packSha) {
-        remote.fetchPackIndex(packSha, function(packIndex) {
-          if (packIndex.getOffset(sha)) {
-            var offset = packIndex.getOffset(sha)
-            remote.fetchPackFile(packSha, function(packFile) {
-              var object = packFile.getObjectAtOffset(offset)
-              callback(object)
-            })
-          }
-        })
-      })
-    })
-  }
-  
-  this.fetchPackList = function(callback) {
-    var remote = this
-    if (remote.packs) {
-      callback(remote.packs)
-    } else {
-      console.log("fetching pack list")
-      var uri = this.makeUri("/objects/info/packs")
-      $.ajax({
-        url: uri, type: "GET", 
-        success: function(data) {
-          remote.packs = {}
-          _(Git.HttpRemote.parsePackList(data)).each(function(packSha) {
-            remote.packs[packSha] = {index: null, pack: null}
-          })
-          callback(remote.packs)
-        }
-      })
-    }
-  }
-  
-  this.fetchPackIndex = function(sha, callback) {
-    if (this.packs && this.packs[sha] && this.packs[sha].index) {
-      callback(this.packs[sha].index)
-    } else {
-      console.log("fetching pack index pack-" + sha + ".idx")
-      var uri = this.makeUri("/objects/pack/pack-" + sha + ".idx")
-      var remote = this
-      $.ajax({
-        url: uri, type: "GET", 
-        beforeSend: function(xhr, settings) {
-          xhr.overrideMimeType('text/plain; charset=x-user-defined')
-        },
-        success: function(data) {
-          var packIndex = new Git.PackIndex(data)
-          remote.packs[sha].index = packIndex
-          callback(packIndex)
-        }
-      })
-    }
-  }
-  
-  this.fetchPackFile = function(sha, callback) {
-    if (this.packs && this.packs[sha] && this.packs[sha].pack) {
-      callback(this.packs[sha].pack)
-    } else {
-      console.log("fetching pack file pack-" + sha + ".pack")
-      var uri = this.makeUri("/objects/pack/pack-" + sha + ".pack")
-      var remote = this
-      $.ajax({
-        url: uri, type: "GET", 
-        beforeSend: function(xhr, settings) {
-          xhr.overrideMimeType('text/plain; charset=x-user-defined')
-        },
-        success: function(data) {
-          var packFile = new Git.Pack(data)
-          remote.packs[sha].pack = packFile
-          callback(packFile)
-        }
-      })
-    }
-  }
-  
-  this.makeObjectUri = function(sha) {
-    return this.makeUri("/objects/" + sha.slice(0, 2) + "/" + sha.slice(2))
-  }
-}
-
-// Parses the contents of the .git/info/refs file
-Git.HttpRemote.parseInfoRefs = function(data) {
-  var lines = data.split("\n")
-  var refs = []
-  _(lines).each(function(line) {
-    if (line !== "") {
-      var tabStops = line.split("\t")
-      var ref = {name: tabStops[1], sha: tabStops[0]}
-      refs.push(ref)
-    }
-  })
-  return refs
-}
-
-Git.HttpRemote.parsePackList = function(data) {
-  var lines = data.split("\n")
-  var packs = []
-  _(lines).each(function(line) {
-    if (line !== "") {
-      var packSha = /pack-(.*)\.pack/.exec(line)[1]
-      packs.push(packSha)
-    }
-  })
-  return packs
-}
-
-Git.HttpRemote.parseObjectData = function(sha, compressedData) {
-  var deflated = Git.stripZlibHeader(Git.stringToBytes(compressedData))
-  var data = new BinaryFile(RawDeflate.inflate(Git.bytesToString(deflated)).toString())
-  var offset = 0
-  
-  var peek = function(length) {
-    return data.slice(offset, offset + length)
-  }
-  
-  var rest = function() {
-    return data.slice(offset)
-  }
-  
-  var advance = function(length) {
-    offset += length
-  }
-  
-  var type = Git.bytesToString(peek(3))
-  advance(3)
-  if (type === "com") {
-    type = "commit"
-    advance(4)
-  } else if (type === "blo") {
-    type = "blob"
-    advance(2)
-  } else if (type === "tre") {
-    type = "tree"
-    advance(2)
-  } else {
-    throw(Error("can't determine type of object"))
-  }
-  
-  var nextByte = -1
-  while (nextByte !== 0) {
-    nextByte = peek(1)[0]
-    advance(1)
-  }
-  return Git.objects.make(sha, type, Git.bytesToString(rest()))
-}
-
-
-
-
-
-
-
-
-
-
-
-Git.SmartHttpRemote = function(repo, name, repoUrl) {
-  Git.Remote.apply(this, [repo, name, repoUrl])
-  
-  this.fetchRefs = function(callback) {
-    var remote = this
-    $.get(
-      this.makeUri('/info/refs', {service: "git-upload-pack"}),
-      "",
-      function(data) {
-        var discInfo = Git.SmartHttpRemote.parseDiscovery(data)
-        var i, ref
-        for (i = 0; i < discInfo.refs.length; i++) {
-          ref = discInfo.refs[i]
-          remote.addRef(ref.name, ref.sha)
-        }
-        if (callback != "undefined") {
-          callback(discInfo.refs)
-        }
-      }
-    )
-  }
-  
-  this.fetchRef = function(wantRef, callback) {
-    var url = this.makeUri('/git-upload-pack')
-    var body = Git.SmartHttpRemote.refWantRequest(wantRef, repo.haveRefs(repo.getAllRefs()))
-    var thisRemote = this
-    $.ajax({
-      url: url,
-      data: body,
-      type: "POST",
-      contentType: "application/x-git-upload-pack-request",
-      beforeSend: function(xhr) {
-        xhr.overrideMimeType('text/plain; charset=x-user-defined')
-      },
-      success: function(data, textStatus, xhr) {
-        var binaryData = xhr.responseText
-        var parser = new Git.UploadPackParser(binaryData)
-        parser.parse()
-        var objectDatas = parser.getObjects()
-        if (!objectDatas) {
-          throw("Upload pack contained no objects! Data is: " + Git.stringToBytes(binaryData).toString())
-        }
-        var i, object
-        var newObjects = []
-        for (i = 0; i < objectDatas.length; i++) {
-          object = objectDatas[i]
-          var newObject = thisRemote.repo.makeAndAddObject(object.sha, object.type, object.data)
-          newObjects.push(newObject)
-        }
-        if (callback != "undefined") {
-          callback(parser.getRemoteLines(), newObjects)
-        }
-      },
-      error: function(xhr, data, e) {
-        Git.displayError("ERROR Status: " + xhr.status + ", response: " + xhr.responseText)
-      }
-    });
-  }
-  
-}
-
-// Parses the response to /info/refs?service=git-upload-pack, which contains ids for
-// refs/heads and a capability listing for this git HTTP server.
-//
-// Returns {capabilities:"...", refs: [{name:"...", sha:"..."}, ...]}
-Git.SmartHttpRemote.parseDiscovery = function(data) {
-  var lines = data.split("\n")
-  var result = {"refs":[]}
-  for ( i = 1; i < lines.length - 1; i++) {
-    thisLine = lines[i]
-    if (i == 1) {
-      var bits = thisLine.split("\0")
-      result["capabilities"] = bits[1]
-      var bits2 = bits[0].split(" ")
-      result["refs"].push({name:bits2[1], sha:bits2[0].substring(8)})
-    }
-    else {
-      var bits2 = thisLine.split(" ")
-      result["refs"].push({name:bits2[1], sha:bits2[0].substring(4)})
-    }
-  }
-  return result
-}
-
-// Constructs the body of a request to /git-upload-pack, specifying a ref
-// we want and a bunch of refs we have.
-//
-// Returns a String
-Git.SmartHttpRemote.refWantRequest = function(wantRef, haveRefs) {
-  var str = "0067want " + wantRef.sha + " multi_ack_detailed side-band-64k thin-pack ofs-delta\n0000"
-  _(haveRefs).each(function(haveRef) {
-    str += "0032have " + haveRef.sha + "\n"
-  })
-  str += "0009done\n"
-  return str
-}
-
-
-
-
-
-
-
-
-
-
-
-
-Git.objects = {
-  CONSTRUCTOR_NAMES:{
-    "blob": "Blob", 
-    "tree": "Tree", 
-    "commit": "Commit", "comm": "Commit",
-    "tag": "Tag", "tag ": "Tag"
-  },
-  
-  make: function(sha, type, content) {
-    var constructor = Git.objects[this.CONSTRUCTOR_NAMES[type]]
-    if (constructor) {
-      return new constructor(sha, content)
-    } else {
-      throw("no constructor for " + type)
-    }
-  },
-  
-  Blob: function(sha, data) {
-    this.type = "blob"
-    this.sha = sha
-    this.data = data
-    this.toString = function() {
-      return data
-    }
-  },
-  
-  Tree: function(sha, data) {
-    this.type = "tree"
-    this.sha = sha
-    this.data = data
-    
-    data = new BinaryFile(data)
-    offset = 0
-
-    var peek = function(length) {
-      return data.slice(offset, offset + length)
-    }
-    
-    var advance = function(length) {
-      offset += length
-    }
-  
-    var collectUntil = function(byte) {
-      var bytes = []
-      var nextByte = peek(1)[0]
-      while (nextByte != 0 && nextByte != byte) {
-        bytes.push(peek(1)[0])
-        advance(1)
-        nextByte = peek(1)[0]
-      }
-      advance(1)
-      if (bytes.length > 0) {
-        return Git.bytesToString(bytes)
-      }
-      else {
-        return false
-      }
-    }
-    
-    var matchMode = function() {
-      var first = collectUntil(Git.stringToBytes(" ")[0])
-      if (!first) return null
-      if (first != "100644" && first != "40000") {
-        first = collectUntil(Git.stringToBytes(" ")[0])
-      }
-      return first
-    }
-    
-    var matchName = function() {
-      return collectUntil(0)
-    }
-    
-    var matchObject = function() {
-      var mode = matchMode()
-      if (!mode) return false
-      mode = mode.rjust(6, "0")
-      var name = matchName()
-      var shaBytes = peek(20)
-      advance(20)
-      var sha = _(shaBytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
-      var type = (mode.slice(0, 3) === "100" ? "blob" : "tree")
-      return {mode: mode, name: name, sha: sha, type: type}
-    }
-    
-    var newObject
-    this.contents = []
-    while (nextObject = matchObject()) {
-      this.contents.push(nextObject)
-    }
-    
-    this.toString = function() {
-      var str = "tree " + sha + "\n"
-      str += "\n"
-      this.contents.forEach(function(e) {
-        str += e.name + (e.type == "tree" ? "/" : "") + "\n"
-      })
-      return str
-    }
-    
-    this.id = function() {
-      return {type: this.type, sha: this.sha, data: this.data, contents:this.contents}
-    }
-    
-    this.asHash = function(tree) {
-      var result = {}
-      _(this.contents).each(function(entry) {
-        result[entry.name] = entry
-      })
-      return result
-    }
-  
-  },
-  
-  Commit: function(sha, data) {
-    this.type = "commit"
-    this.sha = sha
-    this.data = data
-    
-    var lines = data.split("\n")
-    this.tree = lines[0].split(" ")[1]
-    var i = 1
-    this.parents = []
-    while (lines[i].slice(0, 6) === "parent") {
-      this.parents.push(lines[i].split(" ")[1])
-      i += 1
-    }
-    
-    var parseAuthor = function(line) {
-      var match = /^(.*) <(.*)> (\d+) \+\d\d\d\d$/.exec(line)
-      var result = {}
-      
-      result.name = match[1]
-      result.email = match[2]
-      result.timestamp = parseInt(match[3])
-      result.date = new Date(result.timestamp*1000)
-      return result
-    }
-    
-    var authorLine = lines[i].replace("author ", "")
-    this.author = parseAuthor(authorLine)
-    
-    var committerLine = lines[i + 1].replace("committer ", "")
-    this.committer = parseAuthor(committerLine)
-    
-    if (lines[i + 2].split(" ")[0] == "encoding") {
-      this.encoding = lines[i + 2].split(" ")[1]
-    }
-    this.message = _(lines.slice(i + 2, lines.length)).select(function(line) { return line !== ""}).join("\n")
-    
-    this.toString = function() {
-      var str = "commit " + sha + "\n"
-      str += "Author: " + this.author.name + " <" + this.author.email + ">\n"
-      str += "Date:   " + this.author.date +"\n"
-      str += "\n"
-      str += this.message
-      return str
-    }
-  },
-  
-  Tag: function(sha, data) {
-    this.type = "tag"
-    this.sha = sha
-    this.data = data
-  }
-}
-
-
-
-
-
-Git.FileDiff = function(file1, file2, options) {
-  this.lines1 = file1.split("\n")
-  this.lines2 = file2.split("\n")
-  this.diffChunks = Diff.diff_patch(this.lines1, this.lines2)
-  var options = options || {}
-  this.contextLength = options.context || 3
-  
-  this.toInfo = function() {
-    if (file1 === "") {
-      var infoChunk = {offset: 1, lines:[]}
-      _(this.lines2).each(function(line, i) {
-        infoChunk.lines.push({oldIndex: null, newIndex:(i + 1), line: line, type:"added"})
-      })
-      return [infoChunk]
-    }
-    if (file2 === "") {
-      var infoChunk = {offset: 1, lines:[]}
-      _(this.lines1).each(function(line, i) {
-        infoChunk.lines.push({oldIndex: (i + 1), newIndex:null, line: line, type:"removed"})
-      })
-      return [infoChunk]
-    }
-    var infos = []
-    var diff = this
-    var totalAdded = 0
-    var totalRemoved = 0
-    var lastInfoChunk = null
-    var infoChunk = null
-    _(this.diffChunks).each(function(chunk) {
-      var removed = chunk.file1
-      var added   = chunk.file2
-      infoChunk = null
-      var removeContext = null
-      var overlapLength = null
-      var lastLineNewIndex = null
-      if (lastInfoChunk) {
-        var lastLine = lastInfoChunk.lines[lastInfoChunk.lines.length - 1]
-        if (lastLine.oldIndex >= Math.max(removed.offset - diff.contextLength, 0)) {
-          infoChunk = lastInfoChunk
-          overlapLength = lastLine.oldIndex - Math.max(removed.offset - diff.contextLength, 0)
-          removeContext = Math.min(overlapLength, diff.contextLength)
-          lastInfoChunk.lines = lastInfoChunk.lines.slice(0, lastInfoChunk.lines.length - removeContext)
-          lastLineNewIndex = lastInfoChunk.lines[lastInfoChunk.lines.length - 1].newIndex
-        }
-      }
-      infoChunk = infoChunk || {offset: added.offset + 1, lines:[]}
-      var preContextRange = [Math.max(removed.offset - diff.contextLength, 0), Math.max(removed.offset, 0)]
-      var preContext = diff.lines1.slice(preContextRange[0], preContextRange[1])
-      _(preContext).each(function(line, i) {
-        var oldIx = preContextRange[0] + i + 1
-        var newIx = oldIx + totalAdded - totalRemoved
-        if (newIx > lastLineNewIndex) {
-          infoChunk.lines.push({oldIndex: oldIx, newIndex:newIx, line: line, type:"context"})
-        }
-      })
-      
-      if (removed.length > 0) {
-        _(removed.chunk).each(function(line, i) {
-          var oldIx = removed.offset + i + 1
-          infoChunk.lines.push({oldIndex: oldIx, newIndex:null, line: line, type:"removed"})
-        })
-      }
-      
-      if (added.length > 0) {
-        _(added.chunk).each(function(line, i) {
-          var newIx = added.offset + i + 1
-          infoChunk.lines.push({oldIndex: null, newIndex:newIx, line: line, type:"added"})
-        })
-      }
-      
-      var postContextRange = [(added.offset - totalAdded + totalRemoved) + removed.length, (added.offset - totalAdded + totalRemoved) + diff.contextLength + removed.length]
-      var postContext = diff.lines1.slice(postContextRange[0], postContextRange[1])
-      _(postContext).each(function(line, i) {
-        var oldIx = postContextRange[0] + i + 1
-        var newIx = oldIx + added.length - removed.length + totalAdded - totalRemoved
-        infoChunk.lines.push({oldIndex: oldIx, newIndex:newIx, line: line, type:"context"})
-      })
-      totalAdded += added.length
-      totalRemoved += removed.length
-      if (infoChunk !== lastInfoChunk) {
-        infos.push(infoChunk)
-      }
-      lastInfoChunk = infoChunk
-    })
-    return infos
-  }
-  
-  this.info = this.toInfo()
-  
-  this.toString = function() {
-    return "asdf"
-  }
-  
-  this.toHtml = function() {
-    var str = []
-    str.push("  <div class='diff'>")
-    var diff = this
-    _(this.info).each(function(chunk) {
-      _(chunk.lines).each(function(line) {
-        var truncatedLine = Git.escapeHTML(line.line.slice(0, Git.FileDiff.MAX_LINE_CHARS))
-        if (line.type == "context") {
-          var oldIx = line.oldIndex.toString().rjust(2, " ")
-          var newIx = line.newIndex.toString().rjust(2, " ")
-          str.push("<pre class='context'>" + oldIx + " " + newIx + "  " + truncatedLine + "</pre>")
-        } else if (line.type == "added") {
-          var newIx = line.newIndex.toString().rjust(2, " ")
-          str.push("<pre class='added'>" + "   " + newIx + " +" + truncatedLine + "</pre>")
-        } else if (line.type == "removed") {
-          var oldIx = line.oldIndex.toString().rjust(2, " ")
-          str.push("<pre class='removed'>" + oldIx + "    -" + truncatedLine + "</pre>")
-        }
-      })
-    })
-    str.push("</div>")
-    return str.join("\n")
-  }
-  
-  this.stat = function() {
-    var result = {insertions: 0, deletions: 0}
-    _(this.info).each(function(chunk) {
-      _(chunk.lines).each(function(line) {
-        if (line.type == "context") {
-        } else if (line.type == "added") {
-          result.insertions += 1
-        } else if (line.type == "removed") {
-          result.deletions += 1
-        }
-      })
-    })
-    return result
-  }
-}
-
-Git.FileDiff.MAX_LINE_CHARS = 140
-
-
-
-Git.TreeDiff = function(repo, prevTreeSha, thisTreeSha, path) {
-  var that = this
-  that.repo        = repo
-  that.thisTreeSha = thisTreeSha
-  that.prevTreeSha = prevTreeSha
-  that.path        = path || ""
-  that.waitingFor  = 0
-  
-  var changesToHtml = function(changes) {        
-    var str = []
-    str.push("<table class='commit-summary'>")
-    _(changes).each(function(change) {
-      str.push("<tr>")
-      if (change.type == "new") {
-        str.push("<td class='modification new'>new</td><td>" + change.name + "</td>")
-      } else if (change.type == "changed") {
-        str.push("<td class='modification changed'>changed</td><td>" + change.name + "</td>")
-      } else if (change.type == "removed") {
-        str.push("<td class='modification removed'>removed</td><td>" + change.name + "</td>")
-      }
-      str.push("</tr>")
-    })
-    str.push("</table>")
-    str.push("<hr>")
-    
-    _(changes).each(function(change) {
-      str.push("<div class='changed-file'>")
-      str.push("  <div class='filename'><b>" + change.name + "</b></div>")
-      var diff = new Git.FileDiff(change.blob[0], change.blob[1])
-      str.push(diff.toHtml())
-      str.push("</div>")
-    })
-    return str.join("\n")
-  }
-  
-  var changesToStat = function(changes) {        
-    var str = []
-    var result = {insertions: 0, deletions: 0}
-    _(changes).each(function(change) {
-      var diff = new Git.FileDiff(change.blob[0], change.blob[1])
-      var stat = diff.stat()
-      result.insertions += stat.insertions
-      result.deletions  += stat.deletions
-      var changeStr = []
-      changeStr.push(" " + change.name + " |    " + (stat.insertions + stat.deletions) + " ")
-      for(var i = 0; i < stat.insertions; i++) changeStr.push("+")
-      for(var i = 0; i < stat.deletions; i++)  changeStr.push("-")
-      str.push(changeStr.join(""))
-    })
-    str.push(" " + changes.length + " files changed, " + 
-      result.insertions + " insertions(+), " + 
-      result.deletions  + " deletions(-)")
-    
-    return str.join("\n")
-  }
-  
-  that.incWaiting = function() {
-    that.waitingFor += 1
-  }
-  
-  that.decWaiting = function() {
-    that.waitingFor -= 1
-    that.finishIfDone()
-  }
-  
-  that.finishIfDone = function() {
-    if (that.waitingFor == 0 && !that.finished && that.doneAll) {
-      that.finished = true
-      that.callback(that.changes)
-    }
-  }
-  
-  that.finished = false
-  that.doneAll = false
-  that.changes = null
-  
-  that.compareBlobEntry = function(prevBlobEntry, thisBlobEntry) {
-    var generator = that
-    if(!prevBlobEntry) {
-      var name = that.path + thisBlobEntry.name
-      generator.incWaiting()
-      repo.getObject(thisBlobEntry.sha, function(err, thisBlob) {
-        generator.changes.push({type:"new", blob: ["", thisBlob.data], name: name})
-        generator.decWaiting()
-      })
-    } else if (!thisBlobEntry) {
-      var name = that.path + prevBlobEntry.name
-      generator.incWaiting()
-      repo.getObject(prevBlobEntry.sha, function(err, prevBlob) {
-        generator.changes.push({type:"removed", blob: [prevBlob.data, ""], name: name})
-        generator.decWaiting()
-      })
-    } else if (prevBlobEntry.sha != thisBlobEntry.sha) {
-      var name = that.path + thisBlobEntry.name
-      var generator = that
-      generator.incWaiting()
-      repo.getObject(prevBlobEntry.sha, function(err, prevBlob) {
-        repo.getObject(thisBlobEntry.sha, function(err, thisBlob) {
-          generator.changes.push({type:"changed", blob: [prevBlob.data, thisBlob.data], name: name})
-          generator.decWaiting()
-        })
-      })
-    }
-  }
-  
-  that.compareTreeEntry = function(prevTreeEntry, thisTreeEntry) {
-    var generator = that
-    if (!prevTreeEntry) {
-      generator.incWaiting()
-      var subTreeDiff = new Git.TreeDiff(repo, null, thisTreeEntry.sha)
-      subTreeDiff.generateChanges(function(subChanges) {
-        generator.changes = generator.changes.concat(subChanges)
-        generator.decWaiting()
-      }, generator.path + thisTreeEntry.name + "/")
-    } else if (!thisTreeEntry) {
-      generator.incWaiting()
-      var subTreeDiff = new Git.TreeDiff(repo, prevTreeEntry.sha, null)
-      subTreeDiff.generateChanges(function(subChanges) {
-        generator.changes = generator.changes.concat(subChanges)
-        generator.decWaiting()
-      }, generator.path + prevTreeEntry.name + "/")
-    } else if (prevTreeEntry.sha != thisTreeEntry.sha) {
-      generator.incWaiting()
-      var subTreeDiff = new Git.TreeDiff(repo, prevTreeEntry.sha, thisTreeEntry.sha)
-      subTreeDiff.generateChanges(function(subChanges) {
-        generator.changes = generator.changes.concat(subChanges)
-        generator.decWaiting()
-      }, generator.path + thisTreeEntry.name + "/")
-    }
-  }
-  
-  that.compareTrees = function() {
-    var generator = that
-    var prevTreeHash = null
-    var thisTreeHash = null
-    if (that.prevTree) {
-      prevTreeHash = that.prevTree.asHash()
-    } else {
-      prevTreeHash = {}
-    }
-    if (that.thisTree) {
-      thisTreeHash = that.thisTree.asHash()
-    } else {
-      thisTreeHash = {}
-    }
-    var names = _(_(thisTreeHash).keys().concat(_(prevTreeHash).keys())).uniq()
-    _(names).each(function(name) {
-      var prevEntry = prevTreeHash[name]
-      var thisEntry = thisTreeHash[name]
-      var prevType = (prevEntry ? prevEntry.type : null)
-      var thisType = (thisEntry ? thisEntry.type : null)
-      if (prevType == thisType || prevType == null || thisType == null) {
-        var type = prevType || thisType
-        if (type == "blob") {
-          generator.compareBlobEntry(prevEntry, thisEntry)
-        } else if (type == "tree") {
-          generator.compareTreeEntry(prevEntry, thisEntry)
-        }
-      } else {
-        // entry changed from a dir to a file or vice versa
-        if (prevType == "blob" && thisType == "tree") {
-          generator.compareBlobEntry(prevEntry, null)
-          generator.compareTreeEntry(null, thisEntry)
-        }
-      }
-    })
-    that.doneAll = true
-    generator.finishIfDone()
-  }
-  
-  that.toHtml = function(callback) {
-    that.generateChanges(function(changes) {
-      callback(changesToHtml(changes))
-    })
-  }
-  
-  that.toStat = function(callback) {
-    that.generateChanges(function(changes) {
-      callback(null, changesToStat(changes))
-    })
-  }
-  
-  that.generateChanges = function(callback) {
-    if (that.changes === null) {
-      that.callback = callback
-      that.changes = []
-      repo.getObject(that.prevTreeSha, function(err, prevTree) {
-        if (err) return callback(err)
-        
-        that.prevTree = prevTree
-        
-        repo.getObject(that.thisTreeSha, function(err, thisTree) {
-          if (err) return callback(err)
-        
-          that.thisTree = thisTree
-          return that.compareTrees()
-        })
-      })
-    }
-    else {
-      return callback(that.changes)
-    }
-  }
-}
-
-
-
-Git.applyDelta = (function() {
-  var matchLength = function(stream) {
-    var data = stream.data
-    var offset = stream.offset
-    var result = 0
-    var currentShift = 0
-    var _byte = 128
-    var maskedByte, shiftedByte
-    
-    while ((_byte & 128) != 0) {
-      _byte = data[offset]
-      offset += 1
-      maskedByte = _byte & 0x7f
-      shiftedByte = maskedByte << currentShift
-      result += shiftedByte
-      currentShift += 7
-    }
-    stream.offset = offset
-    return result
-  }
-  
-  return function(baseDataString, delta) {
-    var baseData = Git.stringToBytes(baseDataString)
-    var stream = {data: delta, offset: 0, length: delta.length}
-    
-    var baseLength = matchLength(stream)
-    if (baseLength != baseData.length) {
-      throw (Error("Delta Error: base length not equal to length of given base data"))
-    }
-    
-    var resultLength = matchLength(stream)
-    var resultData = ""
-    
-    var copyOffset
-    var copyLength
-    var opcode
-    var copyFromResult
-    while (stream.offset < stream.length) {
-      opcode = stream.data[stream.offset]
-      stream.offset += 1
-      copyOffset = 0
-      copyLength = 0
-      if (opcode == 0) {
-        throw(Error("Don't know what to do with a delta opcode 0"))
-      } else if ((opcode & 0x80) != 0) {
-        var value
-        var shift = 0
-        _(4).times(function() {
-          if ((opcode & 0x01) != 0) {
-            value = stream.data[stream.offset]
-            stream.offset += 1
-            copyOffset += (value << shift)
-          }
-          opcode >>= 1
-          shift += 8
-        })
-        shift = 0
-        _(2).times(function() {
-          if ((opcode & 0x01) != 0) {
-            value = stream.data[stream.offset]
-            stream.offset += 1
-            copyLength += (value << shift)
-          }
-          opcode >>= 1
-          shift += 8
-        })
-        if (copyLength == 0) {
-          copyLength = (1<<16)
-        }
-        
-        // TODO: check if this is a version 2 packfile and apply copyFromResult if so
-        copyFromResult = (opcode & 0x01)
-        resultData += Git.bytesToString(baseData.slice(copyOffset, copyOffset + copyLength))
-        
-      } else if ((opcode & 0x80) == 0) {
-        resultData += Git.bytesToString(stream.data.slice(stream.offset, stream.offset + opcode))
-        stream.offset += opcode
-      }
-    }
-    
-    if (resultLength != resultData.length) {
-      throw (Error("Delta Error: got result length " + resultData.length + ", expected " + resultLength))
-    }
-    return resultData
-  }
-}())
-
-
-
-
-// This object partially parses the data contained in a pack-*.idx file, and provides
-// access to the offsets of the objects the packfile and the crc checksums of the objects.
-Git.PackIndex = function(data) {
-  this.data = new BinaryFile(data)
-  
-  if (!Git.PackIndex.assertVersion(this.data, 2)) {
-    throw(Error("pack index is not version 2"))
-  }
-  
-  this.bytesToInteger = function(bytes) {
-    var val = 0
-    _(bytes).each(function(b) {
-      val += b
-      val *= 256
-    })
-    return val/256
-  }
-  
-  this.bytesToSha = function(bytes) {
-    return _(bytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
-  }
-  
-  this.numObjects = function() {
-    return this.bytesToInteger(this.data.slice(8 + 255*4, 8 + 255*4 + 4))
-  }
-  
-  // Return the offset within the packfile of the object with the given sha.
-  this.getOffset = function(sha) {
-    var numObjects = this.numObjects()
-    var ix = this.indexOfSha(sha)
-    return this.offsets[ix]
-  }
-  
-  // Return the checksum of the object with the given sha.
-  this.getCrc = function(sha) {
-    var numObjects = this.numObjects()
-    var crcArrayOffset = 8 + 256*4 + numObjects*20
-    var ix = this.indexOfSha(sha)
-    var offset = crcArrayOffset + ix*4
-    return this.bytesToInteger(this.data.slice(offset, offset + 4))
-  }
-  
-  // Does this pack index contain 64b offsets?
-  this.has64bOffsets = function() {
-    var numObjects = this.numObjects()
-    var expectedLength = 8 + 256*4 + numObjects*20 + numObjects*4 + numObjects*4 + 40
-    return this.data.length > expectedLength + 7 // 64b offsets are 8 bytes
-  }
-  
-  // Returns the index offset into the sha array which is the first occurrence
-  // of shas with first byte matching the first byte of the given sha.
-  this.fanout = function(sha) {
-    var firstByte = parseInt(sha.slice(0, 2), 16) - 1
-    if (firstByte === -1) {
-      return 0
-    } else {
-      var fanoutBytes = this.data.slice(8 + firstByte*4, 8 + firstByte*4 + 4)
-      return this.bytesToInteger(fanoutBytes)
-    }
-  }
-  
-  // Returns the index of this sha into the three arrays: sha[], crc[] and offset[]
-  this.indexOfSha = function(sha) {
-    var ix = this.fanout(sha)
-    var currentSha = this.shaAtIndex(ix)
-    var firstByte = sha.slice(0, 2)
-    while (currentSha !== sha) {
-      ix++
-      currentSha = this.shaAtIndex(ix)
-      if (ix >= this.numObjects()) {
-        return null
-      } else {
-        if (currentSha.slice(0, 2) !== firstByte) {
-          return null
-        }
-      }
-    }
-    return ix 
-  }
-  
-  // Returns the sha at the given index into the sha array
-  this.shaAtIndex = function(ix) {
-    var shaArrayOffset = 8 + 256*4
-    var offset = shaArrayOffset + ix*20
-    return this.bytesToSha(this.data.slice(offset, offset + 20))
-  }
-  
-  // Extracts the offset array from the data, and gets the maximum offset
-  // Return {offsets: [int], max: int}
-  this.offsetInfo = function() {
-    var offsets = []
-    var numObjects = this.numObjects()
-    var offsetArrayOffset = 8 + 256*4 + numObjects*20 + numObjects*4
-    var i
-    var max = 0
-    for (i = 0; i < numObjects; i++) {
-      var offsetBytes = this.data.slice(offsetArrayOffset + i*4, offsetArrayOffset + i*4 + 4)
-      var offset = this.bytesToInteger(offsetBytes)
-      if (offset > max) { max = offset}
-      offsets.push(offset)
-    }
-    return {offsets: offsets, max: max}
-  }
-  
-  // Returns an estimate (a lower bound) of the size of the packfile. 
-  this.estimatedPackFileSize = function() {
-    return this.maxOffset
-  }
-  
-  var info = this.offsetInfo()
-  this.offsets = info.offsets
-  this.maxOffset = info.max
-}
-
-Git.PackIndex.assertVersion = function(binary, expectedVersion) {
-  var versionBytes = binary.slice(4, 8)
-  return _(versionBytes).isEqual([0, 0, 0, expectedVersion])
-}
diff --git a/lib/git/http.js b/lib/git/http.js
index b906ef6..60f0ae9 100644
--- a/lib/git/http.js
+++ b/lib/git/http.js
@@ -1,7 +1,5 @@
 var get;
 if(typeof XMLHttpRequest !== 'undefined') {
-  var url = require('../../vendor/node_urlparser')
-
   get = function(uri, ready) {
     var xhr = new XMLHttpRequest;
     xhr.onreadystatechange = function() {
diff --git a/lib/git/memory_repo.js b/lib/git/memory_repo.js
index 3403e0e..3e811e6 100644
--- a/lib/git/memory_repo.js
+++ b/lib/git/memory_repo.js
@@ -4,7 +4,6 @@ var HttpRemote = require('./http_remote')
 
 var MemoryRepo = function() {
   this.refs = {}
-  this.that = {}
   this.remotes = {}
   this.objects = {}
 };
@@ -29,9 +28,9 @@ MemoryRepo.prototype.haveRefs = function(refs) {
 }
 
 MemoryRepo.prototype.getAllRefs = function() {
-  return _(that.getRemotes()).reduce(function(memo, remote) {
+  return _(this.getRemotes()).reduce(function(memo, remote) {
     return memo.concat(remote.getRefs())
-  }, that.getRefs())
+  }, this.getRefs())
 }
 
 // Add a ref to this repo. fullName is of the form:
@@ -80,10 +79,11 @@ MemoryRepo.prototype.getObject = function(sha, callback) {
   var already = this.objects[sha]
   if (already) { return callback(null, already) }
 
-  var remote = that.getRemotes()[0]
+  var remote = this.getRemotes()[0]
+    , self = this
   remote.getObject(sha, function(object) {
     if (object) {
-      that.addObject(object)
+      self.addObject(object)
     }
     callback(null, object)
   })
diff --git a/vendor/md5.js b/vendor/md5.js
index bcbad90..88582da 100644
--- a/vendor/md5.js
+++ b/vendor/md5.js
@@ -4,8 +4,9 @@
 *  http://www.webtoolkit.info/
 *
 **/
- 
-MyMD5 = function (string) {
+
+var MyMD5;
+module.exports = MyMD5 = function (string) {
  
 	function RotateLeft(lValue, iShiftBits) {
 		return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits));
@@ -204,4 +205,4 @@ MyMD5 = function (string) {
 	var temp = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);
  
 	return temp.toLowerCase();
-}
\ No newline at end of file
+}

From 490a480f8d19051da0fb76a412a5cd43f2bb1f88 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Mon, 15 Aug 2011 14:12:19 -0500
Subject: [PATCH 13/19] Prepare js-deflate for web workers

---
 vendor/js-deflate/rawdeflate.js | 3 ++-
 vendor/js-deflate/rawinflate.js | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/vendor/js-deflate/rawdeflate.js b/vendor/js-deflate/rawdeflate.js
index 548af68..51f3c9b 100644
--- a/vendor/js-deflate/rawdeflate.js
+++ b/vendor/js-deflate/rawdeflate.js
@@ -1665,6 +1665,7 @@ var zip_deflate = function(str, level) {
     return aout.join("");
 }
 
-module.exports.deflate = zip_deflate;
+module.exports = zip_deflate;
+module.exports.source = arguments.callee.toString();
 
 })();
diff --git a/vendor/js-deflate/rawinflate.js b/vendor/js-deflate/rawinflate.js
index 956bfbd..5f1d55e 100644
--- a/vendor/js-deflate/rawinflate.js
+++ b/vendor/js-deflate/rawinflate.js
@@ -729,7 +729,7 @@ var zip_inflate_internal = function(buff, off, size) {
 
 var zip_inflate = function(str) {
     var i, j;
-
+    
     zip_inflate_start();
     zip_inflate_data = str;
     zip_inflate_pos = 0;
@@ -748,7 +748,7 @@ var zip_inflate = function(str) {
     result.compressedLength = zip_inflate_pos;
     return result;
 }
-
 module.exports = zip_inflate;
+module.exports.source = arguments.callee.toString();
 
 })();

From 2e9e5c47b6409e6b2d0886f6350d40e4598e8bc4 Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Mon, 15 Aug 2011 14:13:05 -0500
Subject: [PATCH 14/19] Add lib/git/zlib.js; will attempt to provide a web
 worker version of js-deflate when possible

---
 lib/git/zlib.js | 54 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 lib/git/zlib.js

diff --git a/lib/git/zlib.js b/lib/git/zlib.js
new file mode 100644
index 0000000..5b34838
--- /dev/null
+++ b/lib/git/zlib.js
@@ -0,0 +1,54 @@
+var inflate = require('../../vendor/js-deflate/rawinflate')
+  , deflate = require('../../vendor/js-deflate/rawdeflate')
+
+var BB = this.BlobBuilder || this.WebKitBlobBuilder || this.MozBlobBuilder
+  , Worker = this.Worker
+  , URL = this.URL || this.webkitURL || this.mozURL;
+
+if(BB && Worker && URL) {
+  var workerize = function(src) {
+    var blobBuilder = new BB()
+      , blob
+      , url
+      , str = ''
+
+    blobBuilder.append('var module = {};(');
+    blobBuilder.append(src);
+    blobBuilder.append(')();('+function() {
+      onmessage = function(ev) {
+        postMessage(module.exports(ev.data, true));
+      };    
+    }+')();')
+
+
+    blob = blobBuilder.getBlob('text/javascript')
+    url = URL.createObjectURL(blob)
+
+    return function(uncompressed, ready) {
+      var worker = new Worker(url)
+
+      worker.addEventListener('message', function(ev) {
+        var data = (function(data) { var a = [], i = 0; while(data[i] !== undefined) a[i] = data[i++]; return a.join(''); })(ev.data);
+        ready(null, data, ev.data.compressedLength)
+      }, false);
+
+      worker.addEventListener('error', function(err) {
+        ready(err);
+      }, false);
+
+      worker.postMessage(uncompressed);
+    };
+  };
+
+  exports.deflate = workerize(deflate.source)
+  exports.inflate = workerize(inflate.source)
+} else {
+  exports.inflate = function(data, ready) {
+    data = inflate(data)
+    var strdata = (function(d) { var a = [], i = 0; while(d[i] !== undefined) a[i] = d[i++]; return a.join(''); })(data)
+    ready(null, strdata, data.compressedLength)
+  }
+  exports.deflate = function(data, ready) {
+    ready(null, deflate(data))
+  } 
+}

From 030656a311d3adbcb0e63d8ad8b3d40b66fe2e5d Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Mon, 15 Aug 2011 14:13:20 -0500
Subject: [PATCH 15/19] Add a nicer 'toString' method to BinaryFile

---
 lib/binary_file.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lib/binary_file.js b/lib/binary_file.js
index 38d7cac..ad1114a 100644
--- a/lib/binary_file.js
+++ b/lib/binary_file.js
@@ -23,6 +23,10 @@ BinaryFile = function(strData, iDataOffset, iDataLength) {
   }
 };
 
+BinaryFile.prototype.toString = function() {
+  return '<BinaryFile: "'+JSON.stringify(this.data.slice(0, 20))+'... ('+this.data.length+')">';
+}
+
 BinaryFile.prototype.getByteAt_CharCode = function(iOffset) {
   return this.data.charCodeAt(iOffset + this.dataOffset) & 0xFF;
 };

From e166fa9f668c301ff199f3e41b51e13f10eccd4f Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Mon, 15 Aug 2011 14:25:33 -0500
Subject: [PATCH 16/19] Rework http.js

---
 lib/git/http.js | 94 +++++++++++++++++++++++++++++++++++++------------
 1 file changed, 72 insertions(+), 22 deletions(-)

diff --git a/lib/git/http.js b/lib/git/http.js
index 60f0ae9..761f679 100644
--- a/lib/git/http.js
+++ b/lib/git/http.js
@@ -1,33 +1,83 @@
-var get;
+var HTTP;
 if(typeof XMLHttpRequest !== 'undefined') {
-  get = function(uri, ready) {
-    var xhr = new XMLHttpRequest;
-    xhr.onreadystatechange = function() {
-      if(xhr.readyState === 4) {
-        if(xhr.status === 200) {
-          ready(null, xhr.responseText)
-        } else ready(new Error('Got a '+xhr.status+' response from '+uri));
+  var HTTP = function(method) {
+    return function(uri, options, ready, body) {
+      typeof options === 'function' ?
+        (ready = options, options = {}) :
+        null;
+
+      var xhr = new XMLHttpRequest;
+      xhr.onreadystatechange = function() {
+        if(xhr.readyState === 4) {
+          if(xhr.status === 200) {
+            ready(null, xhr.responseText)
+          } else ready(new Error('Got a '+xhr.status+' response from '+uri));
+        }
       }
+      xhr.open(
+          method
+        , uri
+        , true
+      )
+
+      xhr.overrideMimeType &&
+        xhr.overrideMimeType('text/plain; charset=x-user-defined')
+
+      for(var key in options) if(options.hasOwnProperty(key)) {
+        xhr.setRequestHeader(key, options[key]);
+      }
+      xhr.send(body || null) 
     }
-    xhr.open(
-        'GET'
-      , uri
-      , true
-    )
-    xhr.send(null) 
   }
+
 } else {
   var http = require('http')
     , url  = require('url')
+    , utils= require('./utils')
 
-  get = function(uri, ready) {
-    var parsed = url.parse(uri)
-    http.request({
-        host  : parsed.hostname
-      , port  : parseInt(parsed.port || 80)
-      , path  : parsed.pathname + parsed.query + parsed.hash
-    }, ready)
+  HTTP = function(method) {
+    return function(uri, headers, ready, body) {
+      typeof headers === 'function' ?
+        (ready = headers, headers = {}) :
+        null;
+
+      var parsed = url.parse(uri)
+        , options = {
+          host  : parsed.hostname
+        , port  : parseInt(parsed.port || 80)
+        , path  : parsed.pathname + (parsed.query ? '?'+parsed.query : '') + (parsed.hash || '')
+        , method: method
+      }
+      var req = http.request(options, function(incoming) {
+        var chunks = []
+        if(incoming.statusCode === 200) {
+          incoming.on('data', chunks.push.bind(chunks))
+          incoming.on('end',  function() {
+            var explicit = chunks.map(function(chunk) {
+              return utils.bytesToString(chunk)
+            }).reduce(function(lhs, rhs) {
+              return lhs + rhs
+            }, '')
+
+            ready(null, explicit) 
+          })
+        } else {
+          ready(new Error('Received HTTP Response '+incoming.statusCode))
+        }
+      })
+
+      Object.keys(headers).forEach(function(key) {
+        req.setHeader(key.toLowerCase(), headers[key])
+      })
+      req.on('error', function(err) {
+        ready(err)   
+      })
+      req.useChunkedEncodingByDefault = false;
+      body && req.write(body)
+      req.end()
+    }
   }
 }
 
-exports.get = get;
+exports.get   = HTTP('GET');
+exports.post  = HTTP('POST');

From 6139427949e058401ceecb6d9fe05e420742f64d Mon Sep 17 00:00:00 2001
From: Chris Dickinson <christopher.s.dickinson@gmail.com>
Date: Mon, 15 Aug 2011 14:26:26 -0500
Subject: [PATCH 17/19] Big rewrite: make zlib.inflate and zlib.deflate async,
 make smart_http_remote work (at least in node), etc, etc, etc.

---
 lib/git/http_remote.js        | 341 +++++++++++++++++-----------------
 lib/git/memory_repo.js        |  16 +-
 lib/git/pack-file.js          |  13 +-
 lib/git/pack.js               | 180 +++++++++++-------
 lib/git/remote.js             |   3 +-
 lib/git/repo.js               |  24 ++-
 lib/git/smart_http_remote.js  |  96 +++++-----
 lib/git/upload_pack_parser.js |  61 +++---
 8 files changed, 393 insertions(+), 341 deletions(-)

diff --git a/lib/git/http_remote.js b/lib/git/http_remote.js
index aa83419..78f7153 100644
--- a/lib/git/http_remote.js
+++ b/lib/git/http_remote.js
@@ -4,169 +4,159 @@ var BinaryFile = require('../binary_file')
   , PackIndex = require('./pack_index')
   , utils = require('./utils')
   , _ = require('underscore')
-  , inflate = require('../../vendor/js-deflate/rawinflate')
+  , inflate = require('./zlib').inflate
   , Objects = require('./objects')
   , http = require('./http')
 
 var HttpRemote = function(repo, name, repoUrl) {
   Remote.call(this, repo, name, repoUrl)
-  
-  this.fetchRefs = function(callback) {
-    var remote = this
-    http.get(
-      this.makeUri('/info/refs'),
-      function(err, data) {
-        var refs = HttpRemote.parseInfoRefs(data)
-        _(refs).each(function(ref) {
-          remote.addRef(ref.name, ref.sha)
-        })
-        if (callback !== undefined) {
-          callback(refs)
-        }
+}
+HttpRemote.prototype = new Remote('','','')
+
+HttpRemote.prototype.fetchRefs = function(callback) {
+  var remote = this
+  http.get(
+    this.makeUri('/info/refs'),
+    function(err, data) {
+      var refs = HttpRemote.parseInfoRefs(data)
+      _(refs).each(function(ref) {
+        remote.addRef(ref.name, ref.sha)
+      })
+      if (callback !== undefined) {
+        callback(null, refs)
       }
-    )
-  }
-  
-  this.getObject = function(sha, callback) {
-    if (sha == "" || !sha) { return callback(null) }
-    var remote = this
-    var object = this.getObjectFromCachedPacks(sha)
-    if (object) {
-      return callback(object)
     }
-    this.fetchObjectLoose(sha, function(object) {
-      if (object) { 
-        callback(object)
+  )
+}
+
+HttpRemote.prototype.getObject = function(sha, callback) {
+  if (sha == "" || !sha) { return callback(null) }
+  var remote = this
+
+  var object = this.getObjectFromCachedPacks(sha, function(err, object) {
+    if(err) return callback(err);
+    if(object) return callback(null, object);
+    remote.fetchObjectLoose(sha, function(err, object) {
+      if (object) {
+        callback(null, object)
       } else {
         remote.fetchObjectPacked(sha, callback)
       }
     })
-  }
-  
-  this.getObjectFromCachedPacks = function(sha) {
-    var remote = this
-    if (this.packs) {
-      var foundObject = null
-      _(_(this.packs).keys()).each(function(packSha) {
-        var packInfo = remote.packs[packSha]
-        if (packInfo.index && packInfo.pack) {
-          var offset = packInfo.index.getOffset(sha)
-          if (offset) {
-            thisObject = packInfo.pack.getObjectAtOffset(offset)
-            if (thisObject) {
-              foundObject = thisObject
-            }
-          }
+  })
+}
+
+HttpRemote.prototype.getObjectFromCachedPacks = function(sha, ready) {
+  var remote = this
+  if (this.packs) {
+    var foundObject = null
+    _(_(this.packs).keys()).each(function(packSha) {
+      var packInfo = remote.packs[packSha]
+      if (packInfo.index && packInfo.pack) {
+        var offset = packInfo.index.getOffset(sha)
+        if (offset) {
+          packInfo.pack.getObjectAtOffset(offset, function(err, thisObject) {
+            ready(err, thisObject)
+          })
         }
-      })
-      if (foundObject) {
-        return foundObject
-      }
-    }
-  }
-  
-  this.fetchObjectLoose = function(sha, callback) {
-    var uri = this.makeObjectUri(sha)
-    $.ajax({
-      url: uri,
-      type: "GET",
-      beforeSend: function(xhr, settings) {
-        xhr.overrideMimeType('text/plain; charset=x-user-defined')
-      },
-      success: function(data) {
-        callback(HttpRemote.parseObjectData(sha, data))
-      },
-      error: function(xhr) {
-        callback(null)
       }
     })
+    if (foundObject) {
+      return foundObject
+    }
+  } else {
+    ready()
   }
-  
-  this.fetchObjectPacked = function(sha, callback) {
-    var remote = this
-    this.fetchPackList(function(packs) {
-      _(_(packs).keys()).each(function(packSha) {
-        remote.fetchPackIndex(packSha, function(packIndex) {
-          if (packIndex.getOffset(sha)) {
-            var offset = packIndex.getOffset(sha)
-            remote.fetchPackFile(packSha, function(packFile) {
-              var object = packFile.getObjectAtOffset(offset)
-              callback(object)
+}
+
+HttpRemote.prototype.fetchObjectLoose = function(sha, callback) {
+  var uri = this.makeObjectUri(sha)
+  http.get(uri, function(err, data) {
+    err ? callback(err) : HttpRemote.parseObjectData(sha, data, function(err, data) {
+      callback(null, data);
+    });
+  })
+}
+
+HttpRemote.prototype.fetchObjectPacked = function(sha, callback) {
+  var remote = this
+  this.fetchPackList(function(err, packs) {
+    if(err) return callback(err);
+
+    var expecting = 0;
+    _(_(packs).keys()).each(function(packSha) {
+      remote.fetchPackIndex(packSha, function(err, packIndex) {
+        var offset = packIndex.getOffset(sha)
+        if (offset) {
+          ++expecting;
+          remote.fetchPackFile(packSha, function(err, packFile) {
+            packFile.getObjectAtOffset(offset, function(err, data) {
+              callback(err, data)
             })
-          }
-        })
-      })
-    })
-  }
-  
-  this.fetchPackList = function(callback) {
-    var remote = this
-    if (remote.packs) {
-      callback(remote.packs)
-    } else {
-      console.log("fetching pack list")
-      var uri = this.makeUri("/objects/info/packs")
-      $.ajax({
-        url: uri, type: "GET", 
-        success: function(data) {
-          remote.packs = {}
-          _(HttpRemote.parsePackList(data)).each(function(packSha) {
-            remote.packs[packSha] = {index: null, pack: null}
           })
-          callback(remote.packs)
         }
       })
-    }
+    })
+
+  })
+}
+
+HttpRemote.prototype.fetchPackList = function(callback) {
+  var remote = this
+  if (remote.packs) {
+    callback(null, remote.packs)
+  } else {
+    var uri = this.makeUri("/objects/info/packs")
+    http.get(uri,  function(err, data) {
+        if(err) return callback(err);
+
+        remote.packs = {}
+        _(HttpRemote.parsePackList(data)).each(function(packSha) {
+          remote.packs[packSha] = {index: null, pack: null}
+        })
+        callback(null, remote.packs)
+    })
   }
-  
-  this.fetchPackIndex = function(sha, callback) {
-    if (this.packs && this.packs[sha] && this.packs[sha].index) {
-      callback(this.packs[sha].index)
-    } else {
-      console.log("fetching pack index pack-" + sha + ".idx")
-      var uri = this.makeUri("/objects/pack/pack-" + sha + ".idx")
-      var remote = this
-      $.ajax({
-        url: uri, type: "GET", 
-        beforeSend: function(xhr, settings) {
-          xhr.overrideMimeType('text/plain; charset=x-user-defined')
-        },
-        success: function(data) {
+}
+
+HttpRemote.prototype.fetchPackIndex = function(sha, callback) {
+  if (this.packs && this.packs[sha] && this.packs[sha].index) {
+    callback(null, this.packs[sha].index)
+  } else {
+    console.log("fetching pack index pack-" + sha + ".idx")
+    var uri = this.makeUri("/objects/pack/pack-" + sha + ".idx")
+    var remote = this
+
+    http.get(uri, function(err, data) {
+        if(!err) {
           var packIndex = new PackIndex(data)
           remote.packs[sha].index = packIndex
-          callback(packIndex)
-        }
-      })
-    }
-  }
-  
-  this.fetchPackFile = function(sha, callback) {
-    if (this.packs && this.packs[sha] && this.packs[sha].pack) {
-      callback(this.packs[sha].pack)
-    } else {
-      console.log("fetching pack file pack-" + sha + ".pack")
-      var uri = this.makeUri("/objects/pack/pack-" + sha + ".pack")
-      var remote = this
-      $.ajax({
-        url: uri, type: "GET", 
-        beforeSend: function(xhr, settings) {
-          xhr.overrideMimeType('text/plain; charset=x-user-defined')
-        },
-        success: function(data) {
-          var packFile = new Pack(data)
-          remote.packs[sha].pack = packFile
-          callback(packFile)
-        }
-      })
-    }
+          callback(null, packIndex)
+        } else callback(err)
+    })
   }
-  
-  this.makeObjectUri = function(sha) {
-    return this.makeUri("/objects/" + sha.slice(0, 2) + "/" + sha.slice(2))
+}
+
+HttpRemote.prototype.fetchPackFile = function(sha, callback) {
+  if (this.packs && this.packs[sha] && this.packs[sha].pack) {
+    callback(null, this.packs[sha].pack)
+  } else {
+    console.log("fetching pack file pack-" + sha + ".pack")
+    var uri = this.makeUri("/objects/pack/pack-" + sha + ".pack")
+    var remote = this
+    http.get(uri, function(err, data) {
+        if(err) return callback(err);
+        var packFile = new Pack(data)
+        remote.packs[sha].pack = packFile
+        callback(null, packFile)
+    })
   }
 }
 
-HttpRemote.prototype = new Remote('','','')
+HttpRemote.prototype.makeObjectUri = function(sha) {
+  return this.makeUri("/objects/" + sha.slice(0, 2) + "/" + sha.slice(2))
+}
+
 
 // Parses the contents of the .git/info/refs file
 HttpRemote.parseInfoRefs = function(data) {
@@ -194,44 +184,47 @@ HttpRemote.parsePackList = function(data) {
   return packs
 }
 
-HttpRemote.parseObjectData = function(sha, compressedData) {
+HttpRemote.parseObjectData = function(sha, compressedData, ready) {
   var deflated = utils.stripZlibHeader(utils.stringToBytes(compressedData))
-  var data = new BinaryFile(inflate(utils.bytesToString(deflated)).toString())
-  var offset = 0
-  
-  var peek = function(length) {
-    return data.slice(offset, offset + length)
-  }
-  
-  var rest = function() {
-    return data.slice(offset)
-  }
-  
-  var advance = function(length) {
-    offset += length
-  }
-  
-  var type = utils.bytesToString(peek(3))
-  advance(3)
-  if (type === "com") {
-    type = "commit"
-    advance(4)
-  } else if (type === "blo") {
-    type = "blob"
-    advance(2)
-  } else if (type === "tre") {
-    type = "tree"
-    advance(2)
-  } else {
-    throw(Error("can't determine type of object"))
-  }
-  
-  var nextByte = -1
-  while (nextByte !== 0) {
-    nextByte = peek(1)[0]
-    advance(1)
-  }
-  return Objects.make(sha, type, utils.bytesToString(rest()))
+
+  inflate(utils.bytesToString(deflated), function(err, data) {
+    var offset = 0
+    
+    var peek = function(length) {
+      return data.slice(offset, offset + length)
+    }
+    
+    var rest = function() {
+      return data.slice(offset)
+    }
+    
+    var advance = function(length) {
+      offset += length
+    }
+    
+    var type = utils.bytesToString(peek(3))
+    advance(3)
+    if (type === "com") {
+      type = "commit"
+      advance(4)
+    } else if (type === "blo") {
+      type = "blob"
+      advance(2)
+    } else if (type === "tre") {
+      type = "tree"
+      advance(2)
+    } else {
+
+      throw new Error("can't determine type of object: "+type+" "+data)
+    }
+    
+    var nextByte = -1
+    while (nextByte !== 0) {
+      nextByte = peek(1)[0]
+      advance(1)
+    }
+    ready(null, Objects.make(sha, type, utils.bytesToString(rest())))
+  });
 }
 
 module.exports = exports = HttpRemote
diff --git a/lib/git/memory_repo.js b/lib/git/memory_repo.js
index 3e811e6..3376f30 100644
--- a/lib/git/memory_repo.js
+++ b/lib/git/memory_repo.js
@@ -19,8 +19,9 @@ MemoryRepo.prototype.getRefs = function() {
 
 MemoryRepo.prototype.haveRefs = function(refs) {
   var have = []
+    , self = this
   _(refs).each(function(ref) {
-    if (this.objects[ref.sha] != null) {
+    if (self.objects[ref.sha] != null) {
       have.push(ref)
     }
   })
@@ -37,7 +38,7 @@ MemoryRepo.prototype.getAllRefs = function() {
 //   refs/heads/master or refs/tags/123
 MemoryRepo.prototype.addRef = function(fullName, sha) {
   var type = fullName.split("/")[1]
-  var name = fullName.split("/")[2]
+  var name = fullName.split("/").slice(2).join('/')
   this.refs[name] = {name:name, sha:sha, remote:null, type:type}
 }
 
@@ -49,8 +50,8 @@ MemoryRepo.prototype.getRemotes = function() {
   return _(this.remotes).values()
 }
 
-MemoryRepo.prototype.addRemote = function(name, url) {
-  this.remotes[name] = new HttpRemote(this, name, url)
+MemoryRepo.prototype.addRemote = function(name, url, remote_class) {
+  this.remotes[name] = new (remote_class || HttpRemote)(this, name, url)
 }
 
 MemoryRepo.prototype.addRemoteObject = function(name, remote) {
@@ -81,11 +82,12 @@ MemoryRepo.prototype.getObject = function(sha, callback) {
 
   var remote = this.getRemotes()[0]
     , self = this
-  remote.getObject(sha, function(object) {
-    if (object) {
+
+  remote.getObject(sha, function(err, object) {
+    if (!err && object) {
       self.addObject(object)
     }
-    callback(null, object)
+    callback(err, object)
   })
 }
 
diff --git a/lib/git/pack-file.js b/lib/git/pack-file.js
index 660c727..21b06d4 100644
--- a/lib/git/pack-file.js
+++ b/lib/git/pack-file.js
@@ -13,7 +13,7 @@ PackFile.prototype.getPackIndex = function(callback) {
   var packPath = path.join(this.repo.gitDir, "objects/pack/pack-" + this.sha + ".idx")
   fs.readFile(packPath, function(err, data) {
     var string = data.toString("binary")
-    callback(new PackIndex(string))
+    callback(err, new PackIndex(string))
   })
 }
 
@@ -21,18 +21,19 @@ PackFile.prototype.getPack = function(callback) {
   var packPath = path.join(this.repo.gitDir, "objects/pack/pack-" + this.sha + ".pack")
   fs.readFile(packPath, function(err, data) {
     var string = data.toString("binary")
-    callback(new Pack(string))
+    callback(err, new Pack(string))
   })
 }
 
 PackFile.prototype.getObject = function(sha, callback) {
   var self = this
-  self.getPackIndex(function(packIndex) {
+  self.getPackIndex(function(err, packIndex) {
     var offset = packIndex.getOffset(sha)
     if (offset) {
-      self.getPack(function(pack) {
-        var object = pack.getObjectAtOffset(offset)
-        callback(object)
+      self.getPack(function(err, pack) {
+        pack.getObjectAtOffset(offset, function(err, object) {
+          callback(err, object)  
+        })
       })
     } else {
       callback(null)
diff --git a/lib/git/pack.js b/lib/git/pack.js
index 16a6393..5392795 100644
--- a/lib/git/pack.js
+++ b/lib/git/pack.js
@@ -1,7 +1,7 @@
 var BinaryFile = require('../binary_file')
   , utils = require('./utils')
   , Sha1 = require('../../vendor/sha1')
-  , inflate = require('../../vendor/js-deflate/rawinflate')
+  , inflate = require('./zlib').inflate
   , applyDelta = require('./delta')
   , Objects = require('./objects')
   , _ = require('underscore')
@@ -49,13 +49,17 @@ var intToBytes = function(val, atLeast) {
 //
 //  parseAll()
 
+var id = 0;
 var Pack = function(binary) {
   this.binaryString = utils.toBinaryString(binary)
   this.data = new BinaryFile(this.binaryString)
   this.offset = 0
   this.objects = null
+  this.id = ++id
 }
 
+Pack.prototype.toString = function() { return '<Pack '+this.id+'>'; }
+
 Pack.prototype.peek = function(length) {
   return this.data.slice(this.offset, this.offset + length)
 }
@@ -146,7 +150,7 @@ Pack.prototype.matchBytes = function(bytes) {
   for (i = 0; i < bytes.length; i++) {
     nextByte = this.peek(1)[0]
     if (nextByte !== bytes[i]) {
-      throw new Error("adler32 checksum didn't match")
+      throw new Error("adler32 checksum didn't match: "+ nextByte + ' : '+ bytes[i])
     }
     this.advance(1)
   }
@@ -167,7 +171,7 @@ Pack.prototype.advanceToBytes = function(bytes) {
   }
 }
 
-Pack.prototype.matchOffsetDeltaObject = function(header) {
+Pack.prototype.matchOffsetDeltaObject = function(header, ready) {
   var offsetBytes       = []
   var hintAndOffsetBits = this.peek(1)[0].toString(2).rjust(8, "0")
   var needMore          = (hintAndOffsetBits[0] == "1")
@@ -194,53 +198,66 @@ Pack.prototype.matchOffsetDeltaObject = function(header) {
   })
 
   var deflated = utils.stripZlibHeader(this.rest())
-  var uncompressedData = inflate(utils.bytesToString(deflated))
-  var checksum = adler32(uncompressedData)
-  this.advance(2 + uncompressedData.compressedLength)
-  this.matchBytes(intToBytes(checksum, 4))
-  return {
-    type: header.type,
-    sha: null,
-    desiredOffset: header.offset - offsetDelta,
-    offset: header.offset,
-    data: utils.stringToBytes(uncompressedData.toString())
-  }
+  var self = this
+    , ofs = self.offset
+  inflate(utils.bytesToString(deflated), function(err, uncompressedData, compressedLength) {
+    if(err) return ready(err);
+    self.offset = ofs
+    var checksum = adler32(uncompressedData)
+
+    self.advance(2 + compressedLength)
+    self.matchBytes(intToBytes(checksum, 4))
+    ready(null, {
+      type: header.type,
+      sha: null,
+      desiredOffset: header.offset - offsetDelta,
+      offset: header.offset,
+      data: utils.stringToBytes(uncompressedData.toString())
+    })
+  })
 }
 
-Pack.prototype.matchNonDeltaObject = function(header) {
-  var deflated = utils.stripZlibHeader(this.rest())
-  var uncompressedData = inflate(utils.bytesToString(deflated))
-  var checksum = adler32(uncompressedData)
-  this.advance(2 + uncompressedData.compressedLength)
-  this.matchBytes(intToBytes(checksum, 4))
-
-  return {
-    offset: header.offset,
-    type: header.type,
-    sha: objectHash(header.type, uncompressedData),
-    data: uncompressedData.toString()
-  }
+Pack.prototype.matchNonDeltaObject = function(header, ready) {
+  var data = this.rest()
+  var deflated = utils.stripZlibHeader(data)
+    , self = this
+    , ofs = self.offset
+
+  inflate(utils.bytesToString(deflated), function(err, uncompressedData, compressedLength) {
+    self.offset = ofs
+    var checksum = adler32(uncompressedData)
+    self.advance(2 + compressedLength)
+
+    self.matchBytes(intToBytes(checksum, 4))
+
+    ready(null, {
+      offset: header.offset,
+      type: header.type,
+      sha: objectHash(header.type, uncompressedData),
+      data: uncompressedData.toString()
+    })
+  })
 }
 
-Pack.prototype.matchObjectData = function(header) {
+Pack.prototype.matchObjectData = function(header, ready) {
   if (header.type == "ofs_delta") {
-    return this.matchOffsetDeltaObject(header)
+    return this.matchOffsetDeltaObject(header, ready)
   }
   else if (header.type == "ref_delta") {
-    var shaBytes = peek(20)
+    var shaBytes = this.peek(20)
     this.advance(20)
     var sha = _(shaBytes).map(function(b) { return b.toString(16).rjust(2, "0")}).join("")
-    throw new Error("found ref_delta")
+    ready(new Error("found ref_delta"))
   }
   else {
-    return this.matchNonDeltaObject(header)
+    this.matchNonDeltaObject(header, ready)
   }
 }
 
-Pack.prototype.matchObjectAtOffset = function(startOffset) {
+Pack.prototype.matchObjectAtOffset = function(startOffset, ready) {
   this.offset = startOffset
   var header = this.matchObjectHeader()
-  return this.matchObjectData(header)
+  this.matchObjectData(header, ready)
 }
 
 Pack.prototype.stripOffsetsFromObjects = function() {
@@ -253,46 +270,61 @@ Pack.prototype.objectAtOffset = function(offset) {
   return _(this.objects).detect(function(obj) { return obj.offset == offset })
 }
 
-Pack.prototype.expandOffsetDeltas = function() {
+Pack.prototype.expandOffsetDeltas = function(ready) {
   var self = this
+  var total = this.objects.length
+
+  process.stderr.write(total + 'objects')
   _(this.objects).each(function(object) {
-    self.expandDelta(object)
+    process.stderr.write('.')
+    self.expandDelta(object, function(err) {
+      --total
+      if(total === 0) {
+        ready() 
+      }
+    })
   })
 }
 
-Pack.prototype.expandDelta = function(object) {
+Pack.prototype.expandDelta = function(object, ready) {
   if (object.type == "ofs_delta") {
-    this.expandOffsetDelta(object)
+    this.expandOffsetDelta(object, ready)
+  } else {
+    ready(null, object);
   }
 }
 
-Pack.prototype.getObjectAtOffset = function(offset) {
+Pack.prototype.getObjectAtOffset = function(offset, ready) {
   if (this.objects) {
-    return this.objectAtOffset(offset)
+    return ready(null, this.objectAtOffset(offset))
   }
-  var rawObject = this.matchObjectAtOffset(offset)
-  this.expandDelta(rawObject)
-
-  var newObject = Objects.make(rawObject.sha, rawObject.type, rawObject.data)
-  return newObject
+  var self = this
+  this.matchObjectAtOffset(offset, function(err, rawObject) {
+    self.expandDelta(rawObject, function(err, object) {
+      ready(null, Objects.make(object.sha, object.type, object.data))    
+    })
+  })
 }
 
-Pack.prototype.expandOffsetDelta = function(object) {
-  var baseObject = this.getObjectAtOffset(object.desiredOffset)
-  if (baseObject.type == "ofs_delta" || baseObject.type == "ref_delta") {
-    throw new Error("delta pointing to delta, can't handle this yet")
-  }
-  else {
-    var expandedData = applyDelta(baseObject.data, object.data)
-    object.type = baseObject.type
-    object.fromDelta = {type: "ofs_delta", data: object.data, base: baseObject.sha}
-    delete object.desiredOffset
-    object.data = expandedData
-    object.sha = objectHash(object.type, object.data)
-  }
+Pack.prototype.expandOffsetDelta = function(object, ready) {
+  this.getObjectAtOffset(object.desiredOffset, function(err, baseObject) {
+    if(err) {
+      ready(err)
+    } else if (baseObject.type == "ofs_delta" || baseObject.type == "ref_delta") {
+      ready(new Error("delta pointing to delta, can't handle this yet"))
+    } else {
+      var expandedData = applyDelta(baseObject.data, object.data)
+      object.type = baseObject.type
+      object.fromDelta = {type: "ofs_delta", data: object.data, base: baseObject.sha}
+      delete object.desiredOffset
+      object.data = expandedData
+      object.sha = objectHash(object.type, object.data)
+      ready(null, object)
+    }
+  })
 }
 
-Pack.prototype.parseAll = function() {
+Pack.prototype.parseAll = function(ready) {
   try {
     var numObjects
     var i
@@ -301,17 +333,33 @@ Pack.prototype.parseAll = function() {
     this.matchPrefix()
     this.matchVersion(2)
     numObjects = this.matchNumberOfObjects()
-
+    var readyCount = 0
+      , self = this
+      , errors = []
+    var onMatched = function(errors) {
+      if(errors.length)
+        ready(errors)
+      else {
+        process.stderr.write('\ndone matching... expanding.')
+        self.expandOffsetDeltas(function() {
+          process.stderr.write('\ndone expanding... stripping.')
+          self.stripOffsetsFromObjects()
+          ready(null, this)
+        })
+      }
+    }
     for (i = 0; i < numObjects; i++) {
-      var object = this.matchObjectAtOffset(this.offset)
-      this.objects.push(object)
+      self.matchObjectAtOffset(self.offset, function(err, object) {
+        process.stderr.write('\r'+readyCount +'/' +numObjects);
+        if(err) errors.push(err)
+        else self.objects.push(object)
+        ++readyCount;
+        readyCount === numObjects && onMatched(errors);
+      })
     }
-    this.expandOffsetDeltas()
-    this.stripOffsetsFromObjects()
   }
   catch(e) {
-    console.log("Error caught in pack file parsing data")
-    throw(e)
+    ready(e)
   }
   return this
 }
diff --git a/lib/git/remote.js b/lib/git/remote.js
index c15f7b4..7b1c551 100644
--- a/lib/git/remote.js
+++ b/lib/git/remote.js
@@ -43,9 +43,10 @@ Remote.prototype.makeUri = function(path, extraOptions) {
 //   refs/heads/master or refs/tags/123
 Remote.prototype.addRef = function(fullName, sha) {
   var type, name
+
   if (fullName.slice(0, 5) == "refs/") {
     type = fullName.split("/")[1]
-    name = this.name + "/" + fullName.split("/")[2]
+    name = this.name + "/" + fullName.split("/").slice(2).join('/')
   }
   else {
     type = "HEAD"
diff --git a/lib/git/repo.js b/lib/git/repo.js
index e26f9c4..572e2d1 100644
--- a/lib/git/repo.js
+++ b/lib/git/repo.js
@@ -3,7 +3,7 @@ var BinaryFile = require('../binary_file')
   , fs   = require('fs')
   , utils = require('./utils')
   , PackFile = require('./pack-file')
-  , inflate = require('../../vendor/js-deflate/rawinflate')
+  , inflate = require('./zlib').inflate
   , Objects = require('./objects')
 
 var firstIndexOfByte = function(bytes, b) {
@@ -39,13 +39,17 @@ Repo.prototype.getLooseObject = function(sha, callback) {
 
     var compressedData = data.toString('binary')
     var deflated = utils.stripZlibHeader(utils.stringToBytes(compressedData))
-    var uncompressedData = new BinaryFile(inflate(utils.bytesToString(deflated)).toString())
-    var result = utils.bytesToString(uncompressedData.slice(0))
-    var objectType = result.slice(0, 4)
-    var objectData = result.slice(firstIndexOfByte(uncompressedData, 0) + 1)
-    var obj = Objects.make(sha, objectType, objectData)
 
-    callback(null, obj)
+    inflate(utils.bytesToString(deflated), function(err, uncompressedData) {
+      uncompressedData = new BinaryFile(uncompressedData)
+
+      var result = utils.bytesToString(uncompressedData.slice(0))
+      var objectType = result.slice(0, 4)
+      var objectData = result.slice(firstIndexOfByte(uncompressedData, 0) + 1)
+      var obj = Objects.make(sha, objectType, objectData)
+      callback(null, obj)
+    })
+
   })
 }
 
@@ -60,7 +64,7 @@ Repo.prototype.getPackFiles = function(callback) {
         packFiles.push(new PackFile(that, match[1]))
       }
     })
-    callback(packFiles)
+    callback(err, packFiles)
   })
 }
 
@@ -78,10 +82,10 @@ Repo.prototype.getObject = function(sha, callback) {
     if (object) {
       return callback(null, object)
     } else {
-      that.getPackFiles(function(packFiles) {
+      that.getPackFiles(function(err, packFiles) {
         for(var i = 0; i < packFiles.length; i++) {
           ;(function(ix) {
-            packFiles[ix].getObject(sha, function(object) {
+            packFiles[ix].getObject(sha, function(err, object) {
               if (object) {
                 return callback(null, object)
               } else {
diff --git a/lib/git/smart_http_remote.js b/lib/git/smart_http_remote.js
index c24eb65..57bbcd3 100644
--- a/lib/git/smart_http_remote.js
+++ b/lib/git/smart_http_remote.js
@@ -1,48 +1,52 @@
-var Remote = require('./remote')
+var HttpRemote = require('./http_remote')
   , UploadPackParser = require('./upload_pack_parser')
   , utils = require('./utils')
+  , _ = require('underscore')
+  , http = require('./http')
 
 var SmartHttpRemote = function(repo, name, repoUrl) {
-  Remote.call(this, repo, name, repoUrl)
-  
-  this.fetchRefs = function(callback) {
-    var remote = this
-    $.get(
-      this.makeUri('/info/refs', {service: "git-upload-pack"}),
-      "",
-      function(data) {
-        var discInfo = SmartHttpRemote.parseDiscovery(data)
-        var i, ref
-        for (i = 0; i < discInfo.refs.length; i++) {
-          ref = discInfo.refs[i]
-          remote.addRef(ref.name, ref.sha)
-        }
-        if (callback !== undefined) {
-          callback(discInfo.refs)
-        }
+  HttpRemote.call(this, repo, name, repoUrl)
+}
+
+SmartHttpRemote.prototype = new HttpRemote('','','')
+
+SmartHttpRemote.prototype.toString = function() { return '<SmartHttpRemote: "'+this.makeUri()+'">'; }
+
+SmartHttpRemote.prototype.fetchRefs = function(callback) {
+  var remote = this
+  http.get(
+    this.makeUri('/info/refs', {service: "git-upload-pack"}),
+    function(err, data) {
+      var discInfo = SmartHttpRemote.parseDiscovery(data)
+      var i, ref
+      for (i = 0; i < discInfo.refs.length; i++) {
+        ref = discInfo.refs[i]
+        remote.addRef(ref.name, ref.sha)
       }
-    )
-  }
-  
-  this.fetchRef = function(wantRef, callback) {
-    var url = this.makeUri('/git-upload-pack')
-    var body = SmartHttpRemote.refWantRequest(wantRef, repo.haveRefs(repo.getAllRefs()))
-    var thisRemote = this
-    $.ajax({
-      url: url,
-      data: body,
-      type: "POST",
-      contentType: "application/x-git-upload-pack-request",
-      beforeSend: function(xhr) {
-        xhr.overrideMimeType('text/plain; charset=x-user-defined')
-      },
-      success: function(data, textStatus, xhr) {
-        var binaryData = xhr.responseText
-        var parser = new UploadPackParser(binaryData)
-        parser.parse()
+      if (callback !== undefined) {
+        callback(discInfo.refs)
+      }
+    }
+  )
+}
+
+SmartHttpRemote.prototype.fetchRef = function(wantRef, callback) {
+  var url = this.makeUri('/git-upload-pack')
+  var body = SmartHttpRemote.refWantRequest(wantRef, this.repo.haveRefs(this.repo.getAllRefs()))
+  var thisRemote = this
+
+  http.post(url, {
+      'Content-Type'  : "application/x-git-upload-pack-request"
+    , 'Accept'        : 'text/plain; charset=x-user-defined'
+    , 'Content-Length': body.length
+    , 'Accept'        : 'text/plain; charset=x-user-defined'
+  }, function(err, data) {
+      var binaryData = data
+      var parser = new UploadPackParser(binaryData)
+      parser.parse(function(err, packFile) {
         var objectDatas = parser.getObjects()
         if (!objectDatas) {
-          throw("Upload pack contained no objects! Data is: " + utils.stringToBytes(binaryData).toString())
+          return callback(err);
         }
         var i, object
         var newObjects = []
@@ -51,19 +55,13 @@ var SmartHttpRemote = function(repo, name, repoUrl) {
           var newObject = thisRemote.repo.makeAndAddObject(object.sha, object.type, object.data)
           newObjects.push(newObject)
         }
-        if (callback !== undefined) {
-          callback(parser.getRemoteLines(), newObjects)
-        }
-      },
-      error: function(xhr, data, e) {
-        utils.displayError("ERROR Status: " + xhr.status + ", response: " + xhr.responseText)
-      }
-    });
-  }
-  
+        thisRemote.repo.getObject(wantRef.sha, callback);
+          
+          
+      })
+  }, body);
 }
 
-SmartHttpRemote = new Remote('','','')
 
 
 // Parses the response to /info/refs?service=git-upload-pack, which contains ids for
diff --git a/lib/git/upload_pack_parser.js b/lib/git/upload_pack_parser.js
index f680337..656e104 100644
--- a/lib/git/upload_pack_parser.js
+++ b/lib/git/upload_pack_parser.js
@@ -3,9 +3,9 @@ var BinaryFile = require('../binary_file')
   , Pack = require('./pack')
 
 // A parser for the response to /git-upload-pack, which contains some
-// progress information and a pack file. Delegates parsing the packfile to 
+// progress information and a pack file. Delegates parsing the packfile to
 // the packFileParser.
-// 
+//
 // Has methods parse, getRemoteLines and getObjects.
 var UploadPackParser = function(binary) {
   var binaryString = utils.toBinaryString(binary)
@@ -13,22 +13,25 @@ var UploadPackParser = function(binary) {
   var offset = 0;
   var remoteLines = null;
   var objects = null;
-  
+
   var peek = function(length) {
     return data.slice(offset, offset + length);
   };
-  
+
   var advance = function(length) {
     offset += length;
   };
-  
+
   // A pkt-line is defined in http://git-scm.com/gitserver.txt
   var nextPktLine = function() {
     var pktLine = null;
     var length;
     length = parseInt(utils.bytesToString(peek(4)), 16);
+
+    if(isNaN(length) || length === 0) return null;
     advance(4);
     if (length == 0) {
+      return null;
     //   return nextPktLine()
     } else {
       pktLine = peek(length - 4);
@@ -36,16 +39,16 @@ var UploadPackParser = function(binary) {
     }
     return pktLine;
   };
-  
+
   this.getRemoteLines = function() {
     return remoteLines;
   };
-  
+
   this.getObjects = function() {
     return objects;
   };
-  
-  this.parse = function() {
+
+  this.parse = function(ready) {
     console.log("Parsing upload pack of  " + binaryString.length + " bytes")
     var startTime = new Date()
     var pktLine = nextPktLine()
@@ -53,20 +56,20 @@ var UploadPackParser = function(binary) {
     var remoteLine = ""
     var packData = ""
     var gotAckOrNak = false
-    
+
     while (utils.bytesToString(pktLine).slice(0, 7) === "shallow") {
       pktLine = nextPktLine()
     }
-    while (utils.bytesToString(pktLine) === "NAK\n" || 
+    while (utils.bytesToString(pktLine) === "NAK\n" ||
             utils.bytesToString(pktLine).slice(0, 3) === "ACK") {
       pktLine = nextPktLine()
       gotAckOrNak = true
     }
-    
+
     if (!gotAckOrNak) {
-      throw(Error("got neither ACK nor NAK in upload pack response"))
+      ready(new Error("got neither ACK nor NAK in upload pack response"))
     }
-    
+
     while (pktLine !== null) {
       // sideband format. "2" indicates progress messages, "1" pack data
       if (pktLine[0] == 2) {
@@ -78,25 +81,27 @@ var UploadPackParser = function(binary) {
         packData += utils.bytesToString(pktLine.slice(1))
       }
       else if (pktLine[0] == 3) {
-        throw(Error("fatal error in packet line"))
+        ready(new Error("fatal error in packet line"))
       }
       pktLine = nextPktLine()
     }
-    
+
     packFileParser = new Pack(packData)
-    packFileParser.parseAll()
-    objects = packFileParser.getObjects()
-          
-    remoteLines = []
-    var newLineLines = remoteLine.split("\n")
-    for (var i = 0; i < newLineLines.length; i++) {
-      var crLines = newLineLines[i].split("\r")
-      var newRemoteLine = crLines[crLines.length - 1]
-      if (newRemoteLine !== "") {
-        remoteLines.push(newRemoteLine)
+    packFileParser.parseAll(function(err, data) {
+      objects = packFileParser.getObjects()
+
+      remoteLines = []
+      var newLineLines = remoteLine.split("\n")
+      for (var i = 0; i < newLineLines.length; i++) {
+        var crLines = newLineLines[i].split("\r")
+        var newRemoteLine = crLines[crLines.length - 1]
+        if (newRemoteLine !== "") {
+          remoteLines.push(newRemoteLine)
+        }
       }
-    }
-    console.log("took " + (new Date().getTime() - startTime.getTime()) + "ms")
+      console.log("took " + (new Date().getTime() - startTime.getTime()) + "ms")
+      ready(null, packFileParser) 
+    })
   };
 }
 

From f70bb3836accda736517d85611aec10adbfaaa92 Mon Sep 17 00:00:00 2001
From: Daniel Lucraft <dan@fluentradical.com>
Date: Thu, 18 Aug 2011 21:07:56 +0100
Subject: [PATCH 18/19] Ensure build directory exists

---
 .gitignore | 4 +++-
 Rakefile   | 3 +--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 8a17e69..2b90e60 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,6 @@ response_body.bin
 test/fixtures/test-repo1/
 test/fixtures/test-repo1-packed
 .DS_store
-demos/serve
\ No newline at end of file
+demos/serve
+build
+node_modules
diff --git a/Rakefile b/Rakefile
index 530dac6..e57eee7 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,6 +1,4 @@
 
-
-
 namespace :test do
   desc "Reset the github test repo"
   task :reset do
@@ -101,6 +99,7 @@ task :package_client do
   end 
 
   total_js = js.join("\n\n")
+  FileUtils.mkdir_p("build")
   File.open("build/git.min.js", "w") {|f| f.puts total_js }
   puts "packaged build/git.min.js"
 end

From 90c134733796ac37ba2e12838cca03bac9d17ec6 Mon Sep 17 00:00:00 2001
From: Daniel Lucraft <dan@fluentradical.com>
Date: Thu, 18 Aug 2011 21:08:22 +0100
Subject: [PATCH 19/19] Don't load diff.js explicitly in the repo-viewer demo
 now it is packaged

---
 demos/repo-viewer/index.html     | 1 -
 demos/repo-viewer/repo-viewer.js | 1 -
 2 files changed, 2 deletions(-)

diff --git a/demos/repo-viewer/index.html b/demos/repo-viewer/index.html
index 26f003f..e2ba1da 100644
--- a/demos/repo-viewer/index.html
+++ b/demos/repo-viewer/index.html
@@ -7,7 +7,6 @@
     <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
     <script src="/git.min.js"></script>
     <script src="repo-viewer.js"></script>
-    <script src="/vendor/diff.js"></script>
     <script src="/vendor/syntaxhighlighter_3.0.83/scripts/shCore.js"></script>
     <script src="/vendor/syntaxhighlighter_3.0.83/scripts/shBrushRuby.js"></script>
     <link rel="stylesheet" href="style.css" type="text/css" media="screen" />
diff --git a/demos/repo-viewer/repo-viewer.js b/demos/repo-viewer/repo-viewer.js
index 1adaec4..f5f8169 100644
--- a/demos/repo-viewer/repo-viewer.js
+++ b/demos/repo-viewer/repo-viewer.js
@@ -4,7 +4,6 @@ var MemoryRepo = Git.require('lib/git/memory_repo')
   , _ = Git.require('underscore')
   , MyMD5 = Git.require('vendor/md5')
 
-console.log(MyMD5)
 RepoViewer = {
   repo: null,