condo 1.0.4 → 1.0.6

data/app/assets/javascripts/condo/md5/hash.worker.emulator.js

@@ -1,23 +1,23 @@
-//= require condo/md5/spark-md5
-//= require condo/md5/hasher
-
-
-function CondoHashWorkerEmulator(callback) {
-	
-	// Create an API that looks like postMessage
-	this.postMessage = function (data, portArray) {
-		hasher.hash(data);	// Clone the data if required JSON.parse(JSON.stringify(message)); // - Don't think it is required
-	}
-	
-	
-	this.terminate = function () {
-		// No special clean-up needed.
-	}
-	
-	function messageEvtEmulator(rawMessage) {
-		callback({ data: rawMessage });
-	}
-	
-	// Create an instance of downloader.
-	var hasher = new CondoMD5Hasher(messageEvtEmulator);
-}
+//= require condo/md5/spark-md5
+//= require condo/md5/hasher
+
+
+function CondoHashWorkerEmulator(callback) {
+	
+	// Create an API that looks like postMessage
+	this.postMessage = function (data, portArray) {
+		hasher.hash(data);	// Clone the data if required JSON.parse(JSON.stringify(message)); // - Don't think it is required
+	}
+	
+	
+	this.terminate = function () {
+		// No special clean-up needed.
+	}
+	
+	function messageEvtEmulator(rawMessage) {
+		callback({ data: rawMessage });
+	}
+	
+	// Create an instance of downloader.
+	var hasher = new CondoMD5Hasher(messageEvtEmulator, false);
+}

data/app/assets/javascripts/condo/md5/hash.worker.js

@@ -1,11 +1,11 @@
-//= require condo/md5/spark-md5
-//= require condo/md5/hasher
-
-
-var hasher = new CondoMD5Hasher(postMessage);	// Accepts the callback as the parameter
-
-
-// Hook-up worker input
-onmessage = function (e) {
-	hasher.hash(e.data);
-}
+//= require condo/md5/spark-md5
+//= require condo/md5/hasher
+
+
+var hasher = new CondoMD5Hasher(postMessage, true);	// Accepts the callback as the parameter
+
+
+// Hook-up worker input
+onmessage = function (e) {
+	hasher.hash(e.data);
+};

data/app/assets/javascripts/condo/md5/hasher.js

@@ -1,100 +1,119 @@
-
-
-var CondoMD5Hasher = (function(global) {
-	
-	var part_size = 1048576,	// This is the amount of the file we read into memory as we are building the hash (1mb)
-		async = true;
-	
-	//
-	// Firefox does not have FileReader in webworkers? WTF
-	//	See issue #2
-	//
-	if (!!!global.FileReader) {
-		async = false;
-		global.FileReader = global.FileReaderSync;
-	}
-	
-	//
-	// Some browsers have a vendor prefix on slice
-	//
-	if (!!!Blob.prototype.slice) {
-		Blob.prototype.slice = Blob.prototype.webkitSlice || Blob.prototype.mozSlice;
-	}
-
-	return function(callback) {
-		
-		
-		//
-		// responds with: {success: true|false, result: <Object>}
-		//
-		this.hash = function(blob) {
-			
-			var current_part,
-				md5 = new global.SparkMD5(),
-				reader = new global.FileReader(),
-				part_number = 0,
-				length = Math.ceil(blob.size / part_size),
-				fail = function() {
-					callback({
-						success: false,
-						result: 'file read failed'
-					});
-				},
-				hashData = function(e) {
-					md5.appendBinary(e.target.result);
-					if(part_number * part_size >= blob.size) {
-						callback({
-							success: true,
-							result: md5.end()
-						});
-					} else {
-						processPart();
-					}
-				},
-				processPart = function() {
-					var endbyte = 0;
-					
-					part_number += 1;
-					
-					if (blob.size > part_size) {		// If blob bigger then part_size we will slice it up
-						endbyte = part_number * part_size;
-						if (endbyte > blob.size)
-							endbyte = blob.size;
-							
-						current_part = blob.slice((part_number - 1) * part_size, endbyte);
-					} else {
-						current_part = blob;
-					}
-					
-					if(async)
-						reader.readAsArrayBuffer(current_part);
-					else {
-						setTimeout(function() {
-							try {
-								hashData({
-									target: {
-										result: reader.readAsArrayBuffer(current_part)
-									}
-								});
-							} catch (e) {
-								fail();
-							}
-						}, 1);
-					}
-						
-				};
-			
-			
-			if(async) {
-				reader.onload = hashData;
-				reader.onerror = fail;
-				reader.onabort = fail;
-			}
-			
-			
-			processPart();
-		};
-	};
-	
-})(this);
-
+
+
+var CondoMD5Hasher = (function(global) {
+	
+	var part_size = 1048576,	// This is the amount of the file we read into memory as we are building the hash (1mb)
+		async = true,
+		newReader = !!navigator.userAgent.toLowerCase().match(/opera/);	// Opera bug (opera can only use a reader once)
+		
+	
+	//
+	// Firefox does not have FileReader in webworkers? WTF
+	//	See issue #2
+	//
+	if (!!!global.FileReader) {
+		async = false;
+		global.FileReader = global.FileReaderSync;
+	}
+	
+	//
+	// Some browsers have a vendor prefix on slice
+	//
+	if (!!!Blob.prototype.slice) {
+		Blob.prototype.slice = Blob.prototype.webkitSlice || Blob.prototype.mozSlice;
+	}
+
+	return function(callback, inWorker) {
+		
+		
+		//
+		// Opera claims to have async readers in webworkers however it is actually just
+		//	a synchronous reader in disguise
+		//
+		if (newReader && inWorker) {
+			async = false;
+			global.FileReader = global.FileReaderSync || global.FileReader;
+		}
+		
+		
+		//
+		// responds with: {success: true|false, result: <Object>}
+		//
+		this.hash = function(blob) {
+			
+			var current_part,
+				md5 = new global.SparkMD5.ArrayBuffer(),
+				part_number = 0,
+				length = Math.ceil(blob.size / part_size),
+				reader,
+				
+				fail = function() {
+					callback({
+						success: false,
+						result: 'file read failed'
+					});
+				},
+				
+				hashData = function(e) {
+					md5.append(e.target.result);
+					if(part_number * part_size >= blob.size) {
+						callback({
+							success: true,
+							result: md5.end()
+						});
+					} else {
+						if (newReader) configureReader();
+						processPart();
+					}
+				},
+				
+				processPart = function() {
+					var endbyte = 0;
+					
+					part_number += 1;
+					
+					if (blob.size > part_size) {		// If blob bigger then part_size we will slice it up
+						endbyte = part_number * part_size;
+						if (endbyte > blob.size)
+							endbyte = blob.size;
+							
+						current_part = blob.slice((part_number - 1) * part_size, endbyte);
+					} else {
+						current_part = blob;
+					}
+					
+					if(async)
+						reader.readAsArrayBuffer(current_part);
+					else {
+						setTimeout(function() {
+							try {
+								hashData({
+									target: {
+										result: reader.readAsArrayBuffer(current_part)
+									}
+								});
+							} catch (e) {
+								fail();
+							}
+						}, 0);
+					}
+						
+				},
+				
+				configureReader = function() {
+					reader = new global.FileReader();
+					if(async) {
+						reader.onload = hashData;
+						reader.onerror = fail;
+						reader.onabort = fail;
+					}
+				};
+			
+			
+			configureReader();
+			processPart();
+		};
+	};
+	
+})(this);
+

data/app/assets/javascripts/condo/md5/spark-md5.js

@@ -1,83 +1,6 @@
 /*jshint bitwise:false*/
 /*global unescape*/
 
-/**
- * SparkMD5 is a fast md5 implementation of the MD5 algorithm.
- * This script is based in the JKM md5 library which is the
- * fastest algorithm around (see: http://jsperf.com/md5-shootout/7).
- *
- * NOTE: Please disable Firebug while testing this script!
- *       Firebug consumes a lot of memory and CPU and slows down by a great margin.
- *       Opera Dragonfly also slows down by a great margin.
- *       Safari/Chrome developer tools seems not to slow it down.
- *
- * Improvements over the JKM md5 library:
- *
- * - Functionality wrapped in a closure
- * - Object oriented library
- * - Incremental md5 (see bellow)
- * - Validates using jslint
- *
- * Incremental md5 performs a lot better for hashing large ammounts of data, such as
- * files. One could read files in chunks, using the FileReader & Blob's, and append
- * each chunk for md5 hashing while keeping memory usage low. See example bellow.
- *
- * @example
- *
- * Normal usage:
- *
- *    var hexHash = SparkMD5.hash('Hi there');       // hex hash
- *    var rawHash = SparkMD5.hash('Hi there', true); // raw hash
- *
- * Incremental usage:
- *
- *    var spark = new SparkMD5();
- *    spark.append('Hi');
- *    spark.append(' there');
- *    var hexHash = spark.end();                    // hex hash
- *    var rawHash = spark.end(true);                // raw hash
- *
- * Hash a file incrementally:
- *
- *   NOTE: If you test the code bellow using the file:// protocol in chrome you must start the browser with -allow-file-access-from-files argument.
- *         Please see: http://code.google.com/p/chromium/issues/detail?id=60889
- *
- *   document.getElementById("file").addEventListener("change", function() {
- *
- *       var fileReader = new FileReader(),
- *           blobSlice = File.prototype.slice || File.prototype.mozSlice || File.prototype.webkitSlice,
- *           file = document.getElementById("file").files[0],
- *           chunkSize = 2097152,                           // read in chunks of 2MB
- *           chunks = Math.ceil(file.size / chunkSize),
- *           currentChunk = 0,
- *           spark = new SparkMD5();
- *
- *       fileReader.onload = function(e) {
- *           console.log("read chunk nr", currentChunk + 1, "of", chunks);
- *           spark.appendBinary(e.target.result);           // append binary string
- *           currentChunk++;
- *
- *           if (currentChunk < chunks) {
- *               loadNext();
- *           }
- *           else {
- *              console.log("finished loading");
- *              console.info("computed hash", spark.end()); // compute hash
- *           }
- *       };
- *
- *       function loadNext() {
- *           var start = currentChunk * chunkSize,
- *               end = start + chunkSize >= file.size ? file.size : start + chunkSize;
- *
- *           fileReader.readAsBinaryString(blobSlice.call(file, start, end));
- *       };
- *
- *       loadNext();
- *   });
- *
- * @TODO: Add native support for reading files? Maybe add it as an extension?
- */
 (function (factory) {
     if (typeof exports === 'object') {
         // Node/CommonJS
@@ -99,32 +22,6 @@
 }(function (undefined) {
 
     'use strict';
-    
-    
-    /* converts strings to array buffers
-     * From: http://updates.html5rocks.com/2012/06/How-to-convert-ArrayBuffer-to-and-from-String
-     */
-    var str2ab = function (str) {
-        var buf = new ArrayBuffer(str.length * 2), // 2 bytes for each char
-            bufView = new Uint16Array(buf);
-        for (var i = 0, strLen = str.length; i < strLen; i++) {
-            bufView[i] = str.charCodeAt(i);
-        }
-        return buf;
-    },
-    
-    
-    abConcat = function(first, second)
-    {
-        var firstLength = first.length,
-            result = new Uint8Array(firstLength + second.byteLength);
-
-        result.set(first);
-        result.set(new Uint8Array(second), firstLength);
-
-        return result;
-    },
-    
 
     ////////////////////////////////////////////////////////////////////////////
 
@@ -135,8 +32,13 @@
      * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
      * @see http://jsperf.com/md5-shootout/7
      */
-    
-    add32 = function (a, b) {
+
+    /* this function is much faster,
+      so if possible we use it. Some IEs
+      are the only ones I know of that
+      need the idiotic second function,
+      generated by an if clause.  */
+    var add32 = function (a, b) {
         return (a + b) & 0xFFFFFFFF;
     },
 
@@ -145,23 +47,23 @@
         return add32((a << s) | (a >>> (32 - s)), b);
     },
 
-    ff = function(a, b, c, d, x, s, t) {
+    ff = function (a, b, c, d, x, s, t) {
         return cmn((b & c) | ((~b) & d), a, b, x, s, t);
     },
 
-    gg = function(a, b, c, d, x, s, t) {
+    gg = function (a, b, c, d, x, s, t) {
         return cmn((b & d) | (c & (~d)), a, b, x, s, t);
     },
 
-    hh = function(a, b, c, d, x, s, t) {
+    hh = function (a, b, c, d, x, s, t) {
         return cmn(b ^ c ^ d, a, b, x, s, t);
     },
 
-    ii = function(a, b, c, d, x, s, t) {
+    ii = function (a, b, c, d, x, s, t) {
         return cmn(c ^ (b | (~d)), a, b, x, s, t);
     },
 
-    md5cycle = function(x, k) {
+    md5cycle = function (x, k) {
         var a = x[0],
             b = x[1],
             c = x[2],
@@ -241,16 +143,42 @@
         x[3] = add32(d, x[3]);
     },
 
-    md5blk = function(s) { /* I figured global was faster.   */
+    /* there needs to be support for Unicode here,
+       * unless we pretend that we can redefine the MD-5
+       * algorithm for multi-byte characters (perhaps
+       * by adding every four 16-bit characters and
+       * shortening the sum to 32 bits). Otherwise
+       * I suggest performing MD-5 as if every character
+       * was two bytes--e.g., 0040 0025 = @%--but then
+       * how will an ordinary MD-5 sum be matched?
+       * There is no way to standardize text to something
+       * like UTF-8 before transformation; speed cost is
+       * utterly prohibitive. The JavaScript standard
+       * itself needs to look at this: it should start
+       * providing access to strings as preformed UTF-8
+       * 8-bit unsigned value arrays.
+       */
+    md5blk = function (s) {
         var md5blks = [],
             i; /* Andy King said do it this way. */
+
+        for (i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    },
+
+    md5blk_array = function (a) {
+        var md5blks = [],
+            i; /* Andy King said do it this way. */
+
         for (i = 0; i < 64; i += 4) {
-            md5blks[i >> 2] = s[i] + (s[i + 1] << 8) + (s[i + 2] << 16) + (s[i + 3] << 24);
+            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
         }
         return md5blks;
     },
 
-    md51 = function(s) {
+    md51 = function (s) {
         var n = s.length,
             state = [1732584193, -271733879, -1732584194, 271733878],
             i,
@@ -261,25 +189,61 @@
             hi;
 
         for (i = 64; i <= n; i += 64) {
-            md5cycle(state, md5blk(s.subarray(i - 64, i)));
+            md5cycle(state, md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        length = s.length;
+        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+        }
+        tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+        if (i > 55) {
+            md5cycle(state, tail);
+            for (i = 0; i < 16; i += 1) {
+                tail[i] = 0;
+            }
         }
-        
-        //
+
+        // Beware that the final length might not fit in 32 bits so we take care of that
+        tmp = n * 8;
+        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+        lo = parseInt(tmp[2], 16);
+        hi = parseInt(tmp[1], 16) || 0;
+
+        tail[14] = lo;
+        tail[15] = hi;
+
+        md5cycle(state, tail);
+        return state;
+    },
+
+    md51_array = function (a) {
+        var n = a.length,
+            state = [1732584193, -271733879, -1732584194, 271733878],
+            i,
+            length,
+            tail,
+            tmp,
+            lo,
+            hi;
+
+        for (i = 64; i <= n; i += 64) {
+            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+        }
+
         // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
         // containing the last element of the parent array if the sub array specified starts
         // beyond the length of the parent array - weird.
         // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
-        //
-        if((i - 64) < n)
-            s = s.subarray(i - 64);
-        else
-            s = new Uint8Array(0);
-        
-        length = s.length;
+        a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+        length = a.length;
         tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
         for (i = 0; i < length; i += 1) {
-            tail[i >> 2] |= s[i] << ((i % 4) << 3);
+            tail[i >> 2] |= a[i] << ((i % 4) << 3);
         }
+
         tail[i >> 2] |= 0x80 << ((i % 4) << 3);
         if (i > 55) {
             md5cycle(state, tail);
@@ -298,12 +262,13 @@
         tail[15] = hi;
 
         md5cycle(state, tail);
+
         return state;
     },
 
     hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
 
-    rhex = function(n) {
+    rhex = function (n) {
         var s = '',
             j;
         for (j = 0; j < 4; j += 1) {
@@ -312,7 +277,7 @@
         return s;
     },
 
-    hex = function(x) {
+    hex = function (x) {
         var i;
         for (i = 0; i < x.length; i += 1) {
             x[i] = rhex(x[i]);
@@ -320,10 +285,12 @@
         return x.join('');
     },
 
-    md5 = function(s) {
+    md5 = function (s) {
         return hex(md51(s));
     },
 
+
+
     ////////////////////////////////////////////////////////////////////////////
 
     /**
@@ -335,21 +302,35 @@
     SparkMD5 = function () {
         // call reset to init the instance
         this.reset();
-    };    
-    
+    };
+
+
+    // In some cases the fast add32 function cannot be used..
+    if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+        add32 = function (x, y) {
+            var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+                msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+            return (msw << 16) | (lsw & 0xFFFF);
+        };
+    }
+
 
     /**
      * Appends a string.
-     * Converts to a byte array.
+     * A conversion will be applied if an utf8 string is detected.
      *
      * @param {String} str The string to be appended
      *
      * @return {SparkMD5} The instance itself
      */
     SparkMD5.prototype.append = function (str) {
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
 
-        // convert to array then append as binary
-        this.appendBinary(str2ab(str));
+        // then append as binary
+        this.appendBinary(str);
 
         return this;
     };
@@ -357,26 +338,22 @@
     /**
      * Appends a binary string.
      *
-     * @param {ArrayBuffer} contents The binary string to be appended
+     * @param {String} contents The binary string to be appended
      *
      * @return {SparkMD5} The instance itself
      */
     SparkMD5.prototype.appendBinary = function (contents) {
-        var buff = abConcat(this._buff, contents),
-            length = buff.length,
+        this._buff += contents;
+        this._length += contents.length;
+
+        var length = this._buff.length,
             i;
-            
-        this._length += contents.byteLength;
-		
+
         for (i = 64; i <= length; i += 64) {
-            md5cycle(this._state, md5blk(buff.subarray(i - 64, i)));
+            md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
         }
 
-		// Avoids IE10 weirdness
-		if((i - 64) < length)
-            this._buff = buff.subarray(i - 64);
-        else
-            this._buff = new Uint8Array(0);
+        this._buff = this._buff.substr(i - 64);
 
         return this;
     };
@@ -393,16 +370,34 @@
     SparkMD5.prototype.end = function (raw) {
         var buff = this._buff,
             length = buff.length,
-            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
             i,
-            ret,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    /**
+     * Finish the final calculation based on the tail.
+     *
+     * @param {Array}  tail   The tail (will be modified)
+     * @param {Number} length The length of the remaining buffer
+     */
+    SparkMD5.prototype._finish = function (tail, length) {
+        var i = length,
             tmp,
             lo,
             hi;
 
-        for (i = 0; i < length; i += 1) {
-            tail[i >> 2] |= buff[i] << ((i % 4) << 3);
-        }
         tail[i >> 2] |= 0x80 << ((i % 4) << 3);
         if (i > 55) {
             md5cycle(this._state, tail);
@@ -421,12 +416,6 @@
         tail[14] = lo;
         tail[15] = hi;
         md5cycle(this._state, tail);
-
-        ret = !!raw ? this._state : hex(this._state);
-
-        this.reset();
-
-        return ret;
     };
 
     /**
@@ -435,7 +424,7 @@
      * @return {SparkMD5} The instance itself
      */
     SparkMD5.prototype.reset = function () {
-        this._buff = new Uint8Array(0);
+        this._buff = "";
         this._length = 0;
         this._state = [1732584193, -271733879, -1732584194, 271733878];
 
@@ -452,8 +441,10 @@
         delete this._length;
     };
 
+
     /**
-     * Performs the md5 hash on a string as utf16
+     * Performs the md5 hash on a string.
+     * A conversion will be applied if utf8 string is detected.
      *
      * @param {String}  str The string
      * @param {Boolean} raw True to get the raw result, false to get the hex result
@@ -461,21 +452,145 @@
      * @return {String|Array} The result
      */
     SparkMD5.hash = function (str, raw) {
-        var hash = md51(new Uint8Array(str2ab(str)));
+        // converts the string to utf8 bytes if necessary
+        if (/[\u0080-\uFFFF]/.test(str)) {
+            str = unescape(encodeURIComponent(str));
+        }
+
+        var hash = md51(str);
 
         return !!raw ? hash : hex(hash);
     };
 
     /**
-     * Performs the md5 hash on a typed array.
+     * Performs the md5 hash on a binary string.
      *
-     * @param {ArrayBuffer}  content The binary array
+     * @param {String}  content The binary string
      * @param {Boolean} raw     True to get the raw result, false to get the hex result
      *
      * @return {String|Array} The result
      */
     SparkMD5.hashBinary = function (content, raw) {
-        var hash = md51(new Uint8Array(content));
+        var hash = md51(content);
+
+        return !!raw ? hash : hex(hash);
+    };
+
+    /**
+     * SparkMD5 OOP implementation for array buffers.
+     *
+     * Use this class to perform an incremental md5 ONLY for array buffers.
+     */
+    SparkMD5.ArrayBuffer = function () {
+        // call reset to init the instance
+        this.reset();
+    };
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * Appends an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array to be appended
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+        // TODO: we could avoid the concatenation here but the algorithm would be more complex
+        //       if you find yourself needing extra performance, please make a PR.
+        var buff = this._concatArrayBuffer(this._buff, arr),
+            length = buff.length,
+            i;
+
+        this._length += arr.byteLength;
+
+        for (i = 64; i <= length; i += 64) {
+            md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+        }
+
+        // Avoids IE10 weirdness (documented above)
+        this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+        return this;
+    };
+
+    /**
+     * Finishes the incremental computation, reseting the internal state and
+     * returning the result.
+     * Use the raw parameter to obtain the raw result instead of the hex one.
+     *
+     * @param {Boolean} raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+        var buff = this._buff,
+            length = buff.length,
+            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            i,
+            ret;
+
+        for (i = 0; i < length; i += 1) {
+            tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+        }
+
+        this._finish(tail, length);
+        ret = !!raw ? this._state : hex(this._state);
+
+        this.reset();
+
+        return ret;
+    };
+
+    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+    /**
+     * Resets the internal state of the computation.
+     *
+     * @return {SparkMD5.ArrayBuffer} The instance itself
+     */
+    SparkMD5.ArrayBuffer.prototype.reset = function () {
+        this._buff = new Uint8Array(0);
+        this._length = 0;
+        this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+        return this;
+    };
+
+    /**
+     * Releases memory used by the incremental buffer and other aditional
+     * resources. If you plan to use the instance again, use reset instead.
+     */
+    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+    /**
+     * Concats two array buffers, returning a new one.
+     *
+     * @param  {ArrayBuffer} first  The first array buffer
+     * @param  {ArrayBuffer} second The second array buffer
+     *
+     * @return {ArrayBuffer} The new array buffer
+     */
+    SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+        var firstLength = first.length,
+            result = new Uint8Array(firstLength + second.byteLength);
+
+        result.set(first);
+        result.set(new Uint8Array(second), firstLength);
+
+        return result;
+    };
+
+    /**
+     * Performs the md5 hash on an array buffer.
+     *
+     * @param {ArrayBuffer} arr The array buffer
+     * @param {Boolean}     raw True to get the raw result, false to get the hex result
+     *
+     * @return {String|Array} The result
+     */
+    SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+        var hash = md51_array(new Uint8Array(arr));
 
         return !!raw ? hash : hex(hash);
     };